/*
 * $Id$
 * Copyright © 2007-2020 gingko - https://www.gingko.ovh/
 *
 * This file is part of Pouchin TV Mod, a free DVB-T viewer.
 * See https://www.pouchintv.fr/ for updates.
 *
 * Pouchin TV Mod is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Pouchin TV Mod is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 *
 * Most files of this project have been changed from the Pouchin TV
 * project (Copyright (C) 2006 Pouchin <pouchinteve@free.fr>),
 * to use with a modified version of this software.
 * See http://pouchinteve.free.fr/ for the original project.
 */

/** \file
 *	\brief Gestion de la surface superposée à l'image pour les besoins de l'OSD.
 *
 *	Définitions des interfaces nécessaires à construire une surface
 *  de rendu de texte et autres objets, selon des méthodes variables
 *  (la méthode de base étant la bibliothèque GDI, les alternatives
 *  possibles étant les diverses versions de Direct3D).
 **/

#pragma once

#include "osd_objects.h"
#include "rctutils.h"

NAMESPACE_OSD_BEGIN

// ====================================================================================
// Définitions
// ====================================================================================

/**
 * Couleur de fond de la fenêtre, remplacée par l'image
 * \note L'utilisation de RGB(1,1,1) plutôt que RGB(0,0,0) (= noir parfait) vise à éviter que les
 * caractères (noirs) des textes des dialogues superposés à la vidéo deviennent transparents dans
 * certains mode de cette vidéo. Précédemment, RGB(0,0,1) était utilisé, mais pour une raison
 * inconnue, cette valeur semble poser des problèmes en EVR.
 **/
#define colorKey			RGB(1,1,1)

// ====================================================================================

/// Énumération des types de couches utilisables pour l'OSD
enum LayerTypes
{
	lt_GDI,		//!< GDI (basique), directement dans la fenêtre
	lt_BMP,		//!< GDI via bitmap
	lt_D3D9		//!< Direct3D9
};

// ====================================================================================

/**
 * Calcul du rectangle client de la fenêtre (hors barre d'état)
 **/
RECT CalcCliRect();

// ====================================================================================
// Interface d'allocation des polices de caractères
// ====================================================================================

/// Classe d'assistance à la gestion de la police OSD
class COsdFontAllocator
{
protected:
	LONG	nFntHgt;	//!< Hauteur de la police utilisée par l'OSD

	/// Constructeur
	COsdFontAllocator() :
		nFntHgt(0)
	{
	}

	/// Réinitialisation de la police de caractères
	virtual void Reset() = 0;

public:
	/// Création de l'instance correspondant au type de couche OSD qu'on utilise
	static COsdFontAllocator *	CreateInstance(LayerTypes eType);

	/// Obtenir la taille (hauteur) de police couramment définie
	LONG Size() const {
			return nFntHgt; }

	/**
	 * \brief Réinitialisation de la police de caractères en vue de changement de taille
	 * \param[in]	nNewHgt	Taille à utiliser lorsque la police sera recréée
	 **/
	void SetSize(LONG nNewHgt)
	{
		if (nNewHgt != nFntHgt) {
			Reset();
			nFntHgt = nNewHgt;
		}
	}

	/// Destructeur
	virtual ~COsdFontAllocator() {
				}
};

// ====================================================================================
// Interface de gestion du plan de dessin de l'OSD
// ====================================================================================

/// Gestion du plan de dessin de l'OSD, classe de base abstraite
class COsdLayer
{
protected:
	SIZE				m_sSize;		//!< Taille attendue de l'objet
	bool				m_bNotEmpty;	//!< \p true si au moins un objet est affiché dans l'OSD
public:

	COsdLayer() :
		m_sSize(SIZE()),
		m_bNotEmpty(false)
	{
	}

	/**
	 * Création d'une instance destinée à dessiner directement dans le rectangle client
	 * de la fenêtre.
	 * \param[in]	hDC	"Device context", à utiliser seulement si on dispose de la valeur
	 *					fournie par \p WM_PAINT; sinon, mettre NULL.
	 * \return		Pointeur sur l'objet créé.
	 **/
	static COsdLayer *	CreateWinInstance(HDC hDC);

	/**
	 * Création d'une instance dont le type est défini par \p eType.
	 * \param[in]	eType	Type de couche OSD à créer.
	 * \return		Pointeur sur l'objet créé.
	 **/
	static COsdLayer *	CreateInstance(LayerTypes eType);

	/// Affichage d'un objet OSD
	/// \param[in]	cOsdObj	Référence sur l'objet à afficher
	HRESULT				Draw(COsdObject & cObj);

	virtual HRESULT		Draw(COsdObject & cOsd, const RECT & sRct) = 0;

	/// Retourne \p true si la couche OSD n'est pas vierge
	bool				notEmpty() const {
							return m_bNotEmpty; }

	/// Vérifie (en retournant \p true) que la classe a été correctement initialisée
	virtual bool		layer_ok() const = 0;

	/// Vérifie (en retournant \p true) qu'une surface utilisable existe
	virtual bool		layer_set() const = 0;

	/// Création d'un allocateur de polices de caractères dans le type qui correspond
	/// à la méthode de gestion instanciée
	virtual COsdFontAllocator *
						CreateFontAllocator() = 0;

	/// Initialisation des prérequis au fonctionnement de l'interface
	virtual HRESULT		Initialize() = 0;

	/// Création d'une surface de dimensions définies (remplacement de l'éventuelle surface précédente)
	virtual HRESULT		Create() = 0;

	/// Destruction de la surface
	virtual void		Reset() = 0;

	/// Effacement de la surface existante
	virtual HRESULT		Erase() = 0;

	/// Obtenir la taille courante de la surface
	virtual SIZE		GetSize() const = 0;

	/// Définir une nouvelle taille, réinitialiser si différente de la taille actuelle
	void				SetSize(SIZE sNewSize) {
							if (sNewSize != GetSize()) Reset();
							m_sSize = sNewSize;	}

	/// Présentation de la surface dans un rendu vidéo VMR9
	virtual HRESULT		Present(IVMRMixerBitmap9 * pBmp) = 0;

	/// Présentation de la surface dans un rendu vidéo EVR
	virtual HRESULT		Present(IMFVideoMixerBitmap * pBmp) = 0;

	/// Destructeur
	virtual ~COsdLayer() {
				}
};

typedef shared_ptr<class COsdLayer>	COsdLayerPtr;

// ====================================================================================
// Allocateur de polices de caractères, méthode GDI
// ====================================================================================

/// Gestion GDI du plan de dessin de l'OSD
class COsdGdiFontAllocator : public COsdFontAllocator
{
	HFONT	hf;			//!< Handle de la police utilisée
public:
	/// Constructeur
	COsdGdiFontAllocator() :
		hf(NULL)
	{
	}

	/// Suppression de la police courante (par destructeur, ou bien après
	/// changement de taille, pour forcer la création d'une nouvelle)
	virtual void Reset() {
		if (hf) DeleteObject(hf); hf = NULL; }

	/// Obtenir la police courante (création si nécessaire)
	HFONT GetFont() {
		if (!hf && nFntHgt != 0) {
			LOGFONT sLf = {
				nFntHgt			// lfHeight
				// le reste à zéro (implicite)
			};
			myprintf(COLR(HYELLOW, TEXT("CreateFontIndirect, hgt=%i")) EOL, nFntHgt);
			hf = CreateFontIndirect(&sLf);
		}
		return hf;
	}

	/// Destructeur
	virtual ~COsdGdiFontAllocator() {
		Reset(); }
};

NAMESPACE_OSD_END

// ====================================================================================