sprint/gtl/toolbar.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_TOOLBAR_H
#define _SPRINT_TOOLBAR_H

#include <sprint/gtl/Window.h>
#include <sprint/gtl/detail/commctrl.h>

namespace sprint {
        namespace gtl {

class ToolBar: public CWindow {
      public:
             //  
             void Create(HWND hParent, int id, int style =  TBSTYLE_FLAT | TBSTYLE_TOOLTIPS)
             {
              CommonControl::Instance();
              
              m_hwnd = CreateWindowEx(0, TOOLBARCLASSNAME, NULL, WS_CHILD | style, 0, 0, 0, 0,
                      hParent, (HMENU)id, GetModuleHandle(NULL), NULL);

            // Send the TB_BUTTONSTRUCTSIZE message, which is required for
                 // backward compatibility.
                 ::SendMessage(m_hwnd, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);

             }
             
    void OnSize()
    {
       ::SendMessage(m_hwnd, TB_AUTOSIZE, 0, 0);
    }

        bool IsButtonEnabled(int nID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_ISBUTTONENABLED, nID, 0L);
        }

        bool IsButtonChecked(int nID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_ISBUTTONCHECKED, nID, 0L);
        }

        bool IsButtonPressed(int nID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_ISBUTTONPRESSED, nID, 0L);
        }

        bool IsButtonHidden(int nID) const
        {
                return(bool) ::SendMessage(m_hwnd, TB_ISBUTTONHIDDEN, nID, 0L);
        }

        bool IsButtonIndeterminate(int nID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_ISBUTTONINDETERMINATE, nID, 0L);
        }

        int GetState(int nID) const
        {
                return (int)::SendMessage(m_hwnd, TB_GETSTATE, nID, 0L);
        }

        bool SetState(int nID, UINT nState)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETSTATE, nID, MAKELPARAM(nState, 0));
        }

        bool GetButton(int nIndex, LPTBBUTTON lpButton) const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETBUTTON, nIndex, (LPARAM)lpButton);
        }

        int GetButtonCount() const
        {
                return (int)::SendMessage(m_hwnd, TB_BUTTONCOUNT, 0, 0L);
        }

        bool GetItemRect(int nIndex, LPRECT lpRect) const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETITEMRECT, nIndex, (LPARAM)lpRect);
        }

        void SetButtonStructSize(int nSize = sizeof(TBBUTTON))
        {
                ::SendMessage(m_hwnd, TB_BUTTONSTRUCTSIZE, nSize, 0L);
        }

        bool SetButtonSize(SIZE size)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(size.cx, size.cy));
        }

        bool SetButtonSize(int cx, int cy)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(cx, cy));
        }

        bool SetBitmapSize(SIZE size)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(size.cx, size.cy));
        }

        bool SetBitmapSize(int cx, int cy)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(cx, cy));
        }
        
        void SetNotifyWnd(HWND hWnd)
        {
                ::SendMessage(m_hwnd, TB_SETPARENT, (WPARAM)hWnd, 0L);
        }

        int GetRows() const
        {
                return (int)::SendMessage(m_hwnd, TB_GETROWS, 0, 0L);
        }

        void SetRows(int nRows, bool bLarger, LPRECT lpRect)
        {
                ::SendMessage(m_hwnd, TB_SETROWS, MAKELPARAM(nRows, bLarger), (LPARAM)lpRect);
        }

        bool SetCmdID(int nIndex, UINT nID)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETCMDID, nIndex, nID);
        }

        DWORD GetBitmapFlags() const
        {
                return (DWORD)::SendMessage(m_hwnd, TB_GETBITMAPFLAGS, 0, 0L);
        }

        int GetBitmap(int nID) const
        {
                return (int)::SendMessage(m_hwnd, TB_GETBITMAP, nID, 0L);
        }

        int GetButtonText(int nID, LPTSTR lpstrText) const
        {
                return (int)::SendMessage(m_hwnd, TB_GETBUTTONTEXT, nID, (LPARAM)lpstrText);
        }

        // nIndex - IE5 or higher only
        HIMAGELIST GetImageList(int nIndex = 0) const
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_GETIMAGELIST, nIndex, 0L);
        }

        // nIndex - IE5 or higher only
        HIMAGELIST SetImageList(HIMAGELIST hImageList, int nIndex = 0)
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_SETIMAGELIST, nIndex, (LPARAM)hImageList);
        }

        // nIndex - IE5 or higher only
        HIMAGELIST GetDisabledImageList(int nIndex = 0) const
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_GETDISABLEDIMAGELIST, nIndex, 0L);
        }

        // nIndex - IE5 or higher only
        HIMAGELIST SetDisabledImageList(HIMAGELIST hImageList, int nIndex = 0)
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_SETDISABLEDIMAGELIST, nIndex, (LPARAM)hImageList);
        }
        

        DWORD GetStyle() const
        {
                return (DWORD)::SendMessage(m_hwnd, TB_GETSTYLE, 0, 0L);
        }

        void SetStyle(DWORD dwStyle)
        {
                ::SendMessage(m_hwnd, TB_SETSTYLE, 0, dwStyle);
        }

        SIZE GetButtonSize() const
        {
        SIZE size;
                DWORD dwRet = (DWORD)::SendMessage(m_hwnd, TB_GETBUTTONSIZE, 0, 0L);
                size.cx = LOWORD(dwRet);
                size.cy = HIWORD(dwRet);
                return size;
        }

        bool GetRect(int nID, LPRECT lpRect) const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETRECT, nID, (LPARAM)lpRect);
        }

        int GetTextRows() const
        {
                return (int)::SendMessage(m_hwnd, TB_GETTEXTROWS, 0, 0L);
        }

        bool SetButtonWidth(int cxMin, int cxMax)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONWIDTH, 0, MAKELPARAM(cxMin, cxMax));
        }

        bool SetIndent(int nIndent)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETINDENT, nIndent, 0L);
        }

        bool SetMaxTextRows(int nMaxTextRows)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETMAXTEXTROWS, nMaxTextRows, 0L);
        }

