// RibbonSampleView.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 "RibbonSample.h"

#include "RibbonSampleDoc.h"
#include "CntrItem.h"
#include "RibbonSampleView.h"
#include "MainFrm.h"
#include "WorkspaceView.h"
#include "GalleryItems.h"

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

/////////////////////////////////////////////////////////////////////////////
// CRibbonSampleView

IMPLEMENT_DYNCREATE(CRibbonSampleView, CScrollRichEditViewEx)

BEGIN_MESSAGE_MAP(CRibbonSampleView, CScrollRichEditViewEx)
	//{{AFX_MSG_MAP(CRibbonSampleView)
	ON_WM_DESTROY()
	ON_WM_RBUTTONUP()
	ON_WM_LBUTTONUP()
	ON_WM_LBUTTONDOWN()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)

	//	COMMON
	ON_UPDATE_COMMAND_UI(XTP_ID_RIBBONCONTROLTAB, OnUpdateRibbonTab)
	ON_XTP_EXECUTE(ID_EDIT_UNDO, OnEditUndo)
	ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo)

	// HOME / Clipboard
	ON_COMMAND(ID_GROUP_OPTION_CLIPBOARD, OnEmptyCommand)
	ON_COMMAND(ID_CLIPBOARD_FORMAT_PAINTER, OnEmptyCommand)

	ON_COMMAND(ID_GROUP_OPTION_FONT, OnGroupFont)
	ON_COMMAND(ID_GROUP_OPTION_STYLES, OnEmptyCommand)
	ON_COMMAND(ID_GROUP_OPTION_PARAGRAPH, OnEmptyCommand)

	///	HOME / Editing
	ON_COMMAND(ID_EDIT_GOTO, OnEmptyCommand)
	ON_COMMAND(ID_EDIT_SELECT_OBJECTS, OnEmptyCommand)
	ON_COMMAND(ID_EDIT_SELECT_MULTIPLE_OBJECTS, OnEmptyCommand)

	// INSERT / Pages
	ON_COMMAND_RANGE(ID_INSERT_PAGES_COVER, ID_INSERT_PAGES_BREAK, OnEmptyCommand)

	// INSERT / Tables
	ON_COMMAND(ID_INSERT_TABLE, OnEmptyCommand)

	// INSERT / Illustrations
	ON_COMMAND_RANGE(ID_ILLUSTRATION_PICTURE, ID_TABLE_INSERTTABLE, OnInsertSomeObject)
	ON_COMMAND_RANGE(ID_ILLUSTRATION_PICTURES, ID_ILLUSTRATION_SCREENSHOT, OnEmptyCommand)

	// INSERT / Links
	ON_COMMAND_RANGE(ID_INSERT_HYPERLINK, ID_INSERT_CROSS_REFERENCE, OnEmptyCommand)

	// INSERT / Media
	ON_COMMAND(ID_INSERT_ONLINEVIDEO, OnEmptyCommand)

	// INSERT / Header & Footer
	ON_COMMAND_RANGE(ID_INSERT_HEADER, ID_PAGENUMBER_REMOVEPAGENUMBERS, OnEmptyCommand)

	// INSERT / Text
	ON_COMMAND_RANGE(ID_INSERT_TEXTBOX, ID_INSERT_DATETIME, OnEmptyCommand)
	ON_COMMAND(ID_INSERT_OBJECT, OnInsertObject)

	// INSERT / Symbols
	ON_COMMAND_RANGE(ID_INSERT_EQUATIONS, ID_INSERT_SYMBOL, OnEmptyCommand)

	// PAGE LAYOUT / Themes
	ON_COMMAND_RANGE(ID_THEMES_THEMES, ID_THEMES_OFFICE, OnEmptyCommand)

	// PAGE LAYOUT / Page Setup
	ON_COMMAND_RANGE(ID_PAGE_MARGINS, ID_PAGE_HYPHENATATION, OnEmptyCommand)
	ON_XTP_EXECUTE(ID_PAGE_COLUMNS_GALLERY, OnGalleryColumns)
	ON_UPDATE_COMMAND_UI(ID_PAGE_COLUMNS_GALLERY, OnUpdateGalleryColumns)

	// PAGE LAYOUT / Page background
	ON_COMMAND_RANGE(ID_PAGE_WATERMARK, ID_PAGE_BORDERS, OnEmptyCommand)

	// PAGE LAYOUT / Paragraph
	ON_COMMAND_RANGE(ID_ARRANGE_POSITION, ID_ARRANGE_ROTATE, OnEmptyCommand)

	// PREFERENCES / *
	ON_COMMAND_RANGE(ID_CONTENTS_TABLE, ID_INDEX_UPDATE, OnEmptyCommand)

	// MAILINGS / *
	ON_COMMAND_RANGE(ID_MAIL_ENVELOPES, ID_MAIL_FINISHANDMERGE, OnEmptyCommand)

	// REVIEW / *
	ON_COMMAND_RANGE(ID_REVIEW_SPELLING, ID_REVIEW_RESTRICTEDITING, OnEmptyCommand)

	// VIEW / Views
	ON_COMMAND_RANGE(ID_VIEW_READMODE, ID_VIEW_DRAFT, OnEmptyCommand)

	// VIEW / Zoom
	ON_COMMAND_RANGE(ID_ZOOM_ZOOM, ID_ZOOM_PAGEWIDTH, OnEmptyCommand)

	// BUTTONS / Large + Small
	ON_COMMAND_RANGE(ID_BUTTONS_LARGE_SIMPLEBUTTON, ID_BUTTONS_LARGE_SPLITPOPUPBUTTON,
					 OnEmptyCommand)
	ON_COMMAND_RANGE(ID_BUTTONS_SMALL_SIMPLEBUTTON, ID_BUTTONS_SMALL_SPLITPOPUPBUTTON,
					 OnEmptyCommand)
	ON_COMMAND_RANGE(ID_BUTTONS_POPUP_OPTION1, ID_BUTTONS_POPUP_OPTION3, OnEmptyCommand)
	ON_COMMAND(ID_BUTTONS_LARGE_TOGGLEBUTTON, OnToggleButton)
	ON_UPDATE_COMMAND_UI(ID_BUTTONS_LARGE_TOGGLEBUTTON, OnUpdateToggleButton)
	ON_COMMAND_RANGE(ID_BUTTONS_CHECKBOX1, ID_BUTTONS_CHECKBOX3, OnCheckbox)
	ON_COMMAND_RANGE(ID_BUTTONS_RADIOBUTTON1, ID_BUTTONS_RADIOBUTTON3, OnRadioButton)
	ON_UPDATE_COMMAND_UI_RANGE(ID_BUTTONS_CHECKBOX1, ID_BUTTONS_CHECKBOX3, OnUpdateCheckbox)
	ON_UPDATE_COMMAND_UI_RANGE(ID_BUTTONS_RADIOBUTTON1, ID_BUTTONS_RADIOBUTTON3,
							   OnUpdateRadioButton)

	// BUTTONS / Editors
	ON_UPDATE_COMMAND_UI_RANGE(ID_EDITORS_EDIT, ID_EDITORS_COMBO2, OnEnableButton)
	ON_UPDATE_COMMAND_UI_RANGE(ID_EDITORSEX_EDIT, ID_EDITORSEX_COMBO2, OnEnableButton)
	ON_UPDATE_COMMAND_UI_RANGE(ID_EDITORS_GALLERY_FONT, ID_EDITORS_GALLERY_POPUP, OnEnableButton)

	// GALLERIES / Popup galleries
	ON_UPDATE_COMMAND_UI_RANGE(ID_GALLERIES_STYLES, ID_GALLERIES_TABLE, OnEnableButton)
	ON_UPDATE_COMMAND_UI(ID_GALLERIES_COLOR, OnUpdateGalleryTextColor)
	ON_UPDATE_COMMAND_UI(ID_GALLERIES_UNDO, OnUpdateEditUndo)
	ON_XTP_EXECUTE(ID_GALLERIES_COLOR, OnGalleryTextColor)
	ON_XTP_EXECUTE(ID_GALLERIES_UNDO, OnEditUndo)

	// REDUCTION / Controls
	ON_UPDATE_COMMAND_UI_RANGE(ID_BUTTON_REDUCTION_1, ID_BUTTON_REDUCTION_12, OnEnableButton)
	ON_COMMAND_RANGE(ID_BUTTON_REDUCTION_1, ID_BUTTON_REDUCTION_12, OnEmptyCommand)

	// Statusbar
	ON_NOTIFY(XTP_SBN_SCROLL, ID_INDICATOR_ZOOMSLIDER, OnZoomSliderScroll)
	ON_COMMAND(ID_INDICATOR_ZOOM, OnEmptyCommand)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRibbonSampleView construction/destruction

