sprint/gtl/Menu.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_MENU_H
#define _SPRINT_MENU_H

namespace sprint {
        namespace gtl {

// fw
template <bool t_bManaged> class CMenuT;

// non rilascia il menu
typedef CMenuT<false>   CMenuHandle;

// Rilascia il menu
typedef CMenuT<true>    CMenu;

template <bool t_bManaged> 
class CMenuT {
      HMENU m_hMenu;
      public:
      CMenuT(HMENU hmenu = NULL) : m_hMenu(hmenu) { }

      bool Check(int id, bool status)
      {     
      return ::CheckMenuItem(m_hMenu, id,
            MF_BYCOMMAND | (status ? MF_CHECKED : MF_UNCHECKED));
      }

        ~CMenuT()
        {
                if(t_bManaged && m_hMenu != NULL)
                        DestroyMenu();
        }

        CMenuT<t_bManaged>& operator =(HMENU hMenu)
        {
                Attach(hMenu);
                return *this;
        }

        void Attach(HMENU hMenuNew)
        {
                if(t_bManaged && m_hMenu != NULL && m_hMenu != hMenuNew)
                        ::DestroyMenu(m_hMenu);
                m_hMenu = hMenuNew;
        }

        HMENU Detach()
        {
                HMENU hMenu = m_hMenu;
                m_hMenu = NULL;
                return hMenu;
        }

        operator HMENU() const { return m_hMenu; }

        bool IsNull() const { return (m_hMenu == NULL); }

        BOOL IsMenu() const
        {
                return ::IsMenu(m_hMenu);
        }

// Create/destroy methods
        BOOL CreateMenu()
        {
                m_hMenu = ::CreateMenu();
                return (m_hMenu != NULL) ? TRUE : FALSE;
        }

        BOOL CreatePopupMenu()
        {
                m_hMenu = ::CreatePopupMenu();
                return (m_hMenu != NULL) ? TRUE : FALSE;
        }

#ifndef _WIN32_WCE
        BOOL LoadMenuIndirect(const void* lpMenuTemplate)
        {
                m_hMenu = ::LoadMenuIndirect(lpMenuTemplate);
                return (m_hMenu != NULL) ? TRUE : FALSE;
        }
#endif // !_WIN32_WCE

        BOOL DestroyMenu()
        {
                if (m_hMenu == NULL)
                        return FALSE;
                BOOL bRet = ::DestroyMenu(m_hMenu);
                if(bRet)
                        m_hMenu = NULL;
                return bRet;
        }

// Menu Operations
        BOOL DeleteMenu(UINT nPosition, UINT nFlags)
        {
                return ::DeleteMenu(m_hMenu, nPosition, nFlags);
        }

        UINT CheckMenuItem(UINT nIDCheckItem, UINT nCheck)
        {
                return (UINT)::CheckMenuItem(m_hMenu, nIDCheckItem, nCheck);
        }

        UINT EnableMenuItem(UINT nIDEnableItem, UINT nEnable)
        {
                return ::EnableMenuItem(m_hMenu, nIDEnableItem, nEnable);
        }
        
        CMenuHandle GetSubMenu(int index)
        {
    return CMenuHandle(::GetSubMenu(m_hMenu, index));
    }
    
    bool InsertItem(UINT uItem, bool fByPosition,  const MENUITEMINFO  & mii)
    {
    return ::InsertMenuItem(m_hMenu, uItem, fByPosition, &mii);
    }

    bool Append(UINT uFlags, UINT_PTR uIDNewItem, LPCTSTR lpNewItem)
    {
    return ::AppendMenu(m_hMenu, uFlags, uIDNewItem, lpNewItem);
    }

    bool Add(CMenuHandle handle, LPCTSTR lpNewItem)
    {
    return ::AppendMenu(m_hMenu, MF_STRING | MF_POPUP, (UINT_PTR)(HMENU) handle, lpNewItem);
    } 

    bool AddSeparator()
    {
    return ::AppendMenu(m_hMenu, MF_SEPARATOR,0,0);
    }     
    bool Add(int uIDNewItem, LPCTSTR lpNewItem)
    {
    return ::AppendMenu(m_hMenu, MF_STRING, uIDNewItem, lpNewItem);
    }
    
   
  };          
          
  }
}

#endif