#if (_WIN32_IE >= 0x0400)
#ifndef _WIN32_WCE
        bool GetAnchorHighlight() const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETANCHORHIGHLIGHT, 0, 0L);
        }

        bool SetAnchorHighlight(bool bEnable = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETANCHORHIGHLIGHT, bEnable, 0L);
        }
#endif // !_WIN32_WCE

        int GetButtonInfo(int nID, LPTBBUTTONINFO lptbbi) const
        {
                return (int)::SendMessage(m_hwnd, TB_GETBUTTONINFO, nID, (LPARAM)lptbbi);
        }

        bool SetButtonInfo(int nID, LPTBBUTTONINFO lptbbi)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONINFO, nID, (LPARAM)lptbbi);
        }

        bool SetButtonInfo(int nID, DWORD dwMask, BYTE Style, BYTE State, LPCTSTR lpszItem, 
                           int iImage, WORD cx, int iCommand, DWORD_PTR lParam)
        {
                TBBUTTONINFO tbbi = { 0 };
                tbbi.cbSize = sizeof(TBBUTTONINFO);
                tbbi.dwMask = dwMask;
                tbbi.idCommand = iCommand;
                tbbi.iImage = iImage;
                tbbi.fsState = State;
                tbbi.fsStyle = Style;
                tbbi.cx = cx;
                tbbi.pszText = (LPTSTR) lpszItem;
                tbbi.lParam = lParam;
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONINFO, nID, (LPARAM)&tbbi);
        }

        bool SetButtonState(int nID, BYTE State)
        {
                TBBUTTONINFO tbbi = { 0 };
                tbbi.cbSize = sizeof(TBBUTTONINFO);
                tbbi.dwMask = TBIF_STATE;
                tbbi.fsState = State;
                return (bool)::SendMessage(m_hwnd, TB_SETBUTTONINFO, nID, (LPARAM)&tbbi);
        }

#ifndef _WIN32_WCE
        int GetHotItem() const
        {
                return (int)::SendMessage(m_hwnd, TB_GETHOTITEM, 0, 0L);
        }

        int SetHotItem(int nItem)
        {
                return (int)::SendMessage(m_hwnd, TB_SETHOTITEM, nItem, 0L);
        }
#endif // !_WIN32_WCE

        bool IsButtonHighlighted(int nButtonID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_ISBUTTONHIGHLIGHTED, nButtonID, 0L);
        }

        DWORD SetDrawTextFlags(DWORD dwMask, DWORD dwFlags)
        {
                return (DWORD)::SendMessage(m_hwnd, TB_SETDRAWTEXTFLAGS, dwMask, dwFlags);
        }

