void CMyToolBar::InsertLabel(int nPos, UINT nID, CFont* pFont)
{
	Label label;
	label.nID = nID;
	label.strText = LoadString(nID);
	label.pFont = pFont;
	m_labels.push_back(label);

	CScreenDC dcScreen;
	CFont* pOldFont = dcScreen.SelectObject(pFont);
	int nWidth = dcScreen.GetTextExtent(label.strText).cx + 3;
	dcScreen.SelectObject(pOldFont);

	TBBUTTON btn;
	ZeroMemory(&btn, sizeof(btn));
	btn.idCommand = nID;
	btn.fsStyle = TBSTYLE_BUTTON;

	TBBUTTONINFO info;
	ZeroMemory(&info, sizeof(info));
	info.cbSize = sizeof(info);
	info.dwMask = TBIF_SIZE;
	info.cx = nWidth;

	GetToolBarCtrl().InsertButton(nPos, &btn);
	GetToolBarCtrl().SetButtonInfo(nID, &info);
}

CWnd* CToolBarEx::InsertControl(CWnd* pCtrl, RECT& rect, UINT nID)
{
	ASSERT_VALID(pCtrl);
	// make sure the id is valid, and set the button style for a seperator.
	int nState, nIndex = CommandToIndex(nID);
	if (nIndex > -1)
	{
		ASSERT(nIndex >= 0);
		SetButtonInfo(nIndex, nID, TBBS_SEPARATOR, rect.right - rect.left);
		// insert the control into the toolbar.
		GetItemRect(nIndex, &rect);				
		pCtrl->SetWindowPos(0, rect.left, rect.top, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS);
		pCtrl->SetFont(GetFont());

		BOOL bVert = (m_dwStyle & CBRS_ORIENT_VERT) != 0;
		if (bVert)
		{
		   	nState = GetToolBarCtrl().GetState(nIndex);
		   	GetToolBarCtrl().SetState(nID,(nState | TBSTATE_HIDDEN));
			pCtrl->ShowWindow(SW_HIDE);
		}
		else
		{
		   	nState = GetToolBarCtrl().GetState(nIndex);
		   	GetToolBarCtrl().SetState(nIndex,(nState & ~TBSTATE_HIDDEN));
			pCtrl->ShowWindow(SW_SHOW);
		}
	}
	else pCtrl->ShowWindow(SW_HIDE);	
	return pCtrl;	
}

void CFormatBar::SyncToView()
{
	// get the current font from the view and update
	CHARHDR fh;
	CHARFORMAT& cf = fh.cf;
	cf.dwMask = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE | CFM_COLOR | CFM_FACE | CFM_SIZE;
	fh.hwndFrom = m_hWnd;
	fh.idFrom = GetDlgCtrlID();
	fh.code = FN_GETFORMAT;
	CWnd *pWnd = GetOwner();
	VERIFY(GetOwner()->SendMessage(WM_NOTIFY, fh.idFrom, (LPARAM)&fh));

	GetToolBarCtrl().CheckButton(ID_CHAR_BOLD, cf.dwEffects & CFE_BOLD);
	GetToolBarCtrl().CheckButton(ID_CHAR_ITALIC, cf.dwEffects & CFE_ITALIC);
	GetToolBarCtrl().CheckButton(ID_CHAR_UNDERLINE, cf.dwEffects & CFE_UNDERLINE);		

	// the selection must be same font and charset to display correctly
	if ((cf.dwMask & (CFM_FACE|CFM_CHARSET)) == (CFM_FACE|CFM_CHARSET))
		m_comboFontName.MatchFont(cf.szFaceName, cf.bCharSet);
	else
		m_comboFontName.SetTheText(_T(""));

	// SetTwipSize only updates if different
	// -1 means selection is not a single point size
	m_comboFontSize.SetTwipSize( (cf.dwMask & CFM_SIZE) ? cf.yHeight : -1);
}

