// ControlsSampleFrame.cpp
//
// (c)1998-2025 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "CommandBarsSample.h"
#include "MainFrm.h"
#include "ControlsSampleFrame.h"

#ifdef _DEBUG
#	define new DEBUG_NEW
#	undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

static UINT indicators[] = {
	ID_SEPARATOR, // status line indicator
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};

UINT gSaveAsID = ID_SAVEAS_XML;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//

BEGIN_MESSAGE_MAP(CControlComboBoxEditEx, CXTPMaskEditT<CXTPControlComboBoxEditCtrl>)
	ON_MASKEDIT_REFLECT()
	ON_WM_CREATE()
END_MESSAGE_MAP()

int CControlComboBoxEditEx::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	SetEditMask(_T("00:00:00:00"), _T("__:__:__:__"), _T("00:00:00:00"));

	return CXTPMaskEditT<CXTPControlComboBoxEditCtrl>::OnCreate(lpCreateStruct);
}

IMPLEMENT_XTP_CONTROL(CControlComboBoxEx, CXTPControlComboBox)

//////////////////////////////////////////////////////////////////////////
// CControlComboBoxPopup

IMPLEMENT_XTP_CONTROL(CControlComboBoxPopup, CXTPControlComboBox)

CString CControlComboBoxPopup::GetListBoxText() const
{
	CString str;
	str.LoadString(gSaveAsID);

	return str;
}

//////////////////////////////////////////////////////////////////////////
// CControlComboBoxCustomDraw

IMPLEMENT_XTP_CONTROL(CControlComboBoxCustomDraw, CXTPControlFontComboBox)

void CControlComboBoxCustomDraw::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
	CString strText;
	GetLBText(lpDrawItemStruct->itemID, strText);

	CRect rc(&lpDrawItemStruct->rcItem);

	_ASSERTE(lpDrawItemStruct->CtlType == ODT_LISTBOX);

	CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);

	BOOL bSelected					= lpDrawItemStruct->itemState & ODS_SELECTED;
	CXTPPaintManager* pPaintManager = GetPaintManager();

	COLORREF crOldTextColor = pDC->SetTextColor(
		pPaintManager->GetRectangleTextColor(bSelected, FALSE, TRUE, FALSE, FALSE, xtpBarTypePopup,
											 xtpBarPopup));

	if (bSelected)
		pPaintManager->DrawRectangle(pDC, rc, TRUE, FALSE, TRUE, FALSE, FALSE, xtpBarTypePopup,
									 xtpBarPopup);
	else
		pDC->FillSolidRect(rc, pPaintManager->GetXtremeColor(COLOR_WINDOW));

	CFont fnt;
	fnt.CreateFont(rc.Height(), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
				   OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH,
				   strText);

	CXTPFontDC font(pDC, &fnt);

	pDC->SetBkMode(TRANSPARENT);
	rc.left += XTP_DPI_X(3);
	pDC->DrawText(strText, rc, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);

	pDC->SetTextColor(crOldTextColor);
}

//////////////////////////////////////////////////////////////////////////
// CControlComboBoxDatePicker

#ifdef _XTP_INCLUDE_CALENDAR

class CControlComboBoxDatePickerPopupBar : public CXTPControlComboBoxPopupBar
{
	DECLARE_XTP_COMMANDBAR(CControlComboBoxDatePickerPopupBar)

public:
	CControlComboBoxDatePickerPopupBar();
	~CControlComboBoxDatePickerPopupBar();

	BOOL OnHookKeyDown(UINT nChar, LPARAM lParam);

public:
	BOOL Popup(CXTPControlPopup* pControlPopup, BOOL /*bSelectFirst*/);
	BOOL DestroyWindow();

public:
	class CDatePickerControl : public CXTPDatePickerControl
	{
	public:
		CDatePickerControl()
		{
			m_pControl = 0;
			SetMaxSelCount(1);
		}

		void SetModal()
		{
			m_bIsModal = TRUE;
		}

		virtual BOOL ContinueModal()
		{
			return TRUE;
		}

		virtual void EndModalLoop(int nResult)
		{
			if (!m_pControl)
				return;

			if (nResult == IDOK)
			{
				COleDateTime dt;
				GetCurSel(dt);
				m_pControl->SetDate(dt);
				m_pControl->OnExecute();
			}
			else
			{
				m_pControl->GetParent()->GetCommandBars()->ClosePopups();
			}

			m_pControl = NULL;
			ReleaseCapture();
		}
		CControlComboBoxDatePicker* m_pControl;
	};

	CDatePickerControl m_wndDatePickerControl;
};

IMPLEMENT_XTP_COMMANDBAR(CControlComboBoxDatePickerPopupBar, CXTPControlComboBoxPopupBar)