#ifndef _WIN32_WCE
        bool GetColorScheme(LPCOLORSCHEME lpcs) const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETCOLORSCHEME, 0, (LPARAM)lpcs);
        }

        void SetColorScheme(LPCOLORSCHEME lpcs)
        {
                ::SendMessage(m_hwnd, TB_SETCOLORSCHEME, 0, (LPARAM)lpcs);
        }

        DWORD GetExtendedStyle() const
        {
                return (DWORD)::SendMessage(m_hwnd, TB_GETEXTENDEDSTYLE, 0, 0L);
        }

        DWORD SetExtendedStyle(DWORD dwStyle)
        {
                return (DWORD)::SendMessage(m_hwnd, TB_SETEXTENDEDSTYLE, 0, dwStyle);
        }

        void GetInsertMark(LPTBINSERTMARK lptbim) const
        {
                ::SendMessage(m_hwnd, TB_GETINSERTMARK, 0, (LPARAM)lptbim);
        }

        void SetInsertMark(LPTBINSERTMARK lptbim)
        {
                ::SendMessage(m_hwnd, TB_SETINSERTMARK, 0, (LPARAM)lptbim);
        }

        COLORREF GetInsertMarkColor() const
        {
                return (COLORREF)::SendMessage(m_hwnd, TB_GETINSERTMARKCOLOR, 0, 0L);
        }

        COLORREF SetInsertMarkColor(COLORREF clr)
        {
                return (COLORREF)::SendMessage(m_hwnd, TB_SETINSERTMARKCOLOR, 0, (LPARAM)clr);
        }

        bool GetMaxSize(LPSIZE lpSize) const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETMAXSIZE, 0, (LPARAM)lpSize);
        }
#if 0
        void GetPadding(LPSIZE lpSizePadding) const
        {
                DWORD dwRet = (DWORD)::SendMessage(m_hwnd, TB_GETPADDING, 0, 0L);
                lpSizePadding->cx = GET_X_LPARAM(dwRet);
                lpSizePadding->cy = GET_Y_LPARAM(dwRet);
        }

        void SetPadding(int cx, int cy, LPSIZE lpSizePadding = NULL)
        {
                DWORD dwRet = (DWORD)::SendMessage(m_hwnd, TB_SETPADDING, 0, MAKELPARAM(cx, cy));
                if(lpSizePadding != NULL)
                {
                        lpSizePadding->cx = GET_X_LPARAM(dwRet);
                        lpSizePadding->cy = GET_Y_LPARAM(dwRet);
                }
        }
#endif
        bool GetUnicodeFormat() const
        {
                return (bool)::SendMessage(m_hwnd, TB_GETUNICODEFORMAT, 0, 0L);
        }

        bool SetUnicodeFormat(bool bUnicode = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_SETUNICODEFORMAT, bUnicode, 0L);
        }
#endif // !_WIN32_WCE
#endif // (_WIN32_IE >= 0x0400)

#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
        int GetString(int nString, LPTSTR lpstrString, int cchMaxLen) const
        {
                return (int)::SendMessage(m_hwnd, TB_GETSTRING, MAKEWPARAM(cchMaxLen, nString), (LPARAM)lpstrString);
        }

#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)

#if (_WIN32_WINNT >= 0x0501)
        void GetMetrics(LPTBMETRICS lptbm) const
        {
                ::SendMessage(m_hwnd, TB_GETMETRICS, 0, (LPARAM)lptbm);
        }

        void SetMetrics(LPTBMETRICS lptbm)
        {
                ::SendMessage(m_hwnd, TB_SETMETRICS, 0, (LPARAM)lptbm);
        }

        void SetWindowTheme(LPCWSTR lpstrTheme)
        {
                ::SendMessage(m_hwnd, TB_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
        }
#endif // (_WIN32_WINNT >= 0x0501)

#if (_WIN32_WINNT >= 0x0600)
        HIMAGELIST GetPressedImageList(int nIndex = 0) const
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_GETPRESSEDIMAGELIST, nIndex, 0L);
        }

        HIMAGELIST SetPressedImageList(HIMAGELIST hImageList, int nIndex = 0)
        {
                return (HIMAGELIST)::SendMessage(m_hwnd, TB_SETPRESSEDIMAGELIST, nIndex, (LPARAM)hImageList);
        }
