//
// CTitleOverlayProp.cpp
//

#include "streams.h"

// Eliminate two expected level 4 warnings from the Microsoft compiler.
// The class does not have an assignment or copy operator, and so cannot
// be passed by value.  This is normal.  This file compiles clean at the
// highest (most picky) warning level (-W4).
#pragma warning(disable: 4511 4512)

#include <windowsx.h>
#include <commctrl.h>
#include <olectl.h>
#include <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <tchar.h>

#include "Resource.h"            // ids used in the dialog
#include "CTitleOverlayProp.h"    // our own class
#include "OverlayDefs.h"

//
// CreateInstance
//
// Override CClassFactory method.
// Set lpUnk to point to an IUnknown interface on a new NullIPProperties object
// Part of the COM object instantiation mechanism
//
CUnknown * WINAPI CTitleOverlayProp::CreateInstance(LPUNKNOWN lpunk, HRESULT *phr)
{
	CUnknown *punk = new CTitleOverlayProp(lpunk, phr);
	if (punk == NULL) 
	{
		*phr = E_OUTOFMEMORY;
	}
	return punk;
}

// Constructs and initialises a object
CTitleOverlayProp::CTitleOverlayProp(LPUNKNOWN pUnk, HRESULT *phr)
    : CBasePropertyPage(NAME("Title Overlay Property Page"),pUnk,
        IDD_FILTER_PROP, IDS_INFO)
{
	ASSERT(phr);
	mIOverlay      = NULL;
	mIsFontChanged = FALSE;
} // CGraphInfoProp


// Override CBasePropertyPage method.
// Handles the messages for our property window
BOOL CTitleOverlayProp::OnReceiveMessage(HWND hwnd,
                                        UINT uMsg,
                                        WPARAM wParam,
                                        LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
			// Get windows' handles
			m_hOverlayType    = GetDlgItem(hwnd, IDC_COMBO_OVERLAY_TYPE);
			m_hEditTilte      = GetDlgItem(hwnd, IDC_EDIT_TITLE);
			m_hEditStartX     = GetDlgItem(hwnd, IDC_EDIT_STARTX);
			m_hEditStartY     = GetDlgItem(hwnd, IDC_EDIT_STARTY);
			m_hEditStartTime  = GetDlgItem(hwnd, IDC_EDIT_STARTTIME);
			m_hEditEndTime    = GetDlgItem(hwnd, IDC_EDIT_ENDTIME);
			m_hEditColorR     = GetDlgItem(hwnd, IDC_EDIT_COLORR);
			m_hEditColorG     = GetDlgItem(hwnd, IDC_EDIT_COLORG);
			m_hEditColorB     = GetDlgItem(hwnd, IDC_EDIT_COLORB);
			break;
        }

        case WM_COMMAND:
        {
			if (HIWORD(wParam) == BN_CLICKED)
			{
				switch (LOWORD(wParam))
				{
					case IDC_BUTTON_CHANGE_FONT:
						OnButtonChangeFont();
						break;
				}
			}
			SetDirty();
            break;
        }

    }
    return CBasePropertyPage::OnReceiveMessage(hwnd,uMsg,wParam,lParam);
} // OnReceiveMessage


// Override CBasePropertyPage method.
// Notification of which object this property page should display.
// We query the object for the IFltTrace interface.
HRESULT CTitleOverlayProp::OnConnect(IUnknown *pUnknown)
{
	HRESULT hr = pUnknown->QueryInterface(IID_ITitleOverlay, (void **) &mIOverlay);
	if (FAILED(hr))
	{
		return E_NOINTERFACE;
	}
	ASSERT(mIOverlay);

	return NOERROR;
} // OnConnect


// Override CBasePropertyPage method.
// Release the private interface, release the upstream pin.
HRESULT CTitleOverlayProp::OnDisconnect()
{
	// Release of Interface
	if (mIOverlay == NULL)
		return E_UNEXPECTED;
	mIOverlay->Release();
	mIOverlay = NULL;

	return NOERROR;
} // OnDisconnect


// We are being activated
HRESULT CTitleOverlayProp::OnActivate()
{
	FillOverlayTypeComboBox();
	ReflectOverlayType();
	ReflectOverlayStyle();
	ReflectTitle();
	ReflectTitleStartPosition();
	ReflectTitleDuration();
	ReflectTitleColor();
	ReflectTitleFont();
	return NOERROR;
} // Activate