BOOL CToolBarEx::ShowGroup(int iGrp, int iWhere)
{
	if (iGrp >= m_vGroups.size ())
		return FALSE;

	fs::list <fsTBInfo> *pGroup = &m_vGroups [iGrp];

	for (int i = 0; i < pGroup->size (); i++)
	{
		fsTBInfo *tb = &pGroup->at (i);
		TBBUTTON btn;

		
		btn.dwData = iGrp;
		btn.fsState = TBSTATE_ENABLED;
		btn.fsStyle = tb->bStyle;
		
		btn.iBitmap = tb->iImage;
		btn.idCommand = tb->idCommand;
		btn.iString = tb->iName;

		GetToolBarCtrl ().InsertButton (iWhere++, &btn);
	}

	GetToolBarCtrl().AutoSize();

	UpdateSize ();

	return TRUE;
}

void CDkToolBar::UpdateButtonImage()
{
	TBBUTTONINFO tbbi;
	ZeroMemory(&tbbi, sizeof(TBBUTTONINFO));
	tbbi.cbSize = sizeof(TBBUTTONINFO);
	tbbi.dwMask = TBIF_IMAGE;
	GetToolBarCtrl().GetButtonInfo(ID_CONV_FORMAT_USER, &tbbi);
	tbbi.iImage = nDyImageIndex + g_nUserConvFormatType;
	GetToolBarCtrl().SetButtonInfo(ID_CONV_FORMAT_USER, &tbbi);
}

CSize CToolBarXP::CalcDynamicLayout (int nLength, DWORD dwMode)
{
    bool bHideControls = (dwMode & LM_VERTDOCK) == LM_VERTDOCK;
    m_bCheckVisibility = (BYTE)(bHideControls ? 1 : 2);
    CSize size = CToolBar::CalcDynamicLayout (nLength, dwMode);
    m_bCheckVisibility = false;

    if ( dwMode & LM_COMMIT )
    {
        TBBUTTON tbbutton;
        int nCount = DefWindowProc (TB_BUTTONCOUNT, 0, 0);

        for ( int i = 0; i < nCount; i++ )
        {
            VERIFY(DefWindowProc (TB_GETBUTTON, i, (LPARAM)&tbbutton));

            if ( !IS_CONTROL(tbbutton) )
            {
                continue;
            }
            CWnd* pWnd = GetDlgItem (tbbutton.idCommand);

            if ( pWnd == NULL )
            {
                continue;
            }
            if ( bHideControls )
            {
                GetToolBarCtrl().HideButton (tbbutton.idCommand, true);
                pWnd->ShowWindow (SW_HIDE);
            }
            else
            {
                GetToolBarCtrl().HideButton (tbbutton.idCommand, false);

                // Update control position
                CRect rcControl;

                VERIFY (DefWindowProc (TB_GETITEMRECT, i, (LPARAM)&rcControl));
                rcControl.DeflateRect (1, 1);
                
                CWindowRect rcCtrl (pWnd);
                int         nNoSize = 0;

                if ( rcControl.Width() == rcCtrl.Width() )
                {
                    nNoSize = SWP_NOSIZE;
                }
                pWnd->SetWindowPos (NULL, rcControl.left, rcControl.top, rcControl.Width(), rcControl.Height(),
                                    nNoSize|SWP_NOACTIVATE|SWP_NOZORDER|SWP_SHOWWINDOW);
            }
        }
    }
    return size;
}

int CSearchBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CToolBar::OnCreate(lpCreateStruct) == -1)
		return -1;

	GetToolBarCtrl().SetBitmapSize(CSize(16, 16));

	LPCTSTR cls_name;
	if (riched20)
		cls_name = "RichEdit20A";
	else
		cls_name = "EDIT";

	hedit = CreateWindowEx(WS_EX_CLIENTEDGE, cls_name, NULL, ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE,
						   0, 0, 0, 0, m_hWnd, NULL, AfxGetInstanceHandle(), NULL);

	if (riched20)
	{
		::SendMessage(hedit, EM_SETTEXTMODE, TM_PLAINTEXT | TM_MULTICODEPAGE, 0);
		::SendMessage(hedit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELPARAM(2, 2));
		::SendMessage(hedit, EM_SETUNDOLIMIT, 1, 0);
	}

	old_search_bar_proc = (WNDPROC)::GetWindowLong(hedit, GWL_WNDPROC);
	::SetWindowLong(hedit, GWL_WNDPROC, (LONG)EditProc);
	::SetWindowLong(hedit, GWL_USERDATA, (LONG)this);

	CToolBarCtrl& toolbar = GetToolBarCtrl();

	toolbar.AddButtons(1, searchbar_btns);
	toolbar.SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
	toolbar.SetIndent(100);
	toolbar.AutoSize();

	int n = SearchPluginCollection.GetCount();
	if (n > 0)
	{
		for (int i = 0; i < n; ++i)
		{
			HBITMAP hbmp = SearchPluginCollection.GetImage(i);
			if (hbmp)
			{
				TBADDBITMAP tbab;
				tbab.hInst = NULL;
				tbab.nID = (UINT)hbmp;
				::SendMessage(toolbar.m_hWnd, TB_ADDBITMAP, 1, (LPARAM)&tbab);
			}
		}
	}

	UpdateBtn();
	EnableToolTips();
	return 0;
}

void CRRECToolBar::OnSize(UINT nType, int cx, int cy)
{
    GetToolBarCtrl().SetButtonSize(m_sizeButton);

    CEnToolBar::OnSize(nType, cx, cy);

    CSize size(GetToolBarCtrl().GetButtonSize());

    if (m_font.GetSafeHwnd())
    {
        CRect rDiv;

        // calc length after which we want to start shortening ctrls
        GetItemRect(1, &rDiv); // divider
        const int DEFCTRLSWIDTH = FONT_COMBO_WIDTH + SIZE_COMBO_WIDTH +
                                  (5 * rDiv.Width()) / 2; // 2.5 separators

        // if the toolbar length is less than the default
        // width of the embedded widgets we reduce the
        // font combo as far as we can.
        TBBUTTONINFO tbi;
        tbi.cbSize = sizeof( TBBUTTONINFO );
        tbi.dwMask = TBIF_SIZE;  // By index

        CRect rect;
        GetItemRect( FONT_NAME_POS, &rect );

        rect.left++;
        rect.top++;
        rect.bottom += COMBO_HEIGHT;

        int nNewWidth = FONT_COMBO_WIDTH - max(0, DEFCTRLSWIDTH - cx);
        nNewWidth = max(nNewWidth, MIN_FONT_COMBO_WIDTH);

        if (nNewWidth != rect.Width())
        {
            rect.right = rect.left + nNewWidth;
            rect.bottom += COMBO_HEIGHT;
            m_font.MoveWindow(rect);

            // update toolbar item size also
            tbi.cx = (WORD)rect.Width();
            GetToolBarCtrl().SetButtonInfo(FONT_NAME_ID, &tbi);

            // move the other two items to suit their toolbar rects
            GetItemRect(FONT_SIZE_POS, &rect);
            rect.top++;
            rect.bottom += COMBO_HEIGHT;
            m_size.MoveWindow(rect);
        }
    }
}

int CMainToolBar::HitTestButton(CPoint &pt) {
  int index = GetToolBarCtrl().HitTest(&pt);
  if (index >= 0)
    return GetItemID(index);

  return index;
}