#endif // (_WIN32_WINNT >= 0x0600)

// Operations
        bool EnableButton(int nID, bool bEnable = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_ENABLEBUTTON, nID, MAKELPARAM(bEnable, 0));
        }

        bool CheckButton(int nID, bool bCheck = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_CHECKBUTTON, nID, MAKELPARAM(bCheck, 0));
        }

        bool PressButton(int nID, bool bPress = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_PRESSBUTTON, nID, MAKELPARAM(bPress, 0));
        }

        bool HideButton(int nID, bool bHide = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_HIDEBUTTON, nID, MAKELPARAM(bHide, 0));
        }

        bool Indeterminate(int nID, bool bIndeterminate = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_INDETERMINATE, nID, MAKELPARAM(bIndeterminate, 0));
        }

        int AddBitmap(int nNumButtons, UINT nBitmapID)
        {
                TBADDBITMAP tbab = { 0 };
                tbab.hInst = ::GetModuleHandle(NULL);
                tbab.nID = nBitmapID;
                return (int)::SendMessage(m_hwnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab);
        }

        int AddBitmap(int nNumButtons, HBITMAP hBitmap)
        {
                TBADDBITMAP tbab = { 0 };
                tbab.hInst = NULL;
                tbab.nID = (UINT_PTR)hBitmap;
                return (int)::SendMessage(m_hwnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab);
        }

        bool AddButtons(int nNumButtons, LPTBBUTTON lpButtons)
        {
                return (bool)::SendMessage(m_hwnd, TB_ADDBUTTONS, nNumButtons, (LPARAM)lpButtons);
        }

        bool InsertButton(int nIndex, LPTBBUTTON lpButton)
        {
                return (bool)::SendMessage(m_hwnd, TB_INSERTBUTTON, nIndex, (LPARAM)lpButton);
        }

        bool InsertButton(int nIndex, int iCommand, BYTE Style, BYTE State, int iBitmap, 
                          INT_PTR iString, DWORD_PTR lParam)
        {
                TBBUTTON tbb = { 0 };
                tbb.fsStyle = Style;
                tbb.fsState = State;
                tbb.idCommand = iCommand;
                tbb.iBitmap = iBitmap;
                tbb.iString = iString;
                tbb.dwData = lParam;
                return (bool)::SendMessage(m_hwnd, TB_INSERTBUTTON, nIndex, (LPARAM)&tbb);
        }

        bool InsertButton(int nIndex, int iCommand, BYTE Style, BYTE State, int iBitmap, 
                          LPCTSTR lpszItem, DWORD_PTR lParam)
        {
                return InsertButton(nIndex, iCommand, Style, State, iBitmap, (INT_PTR)lpszItem, lParam);
        }

        bool AddButton(LPTBBUTTON lpButton)
        {
                return InsertButton(-1, lpButton);
        }

        bool AddSeparator()
        {
        return InsertButton(-1, 0, TBSTYLE_SEP, 0, 0, 0, 0); 
    }

        bool AddButton(int iCommand, BYTE Style, BYTE State, int iBitmap)
        {
                return InsertButton(-1, iCommand, Style, State, iBitmap, 0, 0);
        }

        bool AddButton(int iCommand, BYTE Style, BYTE State, int iBitmap, INT_PTR iString, DWORD_PTR lParam)
        {
                return InsertButton(-1, iCommand, Style, State, iBitmap, iString, lParam);
        }

        bool AddButton(int iCommand, BYTE Style, BYTE State, int iBitmap, LPCTSTR lpszItem, DWORD_PTR lParam)
        {
                return InsertButton(-1, iCommand, Style, State, iBitmap, lpszItem, lParam);
        }

        bool DeleteButton(int nIndex)
        {
                return (bool)::SendMessage(m_hwnd, TB_DELETEBUTTON, nIndex, 0L);
        }

        UINT CommandToIndex(UINT nID) const
        {
                return (UINT)::SendMessage(m_hwnd, TB_COMMANDTOINDEX, nID, 0L);
        }