CControlComboBoxDatePickerPopupBar::CControlComboBoxDatePickerPopupBar()
{
	SetShowGripper(FALSE);

	m_wndDatePickerControl.SetBorderStyle(xtpDatePickerBorderNone);
}

CControlComboBoxDatePickerPopupBar::~CControlComboBoxDatePickerPopupBar()
{
}

BOOL CControlComboBoxDatePickerPopupBar::Popup(CXTPControlPopup* pControlPopup, BOOL bSelectFirst)
{
	if (!Create())
		return FALSE;

	_ASSERTE(pControlPopup->IsKindOf(RUNTIME_CLASS(CControlComboBoxDatePicker)));

	GetControls()->RemoveAll();

	CXTPControlCustom* pControl = new CXTPControlCustom();

	CRect rcMin;
	m_wndDatePickerControl.GetMinReqRect(rcMin);
	rcMin.bottom += XTP_DPI_Y(5);

	m_wndDatePickerControl.DestroyWindow();
	m_wndDatePickerControl.Create(WS_CHILD | WS_VISIBLE, rcMin, this, 0);
	m_wndDatePickerControl.SetModal();
	m_wndDatePickerControl.SetFocus();
	m_wndDatePickerControl.SetCapture();
	m_wndDatePickerControl.m_pControl = (CControlComboBoxDatePicker*)pControlPopup;

	m_wndDatePickerControl.SetCurSel(((CControlComboBoxDatePicker*)pControlPopup)->GetDate());
	m_wndDatePickerControl.EnsureVisibleSelection();

	pControl->SetControl(&m_wndDatePickerControl);
	pControl->SetSize(rcMin.Size());
	pControl->SetID(pControlPopup->GetID());

	GetControls()->Add(pControl);

	return CXTPControlComboBoxPopupBar::Popup(pControlPopup, bSelectFirst);
}

BOOL CControlComboBoxDatePickerPopupBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
{
	CXTPControlCustom* pControl = (CXTPControlCustom*)GetControl(0);

	pControl->GetControl()->SendMessage(WM_KEYDOWN, nChar, lParam);

	return TRUE;
}

BOOL CControlComboBoxDatePickerPopupBar::DestroyWindow()
{
	m_wndDatePickerControl.m_pControl = NULL;

	if (::GetCapture() == m_wndDatePickerControl.GetSafeHwnd())
		ReleaseCapture();

	return CXTPControlComboBoxPopupBar::DestroyWindow();
}

#endif

IMPLEMENT_XTP_CONTROL(CControlComboBoxDatePicker, CXTPControlComboBox)

CControlComboBoxDatePicker::CControlComboBoxDatePicker()
{
#ifdef _XTP_INCLUDE_CALENDAR
	CXTPCommandBar* pCommandBar = new CControlComboBoxDatePickerPopupBar();

	SetCommandBar(pCommandBar);

	SetDropDownListStyle();

	pCommandBar->InternalRelease();
#endif
	SetDate(COleDateTime::GetCurrentTime());
}

CControlComboBoxDatePicker::~CControlComboBoxDatePicker()
{
}

void CControlComboBoxDatePicker::SetDate(const COleDateTime& dt)
{
	if (m_dt != dt)
	{
		m_dt = dt;
		SetEditText(m_dt.Format(VAR_DATEVALUEONLY, LANG_USER_DEFAULT));
	}
}

const COleDateTime& CControlComboBoxDatePicker::GetDate() const
{
	return m_dt;
}

void CControlComboBoxDatePicker::OnKillFocus()
{
	SetFocused(FALSE);
}

BOOL CControlComboBoxDatePicker::OnHookKeyDown(UINT nChar, LPARAM lParam)
{
	if (nChar == VK_RETURN)
	{
		COleDateTime dt;
		if (dt.ParseDateTime(GetEditText()))
		{
			SetDate(dt);
		}

		::SetFocus(m_pParent->GetTrackFocus());
		OnExecute();
		return TRUE;
	}

	if (nChar == VK_ESCAPE)
		return FALSE;

	return CXTPControlComboBox::OnHookKeyDown(nChar, lParam);
}

//////////////////////////////////////////////////////////////////////////
// CControlsSampleFrame