CRibbonSampleView::CRibbonSampleView()
{
	m_ptLastSel		= 0;
	m_nColumns		= 0;
	m_nZoom			= 100;
	m_bCheckbox[0]  = TRUE;
	m_bCheckbox[1]  = FALSE;
	m_bCheckbox[2]  = FALSE;
	m_nRadioButton  = 1;
	m_bToggleButton = FALSE;
}

CRibbonSampleView::~CRibbonSampleView()
{
}

BOOL CRibbonSampleView::PreCreateWindow(CREATESTRUCT& cs)
{
	cs.dwExStyle &= ~WS_EX_CLIENTEDGE;

	return CScrollRichEditViewEx::PreCreateWindow(cs);
}

void CRibbonSampleView::OnInitialUpdate()
{
	CScrollRichEditViewEx::OnInitialUpdate();

	USES_CONVERSION;

	// Set the printing margins (720 twips = 1/2 inch).
	SetMargins(CRect(720, 720, 720, 720));

	if (GetDocument()->GetPathName().IsEmpty())
		SetSampleDescriptionText(GetRichEditCtrl(), _T(""));

	ModifyStyleEx(WS_EX_CLIENTEDGE, 0, SWP_FRAMECHANGED);

	static BOOL bLoadOnce = FALSE;
	if (!bLoadOnce && GetDocument()->GetPathName().IsEmpty())
	{
		bLoadOnce = TRUE;

		HINSTANCE hInstance		 = AfxGetInstanceHandle();
		LPCTSTR lpszResourceName = _T("FEEDBACK.RTF");
		LPCTSTR lpszResourceType = _T("RTF");

		HRSRC hRsrc = ::FindResource(hInstance, lpszResourceName, lpszResourceType);
		if (hRsrc == NULL)
			return;

		HGLOBAL hGlobal = LoadResource(hInstance, hRsrc);
		if (hGlobal == NULL)
			return;

		LPCSTR pData = (LPCSTR)LockResource(hGlobal);
		if (pData == NULL)
			return;

		DWORD dwSize = (DWORD)SizeofResource(hInstance, hRsrc);
		if (dwSize == 0)
			return;

		CMemFile memRTF((BYTE*)pData, dwSize, 0);
		CArchive ar(&memRTF, CArchive::load | CArchive::bNoFlushOnDelete | CArchive::bNoByteSwap);

		Serialize(ar);
		GetDocument()->SetModifiedFlag(FALSE);
	}
}