// Changes made should be kept
HRESULT CTitleOverlayProp::OnApplyChanges()
{
	EnterOverlayType();  // This must be first invoked!!
	EnterOverlayStyle();
	EnterTitle();
	EnterTitleStartPosition();
	EnterTitleDuration();
	EnterTitleColor();
	EnterTitleFont();
	return NOERROR;
} // OnApplyChanges

//
// Sets m_hrDirtyFlag and notifies the property page site of the change
void CTitleOverlayProp::SetDirty()
{
    m_bDirty = TRUE;
    if (m_pPageSite)
    {
        m_pPageSite->OnStatusChange(PROPPAGESTATUS_DIRTY);
    }
} // SetDirty

void CTitleOverlayProp::FillOverlayTypeComboBox(void)
{
	const char * szType[] = 
	{
		"None", "Static", "System Time", "Scroll Top", "Scroll Bottom"
	};
	int enType[] = 
	{
		OT_NONE, OT_STATIC, OT_SYSTIME, OT_SCROLL_TOP, OT_SCROLL_BOTTOM
	};
	const int nCount = sizeof(szType) / sizeof(szType[0]);

	// Reset the combo box content
	SendMessage(m_hOverlayType, CB_RESETCONTENT, 0, 0);
	for (int i = 0; i < nCount; i++)
	{
		SendMessage(m_hOverlayType, CB_ADDSTRING, 0, (LPARAM)szType[i]);
		SendMessage(m_hOverlayType, CB_SETITEMDATA, i, (LPARAM)enType[i]);
	}
}

int CTitleOverlayProp::GetOverlayTypeComboIndex(int inType)
{
	// Set the first item selected
	int  nCount = SendMessage(m_hOverlayType, CB_GETCOUNT, 0, 0);
	for (int i = 0; i < nCount; i++)
	{
		int nItemData = (int) SendMessage(m_hOverlayType, CB_GETITEMDATA, i, 0);
		if (nItemData == inType)
		{
			return i;
		}
	}
	return 0;
}

void CTitleOverlayProp::ReflectOverlayType(void)
{
	long   overlayType = 0;
	mIOverlay->get_TitleOverlayType(&overlayType);
	SendMessage(m_hOverlayType, CB_SETCURSEL, GetOverlayTypeComboIndex(overlayType), 0);
}

void CTitleOverlayProp::ReflectOverlayStyle(void)
{
	BOOL  usingCover = TRUE;
	mIOverlay->get_TitleOverlayStyle(&usingCover);
	CheckRadioButton(m_hwnd, IDC_RADIO_BYCOVER, IDC_RADIO_BYREVERSE, 
		usingCover ? IDC_RADIO_BYCOVER : IDC_RADIO_BYREVERSE);
}

void CTitleOverlayProp::ReflectTitle(void)
{
	int  titleLength = 0;
	mIOverlay->get_Title(NULL, &titleLength);
	if (titleLength > 0)
	{
		char * szTitle = new char[titleLength];
		mIOverlay->get_Title(szTitle, &titleLength);
		SetWindowText(m_hEditTilte, szTitle);
		delete[] szTitle;
	}
}

void CTitleOverlayProp::ReflectTitleStartPosition(void)
{
	POINT   startPos;
	mIOverlay->get_TitleStartPosition(&startPos);
	char    szPoint[100];
	sprintf(szPoint, "%d", startPos.x);
	SetWindowText(m_hEditStartX, szPoint);
	sprintf(szPoint, "%d", startPos.y);
	SetWindowText(m_hEditStartY, szPoint);
}

void CTitleOverlayProp::ReflectTitleDuration(void)
{
	double  startTime = 0, endTime = 0; 
	mIOverlay->get_TitleDuration(&startTime, &endTime);
	char    szDuration[100];
	sprintf(szDuration, "%.2f", startTime);
	SetWindowText(m_hEditStartTime, szDuration);
	sprintf(szDuration, "%.2f", endTime);
	SetWindowText(m_hEditEndTime, szDuration);
}

void CTitleOverlayProp::ReflectTitleColor(void)
{
	BYTE  colorR, colorG, colorB;	
	mIOverlay->get_TitleColor(&colorR, &colorG, &colorB);
	char  szColor[100];
	sprintf(szColor, "%d", colorR);
	SetWindowText(m_hEditColorR, szColor);
	sprintf(szColor, "%d", colorG);
	SetWindowText(m_hEditColorG, szColor);
	sprintf(szColor, "%d", colorB);
	SetWindowText(m_hEditColorB, szColor);
	mTitleColor = RGB(colorR, colorG, colorB);
}