BEGIN_MESSAGE_MAP(CControlsSampleFrame, CXTPFrameWnd)
	//{{AFX_MSG_MAP(CControlsSampleFrame)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_XTP_CREATECONTROL()
	ON_COMMAND_RANGE(ID_SCROLL_ITEM1, ID_MULTICOLUMN_COLUMN2, OnScrollItem)
	ON_UPDATE_COMMAND_UI(ID_FIND_COMMAND, OnUpdateEditFind)
	ON_XTP_EXECUTE(ID_FIND_COMMAND, OnEditFind)
	ON_NOTIFY(CBN_DROPDOWN, ID_FIND_COMMAND, OnDropdownFindCombo)
	ON_NOTIFY(CBN_CLOSEUP, ID_FIND_COMMAND, OnCloseupFindCombo)
	ON_NOTIFY(CBN_SELCHANGE, ID_FIND_COMMAND, OnSelchangeFindCombo)
	ON_NOTIFY(CBN_SELENDOK, ID_FIND_COMMAND, OnSelendokFindCombo)
	ON_NOTIFY(CBN_SETFOCUS, ID_FIND_COMMAND, OnSetfocusFindCombo)
	ON_NOTIFY(CBN_SELENDCANCEL, ID_FIND_COMMAND, OnSelendcancelFindCombo)
	ON_NOTIFY(CBN_KILLFOCUS, ID_FIND_COMMAND, OnKillfocusFindCombo)
	ON_NOTIFY(CBN_EDITCHANGE, ID_FIND_COMMAND, OnEditchangeFindCombo)
	ON_XTP_EXECUTE(ID_EDIT_STATE, OnEditState)
	ON_UPDATE_COMMAND_UI(ID_EDIT_STATE, OnUpdateEditState)

	ON_NOTIFY(XTP_FN_SETFORMAT, ID_COMBO_OWNERDRAW, OnSetCharFormat)
	ON_UPDATE_COMMAND_UI(ID_COMBO_OWNERDRAW, OnUpdateComboFont)
	ON_COMMAND_RANGE(ID_SAVEAS_XML, ID_SAVEAS_BINARY, OnSaveAs)
	ON_UPDATE_COMMAND_UI_RANGE(ID_SAVEAS_XML, ID_SAVEAS_BINARY, OnUpdateSaveAs)

	ON_XTP_EXECUTE(ID_COMBO_DATE, OnComboDate)
	ON_UPDATE_COMMAND_UI(ID_COMBO_DATE, OnUpdateComboDate)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CControlsSampleFrame::OnDestroy()
{
	((CMainFrame*)m_pOwnerFrame)->m_pControlsFrame = NULL;

	CFrameWnd::OnDestroy();
}

int CControlsSampleFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CXTPFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	if (!m_wndStatusBar.Create(this)
		|| !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators) / sizeof(UINT)))
	{
		TRACE0("Failed to create status bar\n");
		return -1; // fail to create
	}

	// Initialize the command bars
	if (!InitCommandBars())
		return -1;

	// Get a pointer to the command bars object.
	CXTPCommandBars* pCommandBars = GetCommandBars();
	if (pCommandBars == NULL)
	{
		TRACE0("Failed to create command bars object.\n");
		return -1; // fail to create
	}

	// Add the menu bar
	CXTPToolBar* pMenuBar = pCommandBars->SetMenu(_T("Menu Bar"), IDR_CONTROLSFRAME);
	if (pMenuBar == NULL)
	{
		TRACE0("Failed to create menu bar.\n");
		return -1; // fail to create
	}

	CXTPToolBar* pToolBarButtons = (CXTPToolBar*)pCommandBars->Add(_T("Buttons"), xtpBarTop);
	pToolBarButtons->SetBarID(IDR_CONTROLSFRAME);

	pCommandBars->EnableFrameTheme(m_Theme > xtpThemeDlgOffice2003);

	pToolBarButtons->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlButton:"));
	pToolBarButtons->GetControls()->Add(xtpControlButton, ID_FILE_OPEN);
	pToolBarButtons->GetControls()->Add(xtpControlButton, ID_FILE_SAVE)->SetStyle(xtpButtonCaption);
	pToolBarButtons->GetControls()
		->Add(xtpControlButton, ID_FILE_PRINT)
		->SetStyle(xtpButtonIconAndCaption);

	CXTPToolBar* pToolBarPopups = pCommandBars->Add(_T("Popups"), xtpBarTop);
	pToolBarPopups->SetBarID(IDR_CONTROLS_POPUPS);

	pToolBarPopups->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlPopup:"));
	pToolBarPopups->GetControls()->Add(xtpControlPopup, ID_EDIT_PASTE);
	pToolBarPopups->GetControls()->Add(xtpControlPopup, ID_EDIT_COPY)->SetStyle(xtpButtonIcon);
	pToolBarPopups->GetControls()
		->Add(xtpControlButtonPopup, ID_EDIT_CUT)
		->SetStyle(xtpButtonIconAndCaption);
	pToolBarPopups->GetControls()
		->Add(xtpControlSplitButtonPopup, ID_EDIT_SELECT_ALL)
		->SetStyle(xtpButtonIconAndCaption);

	DockRightOf(pToolBarPopups, pToolBarButtons);

	CXTPToolBar* pToolBarCombo = pCommandBars->Add(_T("Combo"), xtpBarTop);
	pToolBarCombo->SetBarID(IDR_CONTROLS_COMBO);
	pToolBarCombo->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlComboBox:"));
	pToolBarCombo->GetControls()->Add(xtpControlComboBox, ID_FILE_NEW);
	CXTPControlComboBox* pControlCombo =
		(CXTPControlComboBox*)pToolBarCombo->GetControls()->Add(xtpControlComboBox, ID_FILE_NEW);
	pControlCombo->SetDropDownListStyle();
	DockRightOf(pToolBarCombo, pToolBarPopups);

	CXTPToolBar* pToolBarEdit = pCommandBars->Add(_T("Edit"), xtpBarTop);
	pToolBarEdit->SetBarID(IDR_CONTROLS_EDIT);
	pToolBarEdit->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlEdit:"));
	CXTPControlEdit* pControlEdit =
		(CXTPControlEdit*)pToolBarEdit->GetControls()->Add(xtpControlEdit, ID_FILE_NEW);
	pControlEdit->ShowSpinButtons(TRUE);
	pControlEdit->SetEditIconId(ID_EDIT_COPY);

	CXTPToolBar* pToolBarRadio = pCommandBars->Add(_T("Radio"), xtpBarTop);
	pToolBarRadio->SetBarID(IDR_CONTROLS_RADIO);
	pToolBarRadio->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlRadioButton:"));
	pToolBarRadio->GetControls()->Add(xtpControlRadioButton, 0);
	DockRightOf(pToolBarRadio, pToolBarEdit);

	CXTPToolBar* pToolBarCheckBox = pCommandBars->Add(_T("CheckBox"), xtpBarTop);
	pToolBarCheckBox->SetBarID(IDR_CONTROLS_CHECK);
	pToolBarCheckBox->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlCheckBox:"));
	pToolBarCheckBox->GetControls()->Add(xtpControlCheckBox, 0);
	DockRightOf(pToolBarCheckBox, pToolBarRadio);

	CXTPToolBar* pToolBarListBox = pCommandBars->Add(_T("ListBox"), xtpBarTop);
	pToolBarListBox->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlListBox:"));
	CXTPControlPopup* pPopup =
		(CXTPControlPopup*)pToolBarListBox->GetControls()->Add(xtpControlPopup, 0);
	pPopup->SetCaption(_T("ListBox"));
	CXTPControlListBox* pListBox =
		(CXTPControlListBox*)pPopup->GetCommandBar()->GetControls()->Add(new CXTPControlListBox, 0);
	pListBox->GetListCtrl()->AddString(_T("Item 1"));
	pListBox->GetListCtrl()->AddString(_T("Item 2"));

	CXTPToolBar* pToolBarGallery = pCommandBars->Add(_T("Gallery"), xtpBarTop);
	pToolBarGallery->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlGallery:"));

	CXTPControlGalleryItems* pGalleryItems =
		CXTPControlGalleryItems::CreateItems(GetCommandBars(), ID_CONTROL_GALLERY);

	CXTPControlGallery* pControlGallery = (CXTPControlGallery*)pToolBarGallery->GetControls()->Add(
		new CXTPControlGallery(), ID_CONTROL_GALLERY);
	pGalleryItems->AddItem(_T("Item 1"));
	pGalleryItems->AddItem(_T("Item 2"));
	pGalleryItems->AddItem(_T("Item 3"));
	pGalleryItems->AddItem(_T("Item 4"));
	pGalleryItems->AddItem(_T("Item 5"));
	pGalleryItems->SetItemSize(CSize(40, 22));

	pControlGallery->SetHeight(22);
	pControlGallery->SetWidth(140);
	pControlGallery->SetItems(pGalleryItems);
	pControlGallery->SetFlags(xtpFlagManualUpdate);

	DockRightOf(pToolBarGallery, pToolBarListBox);

	CXTPToolBar* pToolBarColor = pCommandBars->Add(_T("ColorButton"), xtpBarTop);
	pToolBarColor->GetControls()
		->Add(xtpControlLabel, 0)
		->SetCaption(_T("CXTPControlColorSelector:"));

	CXTPControlPopupColor* pControlButtonColor =
		(CXTPControlPopupColor*)pToolBarColor->GetControls()->Add(new CXTPControlPopupColor(),
																  ID_COLOR_FORE);
	pControlButtonColor->SetColor(0xFF);
	CXTPPopupToolBar* pPopupToolBar = CXTPPopupToolBar::CreatePopupToolBar(pCommandBars);
	pControlButtonColor->SetCommandBar(pPopupToolBar);
	pPopupToolBar->GetControls()->Add(new CXTPControlColorSelector());
	pPopupToolBar->InternalRelease();
	pControlButtonColor->SetFlags(xtpFlagManualUpdate);

	DockRightOf(pToolBarColor, pToolBarGallery);

	CXTPToolBar* pToolBarSlider = pCommandBars->Add(_T("Slider"), xtpBarTop);
	pToolBarSlider->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlSlider:"));
	pToolBarSlider->GetControls()->Add(new CXTPControlSlider());

	CXTPToolBar* pToolBarScrollBar = pCommandBars->Add(_T("ScrollBar"), xtpBarTop);
	pToolBarScrollBar->GetControls()
		->Add(xtpControlLabel, 0)
		->SetCaption(_T("CXTPControlScrollBar:"));
	pToolBarScrollBar->GetControls()->Add(new CXTPControlScrollBar());

	CXTPControlScrollBar* pControlScrolBar =
		(CXTPControlScrollBar*)pToolBarScrollBar->GetControls()->Add(new CXTPControlScrollBar());
	pControlScrolBar->SetScrollBarStyle(xtpScrollStyleSlider);

	DockRightOf(pToolBarScrollBar, pToolBarSlider);

	CXTPToolBar* pToolBarProgress = pCommandBars->Add(_T("Progress"), xtpBarTop);
	pToolBarProgress->GetControls()->Add(xtpControlLabel, 0)->SetCaption(_T("CXTPControlProgress:"));
	CXTPControlProgress* pProgressControl = new CXTPControlProgress();
	pToolBarProgress->GetControls()->Add(pProgressControl);
	pProgressControl->SetPos(30);
	DockRightOf(pToolBarProgress, pToolBarScrollBar);

	CXTPToolBar* pCommonControlsdBar = (CXTPToolBar*)pCommandBars->Add(_T("Common Controls"),
																	   xtpBarTop);
	if (!pCommonControlsdBar || !pCommonControlsdBar->LoadToolBar(IDR_COMMONCONTROLS, FALSE))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;
	}
	pCommandBars->DockCommandBar(pCommonControlsdBar, xtpBarTop);

	// create the left docked toolbar.
	CXTPToolBar* pLeftBar = (CXTPToolBar*)pCommandBars->Add(_T("Left Bar"), xtpBarLeft);
	if (!pLeftBar || !pLeftBar->LoadToolBar(IDR_LEFT, FALSE))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;
	}

	CXTPImageManager* pImgMgr = pCommandBars->GetImageManager();
	if (pImgMgr)
	{
		CString type(_T("RT_XAML")); // resource type
		UINT nWidth = 0;

		nWidth = XTP_DPI_X(16);
		pImgMgr->SetVectorIcon(type, IDR_XAML_SMALL_ICON_NORMAL_PRINTER, ID_FILE_PRINT_EX, nWidth);
		pImgMgr->SetVectorIcon(type, IDR_XAML_SMALL_ICON_NORMAL_FIND, ID_FIND_COMMAND, nWidth);

		nWidth = XTP_DPI_X(16);
		pImgMgr->SetVectorIcon(type, IDR_XAML_SMALL_ICON_DISABLED_PRINTER, ID_FILE_PRINT_EX, nWidth,
							   xtpImageDisabled);
		pImgMgr->SetVectorIcon(type, IDR_XAML_SMALL_ICON_DISABLED_FIND, ID_FIND_COMMAND, nWidth,
							   xtpImageDisabled);
	}

	// create the combo box toolbar.
	CXTPToolBar* pComboBoxBar = (CXTPToolBar*)pCommandBars->Add(_T("ComboBox Bar"), xtpBarBottom);
	if (!pComboBoxBar || !pComboBoxBar->LoadToolBar(IDR_COMBOBOX_BAR, FALSE))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;
	}
	return 0;
}