/////////////////////////////////////////////////////////////////////////////
// CRibbonSampleView printing

BOOL CRibbonSampleView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	BOOL bPreparePrinting = DoPreparePrinting(pInfo);

	if (bPreparePrinting)
	{
		FORMATRANGE fmtRange;
		CRect page;

		CDC dc;
		dc.Attach(pInfo->m_pPD->m_pd.hDC);

		page.left   = 0;
		page.top	= 0;
		page.right  = ::MulDiv(dc.GetDeviceCaps(PHYSICALWIDTH), 1440, dc.GetDeviceCaps(LOGPIXELSX));
		page.bottom = ::MulDiv(dc.GetDeviceCaps(PHYSICALHEIGHT), 1440,
							   dc.GetDeviceCaps(LOGPIXELSY));

		fmtRange.hdc	   = dc.m_hDC;
		fmtRange.hdcTarget = dc.m_hAttribDC;
		fmtRange.rc		   = page;
		fmtRange.rcPage	= page;

		long lLineWidth = ::MulDiv(dc.GetDeviceCaps(PHYSICALWIDTH), 1440,
								   dc.GetDeviceCaps(LOGPIXELSX));
		GetRichEditCtrl().SetTargetDevice(dc, lLineWidth);

		long lTextLength = GetRichEditCtrl().GetTextLength();
		long lLast		 = 0;
		UINT nPages		 = 0;

		while (lLast < lTextLength)
		{
			fmtRange.chrg.cpMin = lLast;
			fmtRange.chrg.cpMax = -1L;

			lLast = GetRichEditCtrl().FormatRange(&fmtRange, FALSE);
			++nPages;

			if (lLast < fmtRange.chrg.cpMin)
			{
				break;
			}
		}

		dc.Detach();

		pInfo->SetMaxPage(nPages);
		pInfo->m_pPD->m_pd.nToPage = nPages;
	}

	return bPreparePrinting;
}