void CTitleOverlayProp::ReflectTitleColor(BYTE inR, BYTE inG, BYTE inB)
{
	char  szColor[100];
	sprintf(szColor, "%d", inR);
	SetWindowText(m_hEditColorR, szColor);
	sprintf(szColor, "%d", inG);
	SetWindowText(m_hEditColorG, szColor);
	sprintf(szColor, "%d", inB);
	SetWindowText(m_hEditColorB, szColor);
}

void CTitleOverlayProp::ReflectTitleFont(void)
{
	mIOverlay->get_TitleFont(&mTitleFont);
}

void CTitleOverlayProp::EnterOverlayType(void)
{
	int nSelected = SendMessage(m_hOverlayType, CB_GETCURSEL, 0, 0);
	int nType     = SendMessage(m_hOverlayType, CB_GETITEMDATA, nSelected, 0);
	mIOverlay->put_TitleOverlayType(nType);
}

void CTitleOverlayProp::EnterOverlayStyle(void)
{
	int  nChecked = IsDlgButtonChecked(m_hwnd, IDC_RADIO_BYCOVER);
	mIOverlay->put_TitleOverlayStyle(nChecked);
}

void CTitleOverlayProp::EnterTitle(void)
{
	char szTitle[2000];
	if (GetWindowText(m_hEditTilte, szTitle, 2000))
	{
		mIOverlay->put_Title(szTitle, strlen(szTitle));
	}
	else
	{
		mIOverlay->put_Title("", 0);
	}
}

void CTitleOverlayProp::EnterTitleStartPosition(void)
{
	POINT   startPos;	
	char    szPos[100];
	GetWindowText(m_hEditStartX, szPos, 100);
	startPos.x = atoi(szPos);
	GetWindowText(m_hEditStartY, szPos, 100);
	startPos.y = atoi(szPos);
	mIOverlay->put_TitleStartPosition(startPos);
}

void CTitleOverlayProp::EnterTitleDuration(void)
{
	char    szDuration[100];
	GetWindowText(m_hEditStartTime, szDuration, 100);
	double startTime = atof(szDuration);
	GetWindowText(m_hEditEndTime, szDuration, 100);
	double endTime   = atof(szDuration);
	mIOverlay->put_TitleDuration(startTime, endTime);
}

void CTitleOverlayProp::EnterTitleColor(void)
{
	BYTE  colorR = 0, colorG = 0, colorB = 0;	
	char  szColor[100];
	GetWindowText(m_hEditColorR, szColor, 100);
	colorR = atoi(szColor);
	GetWindowText(m_hEditColorG, szColor, 100);
	colorG = atoi(szColor);
	GetWindowText(m_hEditColorB, szColor, 100);
	colorB = atoi(szColor);
	mIOverlay->put_TitleColor(colorR, colorG, colorB);
}

void CTitleOverlayProp::EnterTitleFont(void)
{
	if (mIsFontChanged)
	{
		mIOverlay->put_TitleFont(mTitleFont);
	}
}

void CTitleOverlayProp::OnButtonChangeFont(void)
{
	// Update the RGB values
	BYTE  colorR = 0, colorG = 0, colorB = 0;	
	char  szColor[100];
	GetWindowText(m_hEditColorR, szColor, 100);
	colorR = atoi(szColor);
	GetWindowText(m_hEditColorG, szColor, 100);
	colorG = atoi(szColor);
	GetWindowText(m_hEditColorB, szColor, 100);
	colorB = atoi(szColor);
	mTitleColor = RGB(colorR, colorG, colorB);

	CHOOSEFONT    cf;
	// Initialize CHOOSEFONT
	ZeroMemory(&cf, sizeof(CHOOSEFONT));
	cf.lStructSize = sizeof(CHOOSEFONT);
	cf.hInstance   = g_hInst;
	cf.hwndOwner   = m_hwnd;
	cf.lpLogFont   = &mTitleFont;
	cf.rgbColors   = mTitleColor;
	cf.Flags       = CF_SCREENFONTS | CF_EFFECTS | CF_INITTOLOGFONTSTRUCT;
	if (ChooseFont(&cf)) 
	{
		mIsFontChanged = TRUE;
		// Update the text color
		mTitleColor    = cf.rgbColors;
		ReflectTitleColor(GetRValue(mTitleColor), GetGValue(mTitleColor), GetBValue(mTitleColor));
	}
}