int CControlsSampleFrame::OnCreateControl(LPCREATECONTROLSTRUCT lpCreateControl)
{
#if _MSC_VER >= 1200 || defined(_XTP_INCLUDE_CONTROLS)
	if (lpCreateControl->nID == IDC_CALENDAR)
	{
		// Create the calendar control.
		// Note: The control does not use the DTS_UPDOWN style.
		// DTP controls that do not use the DTS_UPDOWN style display
		// an arrow button. If the user clicks this button, a month
		// calendar control drops down. The user can select a specific
		// date by clicking an area of the calendar.
		if (!m_monthCal.Create(WS_TABSTOP | WS_CHILD | WS_VISIBLE | DTS_SHORTDATEFORMAT,
							   XTP_DPI(CRect(0, 0, 200, 22)), this, IDC_CALENDAR))
		{
			return FALSE;
		}

		// Set default GUI font.
		m_monthCal.SetFont(
			CFont::FromHandle(reinterpret_cast<HFONT>(::GetStockObject(DEFAULT_GUI_FONT))));

		// Use m_monthCal to create a new CXTPControlCustom* control.
		CXTPControlCustom* pControlMonthCal = CXTPControlCustom::CreateControlCustom(&m_monthCal);

		// Set the xtpFlagManualUpdate flag.
		// Without this flag you must call the Enable member of
		// CCmdUI in the ON_UPDATE_COMMAND_UI handler.
		pControlMonthCal->SetFlags(xtpFlagManualUpdate);

		lpCreateControl->pControl = pControlMonthCal;
		return TRUE;
	}
	// Create the Date control
	if (lpCreateControl->nID == IDC_DATE)
	{
		// Create the date control.
		// Note: This control is created using the DTS_UPDOWN style.
		// The DTS_UPDOWN style creates a control with a spin control
		// positioned on the right side of the Date control.
		if (!m_date.Create(WS_TABSTOP | WS_CHILD | WS_VISIBLE | DTS_UPDOWN,
						   XTP_DPI(CRect(0, 0, 100, 22)), this, IDC_DATE))
		{
			return FALSE;
		}

		// Set default GUI font.
		m_date.SetFont(
			CFont::FromHandle(reinterpret_cast<HFONT>(::GetStockObject(DEFAULT_GUI_FONT))));

		// Create a new CXTPControlCustom* control from the m_date control.
		CXTPControlCustom* pControlDate = CXTPControlCustom::CreateControlCustom(&m_date);

		// Set the xtpFlagManualUpdate flag.
		// Without this flag you must call the Enable member
		// of CCmdUI in the ON_UPDATE_COMMAND_UI handler.
		pControlDate->SetFlags(xtpFlagManualUpdate);

		lpCreateControl->pControl = pControlDate;
		return TRUE;
	}
	// Create the Time control
	if (lpCreateControl->nID == IDC_TIME)
	{
		// Create the date control.
		// Note: This control is created using the DTS_UPDOWN style.
		// The DTS_UPDOWN style creates a control with a spin control
		// positioned on the right side of the Time control.
		if (!m_time.Create(WS_TABSTOP | WS_CHILD | WS_VISIBLE | DTS_UPDOWN,
						   XTP_DPI(CRect(0, 0, 90, 22)), this, IDC_TIME))
		{
			return FALSE;
		}

		// Set the format of the Time control.
		m_time.SetFormat(_T("hh':'mm':'ss tt"));

		// set date control font.
		m_time.SetFont(
			CFont::FromHandle(reinterpret_cast<HFONT>(::GetStockObject(DEFAULT_GUI_FONT))));

		// Create a CXTPControlCustom* from the m_time control.
		CXTPControlCustom* pControlTime = CXTPControlCustom::CreateControlCustom(&m_time);

		// Set the xtpFlagManualUpdate flag.
		// Without this flag you must call the Enable member
		// of CCmdUI in the ON_UPDATE_COMMAND_UI handler.
		pControlTime->SetFlags(xtpFlagManualUpdate);

		lpCreateControl->pControl = pControlTime;
		return TRUE;
	}
#endif
	// Create the Animation control
	if (lpCreateControl->nID == IDC_ANIMATION)
	{
		// Create the Animation control.
		if (!m_wndAnimCtrl.Create(WS_TABSTOP | WS_CHILD | WS_VISIBLE | ACS_AUTOPLAY,
								  CRect(0, 0, 0, 0), this, IDC_ANIMATION))
		{
			return FALSE;
		}

		// Open the HeartBeat avi that is associated with the IDR_HEARTBEAT string resource.
		m_wndAnimCtrl.Open(IDR_HEARTBEAT);

		// Create a CXTPControlCustom* control from the m_wndAnimCtrl control.
		CXTPControlCustom* pControlAnimation = CXTPControlCustom::CreateControlCustom(
			&m_wndAnimCtrl);

		// Set the margins of the Animation control.
		pControlAnimation->SetBorders(XTP_DPI_X(3), XTP_DPI_Y(3), XTP_DPI_X(3), XTP_DPI_Y(3));

		// Set the vertical draw options to xtpVerticalShow.
		// This will draw the animation control when the Animation
		// toolbar is docked vertically.
		pControlAnimation->SetVerticalPositionOption(xtpVerticalShow);

		lpCreateControl->pControl = pControlAnimation;
		return TRUE;
	}
	if (lpCreateControl->bToolBar == FALSE)
	{
		if (lpCreateControl->nID == ID_MULTICOLUMN_COLUMN1
			|| lpCreateControl->nID == ID_MULTICOLUMN_COLUMN2)
		{
			lpCreateControl->pControl = new CXTPControlLabel();
			lpCreateControl->pControl->SetItemDefault(TRUE);
			lpCreateControl->pControl->SetStyle(xtpButtonCaption);

			return TRUE;
		}

		if (lpCreateControl->controlType == xtpControlButton
			&& lpCreateControl->nID == ID_FIND_COMMAND)
		{
			CXTPControlComboBox* pComboFind = (CXTPControlComboBox*)
				CXTPControlComboBox::CreateObject();
			pComboFind->SetDropDownListStyle();
			pComboFind->SetEditHint(_T("Click to find string"));

			pComboFind->AddString(_T("Line1"));
			pComboFind->AddString(_T("Line2"));
			pComboFind->AddString(_T("Line3"));

			pComboFind->SetWidth(XTP_DPI_X(150));
			pComboFind->SetCaption(_T("Find"));
			pComboFind->SetStyle(xtpComboLabel);

			lpCreateControl->pControl = pComboFind;
			return TRUE;
		}
	}
	else
	{
		CXTPToolBar* pToolBar = DYNAMIC_DOWNCAST(CXTPToolBar, lpCreateControl->pCommandBar);
		if (!pToolBar)
			return FALSE;
		if (lpCreateControl->nID == ID_COMBO_DISABLED && pToolBar->GetBarID() == IDR_COMBOBOX_BAR)
		{
			CXTPControlComboBox* pComboDisable = (CXTPControlComboBox*)
				CXTPControlComboBox::CreateObject();
			pComboDisable->SetStyle(xtpComboLabel);
			lpCreateControl->pControl = pComboDisable;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_FIND_COMMAND && pToolBar->GetBarID() == IDR_COMBOBOX_BAR)
		{
			CXTPControlComboBox* pComboFind = new CXTPControlComboBox(GetCommandBars());
			pComboFind->ModifyListBoxStyle(0, LBS_OWNERDRAWFIXED | LBS_HASSTRINGS);

			// pComboFind->SetListIconId(ID_FILE_NEW);

			pComboFind->SetDropDownListStyle();
			pComboFind->SetEditHint(_T("Click to find string"));

			pComboFind->AddString(_T("Line1"));
			pComboFind->AddString(_T("Line2"));
			pComboFind->AddString(_T("Line3"));

			pComboFind->SetWidth(XTP_DPI_X(150));
			pComboFind->SetStyle(xtpButtonIconAndCaption);

			lpCreateControl->pControl = pComboFind;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_FILE_NEW && pToolBar->GetBarID() == IDR_COMBOBOX_BAR)
		{
			lpCreateControl->controlType = xtpControlEdit;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_EDIT_STATE && pToolBar->GetBarID() == IDR_COMBOBOX_BAR)
		{
			CXTPControlComboBox* pComboState = (CXTPControlComboBox*)
				CXTPControlComboBox::CreateObject();
			pComboState->AddString(_T("Debug"));
			pComboState->AddString(_T("Release"));
			pComboState->AddString(_T("Configuration Manager"));
			pComboState->SetDropDownWidth(XTP_DPI_X(150));
			lpCreateControl->pControl = pComboState;
			return TRUE;
		}
		if (lpCreateControl->nID == ID_COMBO_MASKED)
		{
			CXTPControlComboBox* pComboMasked = (CXTPControlComboBox*)
				CControlComboBoxEx::CreateObject();

			pComboMasked->SetDropDownListStyle();

			pComboMasked->AddString(_T("12:00:20:30"));
			pComboMasked->AddString(_T("11:03:12:30"));
			pComboMasked->AddString(_T("00:00:12:30"));
			pComboMasked->AddString(_T("10:00:30:30"));

			pComboMasked->SetWidth(XTP_DPI_X(130));
			pComboMasked->SetStyle(xtpComboLabel);
			pComboMasked->SetFlags(xtpFlagManualUpdate);

			lpCreateControl->pControl = pComboMasked;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_COMBO_OWNERDRAW)
		{
			CXTPControlComboBox* pComboCustomDraw = new CControlComboBoxCustomDraw(
				GetCommandBars());

			pComboCustomDraw->SetDropDownListStyle();
			pComboCustomDraw->SetWidth(XTP_DPI_X(130));
			pComboCustomDraw->SetDropDownWidth(XTP_DPI_X(230));
			pComboCustomDraw->SetStyle(xtpComboLabel);

			lpCreateControl->pControl = pComboCustomDraw;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_COMBO_POPUP)
		{
			CXTPControlComboBox* pComboPopup = (CXTPControlComboBox*)
				CControlComboBoxPopup::CreateObject();

			CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(GetCommandBars());
			CMenu menu;
			menu.LoadMenu(IDR_MENU_SAVEAS);

			pPopupBar->LoadMenu(menu.GetSubMenu(0));

			pComboPopup->SetCommandBar(pPopupBar);

			pPopupBar->InternalRelease();

			pComboPopup->SetWidth(XTP_DPI_X(130));
			pComboPopup->SetStyle(xtpComboLabel);
			pComboPopup->SetFlags(xtpFlagManualUpdate);

			lpCreateControl->pControl = pComboPopup;
			return TRUE;
		}

		if (lpCreateControl->nID == ID_COMBO_DATE)
		{
			CXTPControlComboBox* pCombo = new CControlComboBoxDatePicker();
			pCombo->SetWidth(XTP_DPI_X(100));
			lpCreateControl->pControl = pCombo;
			return TRUE;
		}
	}

	return FALSE;
}
void CControlsSampleFrame::RefreshTheme(XTPThemeDlg nTheme)
{
	m_Theme = nTheme;

	switch (nTheme)
	{
		case xtpThemeDlgOffice2007:
		case xtpThemeDlgOffice2010:
		case xtpThemeDlgOffice2013:
		case xtpThemeDlgOffice2016:
		case xtpThemeDlgVisualStudio2012:
		case xtpThemeDlgVisualStudio2015:
		case xtpThemeDlgVisualStudio2017:
		case xtpThemeDlgVisualStudio2019:
		case xtpThemeDlgVisualStudio2022:
		case xtpThemeDlgNativeWindows: GetCommandBars()->EnableFrameTheme(TRUE); break;

		default: GetCommandBars()->EnableFrameTheme(NULL); break;
	}
	GetCommandBars()->RedrawCommandBars();
	m_wndStatusBar.Invalidate(TRUE);
}