HRESULT CTRiASToolBar::DeleteItem (int iIndex)
{
	AFX_MANAGE_STATE(AfxGetModuleState());
    ASSERT_VALID(this);
    ASSERT(::IsWindow(m_hWnd));

TBBUTTON button;

	_GetButtonEx (iIndex, &button);

	if (0 != button.idCommand && !m_Owners.erase (button.idCommand))
		return E_FAIL;

#if !defined(_USE_SEC_CLASSES)
CToolBarCtrl &rTB = GetToolBarCtrl();
HRESULT hr = rTB.DeleteButton (iIndex) ? NOERROR : S_FALSE;
#else
HRESULT hr = m_pMainFrm -> DeleteButton (this, iIndex);
#endif // _USE_SEC_CLASSES
	
	if (S_OK == hr && IsWindowVisible())
		m_pMainFrm -> DelayRecalcLayout();

	return hr;
}

void CPWFindToolBar::ChangeImages(const int toolbarMode)
{
  CToolBarCtrl& tbCtrl = GetToolBarCtrl();
  m_toolbarMode = toolbarMode;
  const int nImageListNum = (m_toolbarMode == ID_MENUITEM_OLD_TOOLBAR) ? 0 : m_bitmode;
  tbCtrl.SetImageList(&m_ImageLists[nImageListNum]);
}

void CToolBarEx::OnReset( NMHDR* /*pNMHDR*/, LRESULT* pResult )
{
    // Delete all buttons
    CToolBarCtrl& tbCtrl = GetToolBarCtrl();
    while ( tbCtrl.DeleteButton( 0 ) );

    // Load buttons from internal cache
    for ( int nIndex = 0; nIndex <= m_aButtons.GetUpperBound(); nIndex++ )
    {
        if ( m_aButtons[ nIndex ].bInitiallyVisible )
        {
            VERIFY( tbCtrl.AddButtons( 1, &m_aButtons[ nIndex ].tbinfo ) );
        }
    }

    // Set default text & icon options
    SetIconOptions( m_eIconOptionsDefault, false );
    SetTextOptions( m_eTextOptionsDefault, false );
    ReloadButtons();
    UpdateParentBandInfo();

    // Synchronize with Customize dialog
    ASSERT( m_pCustomizeDlg != 0 );
    m_pCustomizeDlg->SetTextOptions( m_eTextOptions, true );
    m_pCustomizeDlg->SetIconOptions( m_eIconOptions, true );

    *pResult = 0;
}

BOOL CPlayerToolBar::OnToolTipNotify(UINT id, NMHDR* pNMHDR, LRESULT* pResult)
{
    TOOLTIPTEXT* pTTT = (TOOLTIPTEXT*)pNMHDR;

    UINT_PTR nID = pNMHDR->idFrom;
    if (pTTT->uFlags & TTF_IDISHWND) {
        nID = ::GetDlgCtrlID((HWND)nID);
    }

    if (nID != ID_VOLUME_MUTE) {
        return FALSE;
    }

    CToolBarCtrl& tb = GetToolBarCtrl();
    TBBUTTONINFO bi;
    bi.cbSize = sizeof(bi);
    bi.dwMask = TBIF_IMAGE;
    tb.GetButtonInfo(ID_VOLUME_MUTE, &bi);

    static CString strTipText;
    if (bi.iImage == 12) {
        strTipText.LoadString(ID_VOLUME_MUTE);
    } else if (bi.iImage == 13) {
        strTipText.LoadString(ID_VOLUME_MUTE_ON);
    } else if (bi.iImage == 14) {
        strTipText.LoadString(ID_VOLUME_MUTE_DISABLED);
    } else {
        return FALSE;
    }
    pTTT->lpszText = (LPWSTR)(LPCWSTR)strTipText;

    *pResult = 0;

    return TRUE;    // message was handled
}