#ifndef _WIN32_WCE
        void SaveState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName)
        {
                TBSAVEPARAMS tbs = { 0 };
                tbs.hkr = hKeyRoot;
                tbs.pszSubKey = lpszSubKey;
                tbs.pszValueName = lpszValueName;
                ::SendMessage(m_hwnd, TB_SAVERESTORE, (WPARAM)TRUE, (LPARAM)&tbs);
        }

        void RestoreState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName)
        {
                TBSAVEPARAMS tbs = { 0 };
                tbs.hkr = hKeyRoot;
                tbs.pszSubKey = lpszSubKey;
                tbs.pszValueName = lpszValueName;
                ::SendMessage(m_hwnd, TB_SAVERESTORE, (WPARAM)FALSE, (LPARAM)&tbs);
        }

        void Customize()
        {
                ::SendMessage(m_hwnd, TB_CUSTOMIZE, 0, 0L);
        }
#endif // !_WIN32_WCE

        int AddString(UINT nStringID)
        {
                return (int)::SendMessage(m_hwnd, TB_ADDSTRING, (WPARAM)GetModuleHandle(NULL), (LPARAM)nStringID);
        }

        int AddStrings(LPCTSTR lpszStrings)
        {
                return (int)::SendMessage(m_hwnd, TB_ADDSTRING, 0, (LPARAM)lpszStrings);
        }

        void AutoSize()
        {
                ::SendMessage(m_hwnd, TB_AUTOSIZE, 0, 0L);
        }
/* Changes the bitmap for a button in a toolbar. */
        bool ChangeBitmap(int nID, int nBitmap)
        {
                return (bool)::SendMessage(m_hwnd, TB_CHANGEBITMAP, nID, MAKELPARAM(nBitmap, 0));
        }

// Load a bitmap from local RESOURCE file
        int LoadImages(int nBitmapID)
        {
                return (int)::SendMessage(m_hwnd, TB_LOADIMAGES, nBitmapID, (LPARAM)GetModuleHandle(NULL));
        }

        int LoadStdImages(int nBitmapID)
        {
                return (int)::SendMessage(m_hwnd, TB_LOADIMAGES, nBitmapID, (LPARAM)HINST_COMMCTRL);
        }

        bool ReplaceBitmap(LPTBREPLACEBITMAP ptbrb)
        {
                return (bool)::SendMessage(m_hwnd, TB_REPLACEBITMAP, 0, (LPARAM)ptbrb);
        }

#if (_WIN32_IE >= 0x0400)
        int HitTest(LPPOINT lpPoint) const
        {
                return (int)::SendMessage(m_hwnd, TB_HITTEST, 0, (LPARAM)lpPoint);
        }

#ifndef _WIN32_WCE
        bool InsertMarkHitTest(LPPOINT lpPoint, LPTBINSERTMARK lptbim) const
        {
                return (bool)::SendMessage(m_hwnd, TB_INSERTMARKHITTEST, (WPARAM)lpPoint, (LPARAM)lptbim);
        }

        bool InsertMarkHitTest(int x, int y, LPTBINSERTMARK lptbim) const
        {
                POINT pt = { x, y };
                return (bool)::SendMessage(m_hwnd, TB_INSERTMARKHITTEST, (WPARAM)&pt, (LPARAM)lptbim);
        }

        bool MapAccelerator(TCHAR chAccel, int& nID) const
        {
                return (bool)::SendMessage(m_hwnd, TB_MAPACCELERATOR, (WPARAM)chAccel, (LPARAM)&nID);
        }

        bool MarkButton(int nID, bool bHighlight = TRUE)
        {
                return (bool)::SendMessage(m_hwnd, TB_MARKBUTTON, nID, MAKELPARAM(bHighlight, 0));
        }

        bool MoveButton(int nOldPos, int nNewPos)
        {
                return (bool)::SendMessage(m_hwnd, TB_MOVEBUTTON, nOldPos, nNewPos);
        }

        HRESULT GetObject(REFIID iid, LPVOID* ppvObject)
        {
                return (HRESULT)::SendMessage(m_hwnd, TB_GETOBJECT, (WPARAM)&iid, (LPARAM)ppvObject);
        }
#endif // !_WIN32_WCE
#endif // (_WIN32_IE >= 0x0400) 
             
      };
      
          }
}

#endif