void CRibbonSampleView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
{
	CScrollRichEditViewEx::OnPrint(pDC, pInfo);
}

void CRibbonSampleView::OnFilePrintPreview()
{
	// In derived classes, implement special window handling here
	// Be sure to Unhook Frame Window close if hooked.

	// must not create this on the frame.  Must outlive this function
	CPrintPreviewState* pState = new CPrintPreviewState;

	// DoPrintPreview's return value does not necessarily indicate that
	// Print preview succeeded or failed, but rather what actions are necessary
	// at this point.  If DoPrintPreview returns TRUE, it means that
	// OnEndPrintPreview will be (or has already been) called and the
	// pState structure will be/has been deleted.
	// If DoPrintPreview returns FALSE, it means that OnEndPrintPreview
	// WILL NOT be called and that cleanup, including deleting pState
	// must be done here.

	if (!DoPrintPreview(XTP_IDD_PREVIEW_DIALOGBAR, this, RUNTIME_CLASS(CXTPPreviewView), pState))
	{
		// In derived classes, reverse special window handling here for
		// Preview failure case
		TRACE0("Error: DoPrintPreview failed.\n");
		AfxMessageBox(AFX_IDP_COMMAND_FAILURE);
		delete pState; // preview failed to initialize, delete State now
	}
}

/////////////////////////////////////////////////////////////////////////////
// CRibbonSampleView diagnostics

#ifdef _DEBUG
void CRibbonSampleView::AssertValid() const
{
	CScrollRichEditViewEx::AssertValid();
}

void CRibbonSampleView::Dump(CDumpContext& dc) const
{
	CScrollRichEditViewEx::Dump(dc);
}