void CControlsSampleFrame::OnScrollItem(UINT)
{
	// TODO: Add your command handler code here
}

void CControlsSampleFrame::OnEditFind(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMXTPCONTROL* tagNMCONTROL = (NMXTPCONTROL*)pNMHDR;

	CXTPControlComboBox* pControl = (CXTPControlComboBox*)tagNMCONTROL->pControl;
	if (pControl->GetType() == xtpControlComboBox)
	{
		AfxMessageBox(_T("String not Found"));

		*pResult = 1; // Handled;
	}
}

void CControlsSampleFrame::OnUpdateEditFind(CCmdUI* pCmd)
{
	pCmd->Enable(TRUE);
}

void CControlsSampleFrame::OnDropdownFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnCloseupFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnSelchangeFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnSelendokFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnSetfocusFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnSelendcancelFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnKillfocusFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnEditchangeFindCombo(NMHDR* /*pNMHDR*/, LRESULT* /*pRes*/)
{
}

void CControlsSampleFrame::OnEditState(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMXTPCONTROL* tagNMCONTROL = (NMXTPCONTROL*)pNMHDR;

	CXTPControlComboBox* pControl = (CXTPControlComboBox*)tagNMCONTROL->pControl;
	if (pControl->GetType() == xtpControlComboBox)
	{
		int nState = pControl->GetCurSel();
		if (nState != 2)
		{
			m_nState = nState;
		}
		else
		{
			MessageBox(_T("Configuration Manager"));
			pControl->SetCurSel(m_nState);
		}
		*pResult = TRUE; // Handled
	}
}