xpr_bool_t BookmarkToolBar::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
    NMHDR *pnmhdr = (NMHDR *)lParam;

    if (pnmhdr->code == TTN_GETDISPINFO)
    {
        if (gOpt->mConfig.mBookmarkTooltip == XPR_TRUE)
        {
            LPNMTTDISPINFO sNmTtDispInfo = (LPNMTTDISPINFO)pnmhdr;

            CPoint sPoint;
            GetCursorPos(&sPoint);
            ScreenToClient(&sPoint);

            xpr_sint_t sIndex = GetToolBarCtrl().HitTest(&sPoint);

            BookmarkItem *sBookmarkItem = BookmarkMgr::instance().getBookmark(sIndex);
            if (sBookmarkItem == XPR_NULL)
                return XPR_FALSE;

            sBookmarkItem->getTooltip(mToolTipText, !gOpt->mMain.mBookmarkBarText, XPR_TRUE);

            sNmTtDispInfo->lpszText = mToolTipText;
        }
    }

    return super::OnNotify(wParam, lParam, pResult);
}

void CDynToolBar::ChangeButtonIDS(UINT ID1, UINT ID2, UINT IDRQD)
  {
  if (bCanConfigure)
    {
    CToolBarCtrl& bc = GetToolBarCtrl();
    int Cnt = bc.GetButtonCount();
    BOOL Chngd = FALSE;
    UINT* NewIDs = new UINT[Cnt];
    Strng Item;
    for (int i=0; i<Cnt; i++)
      {
      TBBUTTON B;
      bc.GetButton(i, &B);
      NewIDs[i]=B.idCommand;
      if (B.idCommand==(int)ID1 || B.idCommand==(int)ID2)
        {
        Chngd=true;
        NewIDs[i]=IDRQD;
        }
      }
    if (Chngd)
      ChangeButtons(NewIDs, Cnt);
    delete []NewIDs;
    }
  // the toolbar has changed
  }

void BookmarkToolBar::setBookmark(void)
{
    if (mInit == XPR_FALSE)
        return;

    if (mImgList.m_hImageList != XPR_NULL)
        mImgList.DeleteImageList();

    mImgList.Create(16, 16, ILC_COLOR32 | ILC_MASK, -1, -1);
    GetToolBarCtrl().SetImageList(&mImgList);

    BookmarkMgr &sBookmarkMgr = BookmarkMgr::instance();

    xpr_sint_t sCount = sBookmarkMgr.getCount();
    if (sCount > 0)
    {
        sBookmarkMgr.getAllIcon();

        xpr_sint_t i;
        for (i = 0; i < sCount; ++i)
            addBookmarkButton(i, sBookmarkMgr.getBookmark(i));
    }

    UpdateToolbarSize();
}

BOOL CToolBarEx::Create(CWnd* pParent)
{
	if (!CreateEx (pParent, TBSTYLE_FLAT | TBSTYLE_TRANSPARENT
			,
			WS_CHILD | WS_VISIBLE | CBRS_TOOLTIPS | CBRS_ALIGN_TOP)
			)
		return FALSE;

	m_bar = &GetToolBarCtrl ();

	m_bar->SetBitmapSize (CSize (_TB_SIZE_X, _TB_SIZE_Y));

	SetSizes (CSize (_TB_SIZE_X+7, _TB_SIZE_Y+7),
		CSize (_TB_SIZE_X, _TB_SIZE_Y));

 	if (!m_images.Create (_TB_SIZE_X, _TB_SIZE_Y, ILC_COLOR32 | ILC_MASK, 30, 5))
		return FALSE;

	m_dimages.Create (_TB_SIZE_X, _TB_SIZE_Y, ILC_COLOR32 | ILC_MASK, 30, 5);

	m_bar->SetImageList (&m_images);
	m_bar->SetDisabledImageList (&m_dimages);

	return TRUE;
}