CRibbonSampleDoc* CRibbonSampleView::GetDocument() // non-debug version is inline
{
	_ASSERTE(m_pDocument->IsKindOf(RUNTIME_CLASS(CRibbonSampleDoc)));
	return (CRibbonSampleDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CRibbonSampleView message handlers

void CRibbonSampleView::OnDestroy()
{
	CScrollRichEditViewEx::OnDestroy();
}

void CRibbonSampleView::OnRButtonUp(UINT /*nFlags*/, CPoint point)
{
	ClientToScreen(&point);

	CXTPCommandBars* pCommandBars = ((CMainFrame*)AfxGetMainWnd())->GetCommandBars();

	if (FALSE)
	{
		pCommandBars->TrackPopupMenu(IDR_MENU_CONTEXT, TPM_RIGHTBUTTON, point.x, point.y);
	}
	else
	{
		CXTPMiniToolBar* pMiniToolBar = DYNAMIC_DOWNCAST(
			CXTPMiniToolBar, pCommandBars->GetContextMenus()->FindCommandBar(IDR_MENU_MINITOOLBAR));
		if (!pMiniToolBar)
			return;

		CXTPPopupBar* pPopupBar = (CXTPPopupBar*)pCommandBars->GetContextMenus()->FindCommandBar(
			IDR_MENU_CONTEXT);

		pMiniToolBar->TrackPopupMenu(pPopupBar, 0, point.x, point.y);
	}
}

void CRibbonSampleView::OnLButtonDown(UINT nFlags, CPoint point)
{
	GetRichEditCtrl().GetSel(m_ptLastSel.x, m_ptLastSel.y);

	CScrollRichEditViewEx::OnLButtonDown(nFlags, point);
}

void CRibbonSampleView::OnLButtonUp(UINT nFlags, CPoint point)
{
	CScrollRichEditViewEx::OnLButtonUp(nFlags, point);

	CPoint ptSel;
	GetRichEditCtrl().GetSel(ptSel.x, ptSel.y);

	CMainFrame* pMainFrame = (CMainFrame*)AfxGetMainWnd();

	if ((ptSel.x != ptSel.y && ptSel != m_ptLastSel) && pMainFrame->m_bShowMiniToolbar)
	{
		ClientToScreen(&point);
		CXTPCommandBars* pCommandBars = pMainFrame->GetCommandBars();

		CXTPMiniToolBar* pMiniToolBar = DYNAMIC_DOWNCAST(
			CXTPMiniToolBar, pCommandBars->GetContextMenus()->FindCommandBar(IDR_MENU_MINITOOLBAR));
		if (!pMiniToolBar)
			return;

		pMiniToolBar->TrackMiniBar(0, point.x, point.y - 15);
	}
}

void CRibbonSampleView::OnUpdateEditUndo(CCmdUI* pCmd)
{
	CXTPControlGallery* pControlUndo = DYNAMIC_DOWNCAST(CXTPControlGallery,
														CXTPControl::FromUI(pCmd));

	if (pControlUndo)
	{
		pCmd->Enable(GetRichEditCtrl().CanUndo());

		CXTPControlGalleryItems* pItems = pControlUndo->GetItems();
		pItems->RemoveAll();

		int nCount = RAND_S() % 20 + 3;

		for (int i = 0; i < nCount; i++)
		{
			CString str;
			str.Format(_T("Undo String %i"), i + 1);
			pItems->AddItem(new CGalleryItemUndo(str), i);
		}

		pControlUndo->OnSelectedItemChanged();
		pControlUndo->SetHeight(pItems->GetItemSize().cy * nCount + 2);
	}
	else
	{
		CScrollRichEditViewEx::OnUpdateEditUndo(pCmd);
	}
}

void CRibbonSampleView::OnEditUndo(NMHDR* pNMHDR, LRESULT* pResult)
{
	CXTPControlGallery* pControlUndo = DYNAMIC_DOWNCAST(CXTPControlGallery,
														((NMXTPCONTROL*)pNMHDR)->pControl);
	if (pControlUndo)
	{
		CString str;
		str.Format(_T("Undo last %i actions"), pControlUndo->GetSelectedItem() + 1);
		AfxMessageBox(str);
	}
	else
	{
		CScrollRichEditViewEx::OnEditUndo();
	}

	*pResult = 1; // Handled;
}

//*****************************************
//				RIBBON COMMON
//*****************************************

void CRibbonSampleView::OnUpdateRibbonTab(CCmdUI* pCmdUI)
{
	CXTPRibbonControlTab* pControl = DYNAMIC_DOWNCAST(CXTPRibbonControlTab,
													  CXTPControl::FromUI(pCmdUI));
	if (!pControl)
		return;

	pCmdUI->Enable(TRUE);

	CRibbonSampleCntrItem* pItem = (CRibbonSampleCntrItem*)GetSelectedItem();

	BOOL bVisible = pItem != NULL && pItem->m_nImage == IDB_BITMAP_TABLE;

	pControl->GetParent()->LockRedraw();

	CXTPRibbonTab* pTab = pControl->FindTab(ID_TAB_TABLEDESIGN);
	if (NULL != pTab)
		pTab->SetVisible(bVisible);

	pTab = pControl->FindTab(ID_TAB_TABLELAYOUT);
	if (NULL != pTab)
		pTab->SetVisible(bVisible);

	bVisible = pItem != NULL && pItem->m_nImage == IDB_BITMAP_CHART;

	pTab = pControl->FindTab(ID_TAB_CHARTDESIGN);
	if (NULL != pTab)
		pTab->SetVisible(bVisible);

	pTab = pControl->FindTab(ID_TAB_CHARTFORMAT);
	if (NULL != pTab)
		pTab->SetVisible(bVisible);

	pTab = pControl->FindTab(ID_TAB_PICTUREFORMAT);
	if (NULL != pTab)
		pTab->SetVisible(pItem != NULL);

	pControl->GetParent()->UnlockRedraw();
}

//*****************************************
//				HOME / Font
//*****************************************

void CRibbonSampleView::OnGroupFont()
{
	OnFormatFont();
}

//*****************************************
//				INSERT / Illustrations
//*****************************************

void CRibbonSampleView::OnInsertSomeObject(UINT nID)
{
	if (!OpenClipboard())
		return;

	if (!::EmptyClipboard())
	{
		::CloseClipboard();
		return;
	}

	int nImage = nID - ID_ILLUSTRATION_PICTURE + IDB_BITMAP_PICTURE;

	CBitmap bmp;
	bmp.LoadBitmap(nImage);

	SetClipboardData(CF_BITMAP, (HANDLE)bmp.GetSafeHandle());

	::CloseClipboard();

	COleDataObject dataobj;
	dataobj.AttachClipboard();

	CWaitCursor wait;

	CRibbonSampleCntrItem* pItem = NULL;
	TRY
	{
		pItem		   = (CRibbonSampleCntrItem*)GetDocument()->CreateClientItem(NULL);
		pItem->m_bLock = TRUE;

		// paste embedded
		if (!pItem->CreateFromData(&dataobj) && !pItem->CreateStaticFromData(&dataobj))
		{
			AfxThrowMemoryException(); // any exception will do
		}

		HRESULT hr = InsertItem(pItem);
		pItem->UpdateItemType();

		pItem->m_bLock = FALSE;

		if (hr != NOERROR)
			AfxThrowOleException(hr);
	}
	CATCH(CException, e)
	{
		if (pItem != NULL)
		{
			pItem->m_bLock = FALSE;
			ASSERT_VALID(pItem);
			pItem->Delete();
			pItem = NULL;
		}
	}
	END_CATCH

	if (pItem)
	{
		pItem->m_nImage = nImage;
	}
}

//*****************************************
//				PAGE LAYOUT / Page Setup
//*****************************************

void CRibbonSampleView::OnGalleryColumns(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMXTPCONTROL* tagNMCONTROL = (NMXTPCONTROL*)pNMHDR;

	CXTPControlGallery* pGallery = DYNAMIC_DOWNCAST(CXTPControlGallery, tagNMCONTROL->pControl);
	if (pGallery)
	{
		CXTPControlGalleryItem* pItem = pGallery->GetItem(pGallery->GetSelectedItem());
		if (pItem)
		{
			m_nColumns = pItem->GetID();
			REPORT_NOT_IMPLEMENTED();
		}

		*pResult = TRUE; // Handled
	}
}

void CRibbonSampleView::OnUpdateGalleryColumns(CCmdUI* pCmdUI)
{
	CXTPControlGallery* pGallery = DYNAMIC_DOWNCAST(CXTPControlGallery,
													CXTPControl::FromUI(pCmdUI));
	if (pGallery)
	{
		pGallery->SetCheckedItem(m_nColumns);
	}

	pCmdUI->Enable(TRUE);
}

//*****************************************
//				BUTTONS / Large + Small
//*****************************************

void CRibbonSampleView::OnToggleButton()
{
	m_bToggleButton ^= 1;
}

void CRibbonSampleView::OnUpdateToggleButton(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bToggleButton);
}

void CRibbonSampleView::OnCheckbox(UINT nID)
{
	m_bCheckbox[nID - ID_BUTTONS_CHECKBOX1] ^= 1;
}

void CRibbonSampleView::OnRadioButton(UINT nID)
{
	m_nRadioButton = nID - ID_BUTTONS_RADIOBUTTON1;
}

void CRibbonSampleView::OnUpdateCheckbox(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bCheckbox[(int)pCmdUI->m_nID - ID_BUTTONS_CHECKBOX1]);
}