void CControlsSampleFrame::OnUpdateEditState(CCmdUI* pCmdUI)
{
	CXTPControlComboBox* pStateCombo = DYNAMIC_DOWNCAST(CXTPControlComboBox,
														CXTPControl::FromUI(pCmdUI));

	if (pStateCombo && !pStateCombo->HasFocus())
	{
		pStateCombo->SetCurSel(m_nState);
	}

	pCmdUI->Enable(TRUE);
}

void CControlsSampleFrame::OnSetCharFormat(NMHDR* pNMHDR, LRESULT* pRes)
{
}

void CControlsSampleFrame::OnUpdateComboFont(CCmdUI* pCmd)
{
	pCmd->Enable(TRUE);
}

void CControlsSampleFrame::OnSaveAs(UINT nID)
{
	gSaveAsID = nID;
}

void CControlsSampleFrame::OnUpdateSaveAs(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(pCmdUI->m_nID == gSaveAsID ? TRUE : FALSE);
}

void CControlsSampleFrame::OnComboDate(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMXTPCONTROL* tagNMCONTROL = (NMXTPCONTROL*)pNMHDR;

	CControlComboBoxDatePicker* pControl = DYNAMIC_DOWNCAST(CControlComboBoxDatePicker,
															tagNMCONTROL->pControl);
	if (pControl)
	{
		m_dt = pControl->GetDate();

		*pResult = 1;
	}
}

void CControlsSampleFrame::OnUpdateComboDate(CCmdUI* pCmdUI)
{
	CControlComboBoxDatePicker* pControl = DYNAMIC_DOWNCAST(CControlComboBoxDatePicker,
															CXTPControl::FromUI(pCmdUI));

	if (pControl)
	{
		pControl->SetDate(m_dt);
	}

	pCmdUI->Enable(TRUE);
}

/////////////////////////////////////////////////////////////////////////////
// CControlsSampleFrame diagnostics

#ifdef _DEBUG
void CControlsSampleFrame::AssertValid() const
{
	CXTPFrameWnd::AssertValid();
}

void CControlsSampleFrame::Dump(CDumpContext& dc) const
{
	CXTPFrameWnd::Dump(dc);
}

#endif //_DEBUG