void CToolBarEx::SetIconOptions( EIconOptions eIconOptions, bool bUpdate /*=true*/ )
{
    ASSERT( ::IsWindow( m_hWnd ) );
    ASSERT( IsIconOptionAvailable( eIconOptions ) );

    m_eIconOptions = eIconOptions;

    // Set image list(s) and icon size for selected icon options
    CToolBarCtrl& tbCtrl = GetToolBarCtrl();
    tbCtrl.SetImageList( 0 );
    tbCtrl.SetHotImageList( 0 );
    tbCtrl.SetDisabledImageList( 0 );

    CSize szIcon = ( eIconOptions == ioSmallIcons ) ? m_szImageSmall : m_szImageLarge;
	 VERIFY( tbCtrl.SetBitmapSize( szIcon ) );

    UINT nIDCold     = ( eIconOptions == ioSmallIcons ) ? m_nIDSmallCold     : m_nIDLargeCold;
    UINT nIDHot      = ( eIconOptions == ioSmallIcons ) ? m_nIDSmallHot      : m_nIDLargeHot;
    UINT nIDDisabled = ( eIconOptions == ioSmallIcons ) ? m_nIDSmallDisabled : m_nIDLargeDisabled;
    ASSERT( nIDCold != ( UINT )-1 );    // at least there must be "cold" imagelist

    LPCTSTR lpResName = MAKEINTRESOURCE( nIDCold );
    HINSTANCE hInst = AfxFindResourceHandle( lpResName, RT_BITMAP );

    m_imageListCold.DeleteImageList();
    VERIFY( m_imageListCold.Attach( ImageList_LoadImage( hInst, lpResName,
        szIcon.cx, 0, m_clrMask, IMAGE_BITMAP, LR_CREATEDIBSECTION ) ) );
    tbCtrl.SetImageList( &m_imageListCold );

    if ( nIDHot != ( UINT )-1 ) // "hot" imagelist is optional
    {
        lpResName = MAKEINTRESOURCE( nIDHot );
        hInst = AfxFindResourceHandle( lpResName, RT_BITMAP );

        m_imageListHot.DeleteImageList();
        VERIFY( m_imageListHot.Attach( ImageList_LoadImage( hInst, lpResName,
            szIcon.cx, 0, m_clrMask, IMAGE_BITMAP, LR_CREATEDIBSECTION ) ) );
        tbCtrl.SetHotImageList( &m_imageListHot );
    }

    if ( nIDDisabled != ( UINT )-1 ) // "disabled" imagelist is optional
    {
        lpResName = MAKEINTRESOURCE( nIDDisabled );
        hInst = AfxFindResourceHandle( lpResName, RT_BITMAP );

        m_imageListDisabled.DeleteImageList();
        VERIFY( m_imageListDisabled.Attach( ImageList_LoadImage( hInst, lpResName,
            szIcon.cx, 0, m_clrMask, IMAGE_BITMAP, LR_CREATEDIBSECTION ) ) );
        tbCtrl.SetDisabledImageList( &m_imageListDisabled );
    }

    // If requested, reflect changes immediately
    if ( bUpdate )
    {
        ReloadButtons();
        UpdateParentBandInfo();
    }
}

void CDkToolBar::UpdatePluginButton()
{
	int nPos = 0;
	while (TRUE) {
		CPluginToolBarInfo* button = FindPluginToolBarInfo(nPos);
		if (button == NULL) break;
		if (button->nPos < 0) {
			button->nIndex = -2;
			continue;
		}
		int nIndex = GetToolBarCtrl().GetButtonCount();
		GetToolBarCtrl().InsertButton(nIndex, &button->tbButton);
		if (nIndex != button->nPos) {
			GetToolBarCtrl().MoveButton(nIndex, button->nPos);
		}
		button->nIndex = nIndex;
	}
}

void CSearchBar::OnSize(UINT nType, int cx, int cy)
{
	CToolBar::OnSize(nType, cx, cy);
	CRect rc;
	GetItemRect(0, rc);

	::MoveWindow(hedit, 1, 1, cx - rc.Width() - 6, cy - 2, TRUE);
	GetToolBarCtrl().SetIndent(cx - rc.Width() - 4);
}