void CRibbonSampleView::OnUpdateRadioButton(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck((int)pCmdUI->m_nID - ID_BUTTONS_RADIOBUTTON1 == m_nRadioButton);
}

//*****************************************
//				BUTTONS / Editors
//*****************************************

void CRibbonSampleView::OnEnableButton(CCmdUI* pCmdUI)
{
	pCmdUI->Enable();
}

//*****************************************
//				Statusbar
//*****************************************

// Convert 0 -> 10%, 500 -> 100 %, 1000 -> 500 %

int PosToZoom(int nPos)
{
	return nPos <= 500 ? 10 + MulDiv(nPos, 90, 500) : 100 + MulDiv(nPos - 500, 400, 500);
}

int ZoomToPos(int nZoom)
{
	return nZoom < 100 ? MulDiv(nZoom - 10, 500, 90) : 500 + MulDiv(nZoom - 100, 500, 400);
}

#ifndef EM_SETZOOM
#	define EM_SETZOOM (WM_USER + 225)
#endif

void CRibbonSampleView::OnZoomSliderScroll(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMXTPSCROLL* pNMScroll		   = (NMXTPSCROLL*)pNMHDR;
	CXTPStatusBarSliderPane* pPane = DYNAMIC_DOWNCAST(CXTPStatusBarSliderPane, pNMScroll->pSender);
	if (!pPane)
		return;

	int nZoom = m_nZoom;

	switch (pNMScroll->nSBCode)
	{
		case SB_TOP: nZoom = 10; break;
		case SB_BOTTOM: nZoom = 500; break;

		case SB_LINEUP: nZoom = max(((nZoom / 10) - 1) * 10, 10); break;
		case SB_LINEDOWN: nZoom = min(((nZoom / 10) + 1) * 10, 500); break;

		case SB_THUMBTRACK:
			nZoom = PosToZoom(pNMScroll->nPos);
			if (nZoom > 90 && nZoom < 150)
				nZoom = 100;
			break;

		case SB_PAGEUP: nZoom = max(nZoom - 10, 10); break;
		case SB_PAGEDOWN: nZoom = min(nZoom + 10, 500); break;
	}

	if (nZoom == m_nZoom)
		return;

	m_nZoom = nZoom;

	pPane->SetPos(ZoomToPos(nZoom));

	CXTPStatusBar* pStatusBar = pPane->GetStatusBar();

	CXTPStatusBarPane* pPaneZoomIndicator = pStatusBar->FindPane(ID_INDICATOR_ZOOM);

	CString strZoom;
	strZoom.Format(_T("%i%%"), m_nZoom);
	pPaneZoomIndicator->SetText(strZoom);

	SendMessage(EM_SETZOOM, m_nZoom, 100);
}

CRect CRibbonSampleView::GetParentViewRect()
{
	return ((CWorkspaceView*)GetParent())->GetViewRect(CXTPClientRect(GetParent()));
}

CScrollBar* CRibbonSampleView::GetParentScrollbar(int nBar) const
{
	if (nBar != SB_VERT)
		return NULL;
	if (!AfxGetMainWnd())
		return NULL;
	return &((CWorkspaceView*)GetParent())->m_wndScrollBar[nBar];
}

COLORREF CRibbonSampleView::GetFrameColor()
{
#ifdef _XTP_INCLUDE_DOCKINGPANE
	return theApp.m_csPane.m_clrBorderDark;
#else
	return GetXtremeColor(COLOR_ACTIVEBORDER);
#endif
}