PureBasic Forums - English

Code: Select all

;
; *****************************************************************************
;
;                       Set-GetImageTo-FromMenuItem.pbi
;               Release 1.1 - Zapman - Jan 2025 - Windows only
;
;                         Thanks to the forum members
;                          for testing and debugging.
;                            (idle is a real boss)
;
;  This file should be saved under the name "Set-GetImageTo-FromMenuItem.pbi".
;
;     This library offers functions to set of get images to/from menu items.
; Its goal is to overcome the limitations of the current PureBasic (6.12) functions:
; • It is not possible to change the icon of a menu item after assigning it.
;   You have to destroy the menu and rebuild it entirely to be able to change one
;   of its icons.
; • It is not possible to retrieve the ImageID of a menu icon. You have to memorize
;   it in a variable at the time you assign it to be able to retrieve it later.
; • It is not possible to assign an icon to an item of the main menu of a window,
;   if this item has subitems.
;
; Now, you can do all of that!
;
;
;           The last part of this file includes a demonstration code.
;
;                The functions of this library are duplicated
;                in the SetGadgetItemEx.pbi Zapman library.
;    So, if you include SetGadgetItemEx.pbi in your project, you don't need to
;                   (and should not) include also this one.
;
;
; *****************************************************************************
;-                     1. FIRST PART: SOME EXPLANATIONS
; _____________________________________________________________________________
;
;             A brief description of how PureBasic handles menus
;                and the hassle of trying to manipulate them:
; _____________________________________________________________________________
; • Windows has a native way to handle menu icons: To assign an icon, you have
;   to enter its ImageID in the 'hbmpItem' field of the 'MenuItemInfo' Structure,
;   then call the 'SetMenuItemInfo()' function.
; • But, for some reason, the PureBasic Team chose not to use this option.
;   When you look at the MenuItemInfo Structure in the PureBasic 6.12 Structure
;    viewer, you can see that the 'hbmpItem' field is not even there.
;   There may be a historical reason for this: this field may not have existed
;   when the team registered this structure... and at the time when it was decided
;   to add icons to the menus.
; • The PureBasic way to do this is to store the ImageID of the menu icon in
;   a proprietary Structure, then store the address of that Structure in the
;   'dwItemData' field of 'MenuItemInfo'.
; • This creates a first difficulty: when we want to find or modify the ImageID,
;   we must manage a proprietary structure on which we have no information.
; • There is a second difficulty: since PureBasic has created this proprietary
;   structure, it also stores the text of the menu item in it.
; • But this structure is only created and used when a menu has icons.
;   Otherwise, the classic Windows method is used to store the menu text.
; • Therefore, the way to find the text of an item is not the same depending on
;   whether the menu was created with 'CreateMenu()' or 'CreateImageMenu()'.
; • It's exactly the same for 'CreatePopupMenu()' and CreatePopupImageMenu()'.
; • It seems that the PureBasic team's choice had other consequences since it is
;   impossible to assign an icon to a menu item when this item is an entry for a
;   submenu. For the main menu of a window, it is therefore impossible to assign
;   an icon to its titles, from the moment these titles are provided with subitems.
; • I also noticed a very strange (and very, very peculiar) bug: when you assign
;   the 'OwnerDrawn' style to a menu created with CreateMenu() and try to access
;   the text of one of its items using the GetGadgetItemText() function,
;   it doesn't always work. It doesn't work,in particular, when you are handling
;   the #WM_INITMENU And #WM_INITMENUPOPUP messages of the main window and call
;   GetGadgetItemText() after having set the style to OwnerDrawn.
; _____________________________________________________________________________
;
;          The path chosen to overcome the difficulties encountered
; _____________________________________________________________________________
;
; The approach taken by the functions in this library is to transparently deal with
; both methods of saving information for menu items (Windows and PureBasic)
; depending on the needs and how the menu was created (with CreateMenu/CreatePopupMenu,
; or CreateImageMenu/CreatePopupMenu).
; • When the menu was created with CreateMenu() or CreatePopupMenu(), the icons
;   of the menu items are saved in the Windows way. Because, yes!, you can add icons
;   to a menu that was NOT created with CreateImageMenu().
; • For the main menu of a window (which never has icons when created in PureBasic
;   and has subitems), the Windows data saving method is also used.
; • In all other cases, the PureBasic method is retained. In order to modify the data
;   of the proprietary structure used, I had to observe what it contained in various
;   cases, in order to be able to recreate it and to manipulate it.
;   Fortunately, this structure is very simple.
;
; _____________________________________________________________________________
;
;                      The limitations of this library
; _____________________________________________________________________________
;
; So far, I have identified two small limitations:
; 1- If you create your menu with CreateMenu() or CreatePopupMenu() and assign images
;    to items with the MenuItem(x, "ItemText", ImageID(x)) function, it still won't do
;    anything. It seems that the image ID passed in this case is lost for good.
;    To assign an image with MenuItem(), the menu must have been created with
;    CreateImageMenu(). However, you can still assign ImageIDs with SetMenuItemImageEx(),
;    regardless of how the menu was created.
; 2- If you assign images to items in a menu that was created with CreateMenu()
;    or CreatePopupMenu() using the SetMenuItemMenuEx() function, everything will be fine
;    until you use the SetMenuItemText() function. If you use it, the image previously
;    assigned to the item will be deleted. Therefore, if you want to change the text of
;    an item to which you have already assigned an image, you will have to use
;    SetMenuItemTextEx() instead.
;
; *****************************************************************************
;
;-                 2. SECOND PART: STRUCTURES AND CONSTANTES
;
CompilerIf #PB_Compiler_IsMainFile
  EnableExplicit
CompilerEndIf
;
Structure PBMenuItemData
  ; This structure is intended to correspond to how PureBasic
  ; stores the data of menu items when the menu was created
  ; with the CreateImageMenu() or CreatePopupImageMenu() commands.
  ;
  ; The data in this structure can be accessed through the field
  ; *drawItem\itemData when the #WM_DRAWITEM message is sent
  ; to the main window of the program.
  ;
  ; It can also be accessed with the GetMenuItemInfo_() Windows
  ; API function. See GetMenuItemInfos() as example.
  ;
  ; Due to a lack of documentation on this internal structure
  ; of PureBasic's functionality, the fields have been filled
  ; based on assumptions and observations.
  ;
  *MenuItemTextPntr ; This field contains a pointer
                    ; to the text of the menu item.
  *MenuItemImage    ; This field contains a pointer to the image
                    ; illustrating the menu item.
  Reserved1.i       ; The two following fields 
  Reserved2.i       ;    always contain zero.
  Unknown.i         ; The rest is unknown, even the exact number
                    ;    of fields of the structure.
                    ; But we get enough here for our needs
EndStructure
;
Structure MENUITEMINFO_Fixed Align #PB_Structure_AlignC
  ; The MENUITEMINFO structure described in PureBasic 6.12
  ; is uncomplete.
  ; Great thanks to idle from english PureBasic forum,
  ; for the right form of this structure.
  cbSize.l
  fMask.l
  fType.l
  fState.l
  wID.l
  hSubMenu.i
  hbmpChecked.i
  hbmpUnchecked.i
  dwItemData.i
  *dwTypeData
  cch.l
  hbmpItem.i ; This field is missing in the PureBasic 6.20 description of MENUITEMINFO.
EndStructure

;
; *****************************************************************************
;
;-                     3. THIRD PART: THE LIBRARY ITSELF
;
CompilerIf Not (Defined(GetAnImageForFree, #PB_Procedure))
  Procedure GetAnImageForFree(Start = 1, NbAttempt = 1000, MinSize = 16, PBImage = -1)
    ; By Zapman - Jan 2025.
    ;
    ; Explore the memory an return the first found image from 'Start' address.
    ;
    ; 'NbAttempt' is the limit number of attempts before stopping the exploration.
    ;
    ; 'MinSize' contains the minimum size for the searched image.
    ;
    ; If PBImage contains a valid image created with 'CreateImage()',
    ; the found image will be copied to PBImage.
    ; If PBImage = -1, the memory will only be checked for an existing image
    ; and nothing will be copied nowhere.
    ;
    ; If existing, PBImage can be 24 bits or 32 bits.
    ;
    Protected Result = 0, bitmap.BITMAP, hDestBitmap
    Protected ct, w, h, ImgWidth, ImgHeight, IsAlpha
    Protected x, y, PixelColor, NotEmpty
    Protected EndOfExploration = Start + NbAttempt
    Protected oldDestBitmap, oldSrcBitmap
    Protected blend, *blend.BLENDFUNCTION = @blend
    Protected hdcDest, hdcSrc = CreateCompatibleDC_(#Null) ; Create a memory hDC.
    ;
    If OpenLibrary(0, "Msimg32.dll")
      If hdcSrc
        If IsImage(PBImage) ; Check if the destination given image is valid.
          hDestBitmap = ImageID(PBImage) ; Get the  destination image handle.
          If GetObject_(hDestBitmap, SizeOf(BITMAP), @bitmap) ; get the destination image size.
            ImgWidth = bitmap\bmWidth
            ImgHeight = bitmap\bmHeight
            IsAlpha = bitmap\bmBitsPixel
            If ImgWidth * ImgHeight ; Check if the destination image has not a null size.
              If StartDrawing(ImageOutput(PBImage))
                ; Erase the given image background:
                If isAlpha = 32
                  ; Transparent background
                  DrawingMode(#PB_2DDrawing_AllChannels)
                  Box(0, 0, ImgWidth, ImgHeight, 0)
                Else
                  ; White background
                  Box(0, 0, ImgWidth, ImgHeight, $FFFFFF)
                EndIf
                StopDrawing()
              Else
                Goto GAIFF_CleanAndReturn
              EndIf
              ;
              hdcDest = CreateCompatibleDC_(#Null)    ; Create a memory hDC for the destination image
              oldDestBitmap = SelectObject_(hdcDest, hDestBitmap) ; Associate the destination image with hdcDest.
            Else
              Goto GAIFF_CleanAndReturn
            EndIf
            If oldDestBitmap = 0
              Goto GAIFF_CleanAndReturn
            EndIf
          Else
            Goto GAIFF_CleanAndReturn
          EndIf
        ElseIf PBImage <> -1
          Goto GAIFF_CleanAndReturn
        EndIf
        ;
        For ct = Start To EndOfExploration
          If GetObject_(ct, SizeOf(BITMAP), @bitmap) ; Check is there is an image at this address.
            w = bitmap\bmWidth                       ; If any, get the found image size.
            h = bitmap\bmHeight
            If w >= MinSize And h >= MinSize           ; Ensure that the found image has good dimensions.
              oldSrcBitmap = SelectObject_(hdcSrc, ct) ; Associate the found image with hdcSrc
              If oldSrcBitmap
                Result = ct
                If hDestBitmap
                  ; Copy the found image into PBImage:
                  *blend\BlendOp = #AC_SRC_OVER
                  *blend\BlendFlags = 0
                  *blend\AlphaFormat = #AC_SRC_ALPHA
                  *blend\SourceConstantAlpha = 255
                  CallFunction(0, "AlphaBlend", hdcDest, 0, 0, ImgWidth, ImgHeight, hdcSrc, 0, 0, w, h, blend)
                  ;
                  ; Now, check if the resulting image is empty:
                  ;
                  NotEmpty = #False
                  If StartDrawing(ImageOutput(PBImage))
                    If IsAlpha = 32
                      DrawingMode(#PB_2DDrawing_AllChannels)
                    EndIf
                    ; Check each pixel to see if all are equal to a solid color (e.g., white).
                    For y = 0 To ImgHeight - 1
                      For x = 0 To ImgWidth - 1
                        PixelColor = Point(x, y)
                        If IsAlpha = 24
                          ; Check if the pixel is white:
                          If PixelColor <> RGB(255, 255, 255) ; If a different pixel is found...
                            NotEmpty = #True
                            Break
                          EndIf
                        ElseIf IsAlpha = 32 And Alpha(PixelColor); Check if the pixel is transparent.
                          NotEmpty = #True
                          Break
                        EndIf
                      Next x
                    Next y
                    StopDrawing()
                  Else
                    Result = 0
                  EndIf
                  ;
                  If NotEmpty = #False
                    Result = 0
                  EndIf
                EndIf
                If Result : Break : EndIf
              EndIf
            EndIf
          EndIf
        Next
        ;
        GAIFF_CleanAndReturn: 
        If oldDestBitmap
          SelectObject_(hdcDest, oldDestBitmap)
        EndIf
        If hdcDest : DeleteDC_(hdcDest) : EndIf
        If oldSrcBitmap
          SelectObject_(hdcSrc, oldSrcBitmap)
        EndIf
        If hdcSrc : DeleteDC_(hdcSrc) : EndIf
      EndIf
      CloseLibrary(0)
    EndIf
    ProcedureReturn Result
  EndProcedure
CompilerEndIf  
;
#GMI_StringSearch$ = "GetMenuItemTextExString"
#GMI_SearchFirstImage$ = "GetFirstImageFromMenuItemString"
#GMI_Ignore = -1
;
Procedure.s GetClassicMenuStringFromPosition(hMenu, Position)
  ;
  Protected MenuItemInfo.MENUITEMINFO_Fixed, ItemString$
  ;
  ; Get the size of the string (the number of chars):
  MenuItemInfo\cbSize     = SizeOf(MENUITEMINFO_Fixed)
  MenuItemInfo\fMask      = #MIIM_STRING
  MenuItemInfo\dwTypeData = 0
  GetMenuItemInfo_(hMenu, Position, #MF_BYPOSITION, @MenuItemInfo)
  ;
  If MenuItemInfo\cch
    ; Allocate memory for a unicode string:
    ItemString$ = Space(MenuItemInfo\cch)
    MenuItemInfo\cch + 1 ; Add room for the ending character.
    ; Put the item string buffer address in MenuItemInfo\dwTypeData:
    MenuItemInfo\dwTypeData = @ItemString$
    ; Retreive the string:
    GetMenuItemInfo_(hMenu, Position, #MF_BYPOSITION, @MenuItemInfo)
  EndIf
  ProcedureReturn ItemString$
EndProcedure
;
Procedure GetMenuItemInfos(hMenu, ItemNum = #GMI_Ignore, ByPositionOrCommand = #MF_BYCOMMAND, *StringPointer = #GMI_Ignore)
  ;
  ; Explore hMenu items to find an image and/or a text.
  ; If an image is found, the ImageID (handle) of the image
  ; is returned.
  ; If *StringPointer is a valid pointer to a string, the corresponding
  ; item text is copied into *StringPointer.
  ;
  ; If ItemNum = #GMI_Ignore, the ImageID (handle) of the first found image
  ; is returned (if there is at least one image in the menu items).
  ;
  ; If ItemNum <> #GMI_Ignore, the ImageID of the image of the item designed
  ; by ItemNum is returned.
  ;
  ; If ByPositionOrCommand = #MF_BYPOSITION, ItemNum must contain the position
  ; of the item in the menu. Else, it must contain the item ID.
  ;
  ; If ByPositionOrCommand = #MF_BYCOMMAND, all the submenus of hMenu
  ; will be explored to find 'ItemNum'. Else, only the items of hMenu
  ; will be examined to find the required position.
  ;
  ; If *StringPointer is a valid pointer to a string, the text
  ; of the found item is returned into this string, whatever the
  ; way the menu was created (CreateImageMenu() or CreateMenu()
  ; or CreatePopupMenu() or CreatePopupImageMenu()).
  ;
  ; If ItemNum = #GMI_Ignore and *StringPointer points to a string
  ; equal to #GMI_StringSearch$, the first found item text
  ; is returned in *StringPointer, even if this item has no image.
  ; If ItemNum = #GMI_Ignore and *StringPointer is a valid pointer
  ; but does not point to a string equal to #GMI_StringSearch$,
  ; the item text of the first item with an image is returned 
  ; in *StringPointer. If not any item has an image, the first
  ; found item text is returned in *StringPointer.
  ; If ItemNum <> #GMI_Ignore and *StringPointer is a valid string
  ; pointer, the item text corresponding to ItemNum and
  ; ByPositionOrCommand will be copied in *StringPointer even if
  ; the item has no image. If it has an image, the imageID will
  ; be returned. Else, zero will be returned.
  ;
  Protected Counter, MenuItemInfo.MENUITEMINFO_Fixed, Result = #False
  Protected *PBMenuItemData.PBMenuItemData, bitmap.bitmap
  Protected Cont, SearchFirstImage = 0
  If *StringPointer And *StringPointer <> #GMI_Ignore And PeekS(*StringPointer) = #GMI_SearchFirstImage$
    SearchFirstImage = 1
  EndIf
  ;
  If IsMenu(hMenu)
    hMenu = MenuID(hMenu)
  EndIf
  ;
  For Counter = 0 To GetMenuItemCount_(hMenu) - 1
    Cont = 0
    If ItemNum = #GMI_Ignore
      Cont = 1
    Else
      If ByPositionOrCommand = #MF_BYPOSITION And Counter = ItemNum
        Cont = 1
      ElseIf ByPositionOrCommand = #MF_BYCOMMAND And GetMenuItemID_(hMenu, Counter) = ItemNum
        Cont = 1
      EndIf
    EndIf
    If Cont
      MenuItemInfo\cbSize     = SizeOf(MENUITEMINFO_Fixed)
      MenuItemInfo\fMask      = #MIIM_DATA
      GetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
      If MenuItemInfo\dwItemData
        ; PureBasic as registered data in MenuItemInfo\dwItemData.
        ; The precise structure of this data is private to PureBasic
        ; and is not documented. But observation permitted to know
        ; that the first field of this structure contains a pointer
        ; to the item string and the second one contains a pointer
        ; to the item image.
        *PBMenuItemData = MenuItemInfo\dwItemData
        Result = *PBMenuItemData\MenuItemImage
        ;
        If *PBMenuItemData\MenuItemTextPntr And *StringPointer And *StringPointer <> #GMI_Ignore
          If PeekS(*StringPointer) = #GMI_StringSearch$
            ; A string is requested and we get one.
            Result = 1
          EndIf
          If SearchFirstImage = 0
            PokeS(*StringPointer, PeekS(*PBMenuItemData\MenuItemTextPntr))
          EndIf
        EndIf
        ;
      Else
        ; PureBasic did not register data in MenuItemInfo\dwItemData.
        ;
        ; Retreive the item image using the classical Windows way:
        MenuItemInfo\fMask      = #MIIM_BITMAP
        GetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
        Result = MenuItemInfo\hbmpItem
        ;
        ; Retreive the item text using the classical Windows way:
        Protected ItemString$ = GetClassicMenuStringFromPosition(hMenu, Counter)
        If ItemString$ And *StringPointer And *StringPointer <> #GMI_Ignore
          If PeekS(*StringPointer) = #GMI_StringSearch$ And Result = 0
            ; A string is requested and we get one.
            Result = 1
          EndIf
          If SearchFirstImage = 0
            PokeS(*StringPointer, PeekS(@ItemString$))
          EndIf
        EndIf
        ;
      EndIf
      If Result <> 1 And Result <> 0
        ; It seems that we get an image. Check if it is valid:
        If GetObject_(Result, SizeOf(BITMAP), @bitmap.bitmap)
          If SearchFirstImage
            If ByPositionOrCommand = #MF_BYCOMMAND
              PokeS(*StringPointer, Str(GetMenuItemID_(hMenu, Counter)))
            Else
              PokeS(*StringPointer, Str(Counter))
            EndIf
          EndIf
          ; We get an image. Stop searching.
          Break
        Else
          Result = 0
        EndIf
      ElseIf Result = 1
        ; We get a text. Stop searching.
        Break
      EndIf
    EndIf
    If ByPositionOrCommand = #MF_BYCOMMAND
      ; When ItemNum is an ID, look for
      ; a submenu having an item with this ID.
      Protected SubMenu = GetSubMenu_(hMenu, Counter)
      ; Another way of doing the same thing is the following:
;       MenuItemInfo\cbSize = SizeOf(MENUITEMINFO_Fixed)
;       MenuItemInfo\fMask     = #MIIM_SUBMENU
;       MenuItemInfo\fType     = 0
;       GetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
;       SubMenu = MenuItemInfo\hSubMenu
      ;
      If SubMenu
        ; The item is an entry of a submenu.
        ; Explore the submenu:
        Result = GetMenuItemInfos(SubMenu, ItemNum, ByPositionOrCommand, *StringPointer)
        If Result
          Break
        EndIf
      EndIf
    EndIf
  Next
  ;
  ProcedureReturn Result
  ;
EndProcedure
;
Procedure GetMenuItemImageEx(hMenu, ItemNum)
  ;
  ; This function could be called 'GetMenuItemImage()' but it is possible that
  ; the PureBasic team decides to create seach a function with that name.
  ; So, the name 'GetMenuItemImageEx()' has been choosen.
  ;
  ; It returns the ImageID of the item designed by ItemNum.
  ; ItemNum must contain the item ID.
  ;
  ; All the submenus of hMenu will be explored to find 'ItemNum'.
  ;
  ; When omitting the fourth parameter of GetMenuItemInfos(), image search is preferred.
  ProcedureReturn GetMenuItemInfos(hMenu, ItemNum, #MF_BYCOMMAND)
EndProcedure
;
Procedure GetMenuTitleImageEx(hMenu, ItemNum)
  ;
  ; This function could be called 'GetMenuTitleImage()' but it is possible that
  ; the PureBasic team decides to create seach a function with that name.
  ; So, the name 'GetMenuTitleImageEx()' has been choosen.
  ;
  ; It returns the ImageID of the item designed by ItemNum.
  ; ItemNum must contain the position of the item in the menu.
  ;
  ; When omitting the fourth parameter of GetMenuItemInfos(), image search is preferred.
  ProcedureReturn GetMenuItemInfos(hMenu, ItemNum, #MF_BYPOSITION)
EndProcedure
;
Procedure.s GetMenuItemTextEx(hMenu, ItemNum, ByPositionOrCommand = #MF_BYCOMMAND)
  ; This functions does exactly the same thing As GetMenuItemText()
  ;
  ; BUT : When the menu has been created using CreateMenu() or CreatePopupMenu()
  ; and then set to 'OwnerDrawn' by the program, the PureBasic GetMenuItemText()
  ; doesn't allways work (for an unknown reason).
  ; This function will work in any case.
  Protected *String = AllocateMemory(1000) ; Reserve space for menu item text of any length.
  PokeS(*String, #GMI_StringSearch$) ; Signal a preferred string search.
  GetMenuItemInfos(hMenu, ItemNum, ByPositionOrCommand, *String)
  Protected String$ = PeekS(*String)
  FreeMemory(*String)
  If String$ <> #GMI_StringSearch$
    ProcedureReturn String$
  EndIf
EndProcedure
;
Procedure.s GetMenuTitleTextEx(hMenu, ItemNum)
  ;
  ; This functions does exactly the same thing As GetMenuTitleText()
  ;
  ProcedureReturn GetMenuItemTextEx(hMenu, ItemNum, #MF_BYPOSITION)
EndProcedure
;
Procedure GetFirstMenuItemImage(hMenu, ByPositionOrCommand = #MF_BYCOMMAND)
  ;
  ; Returns the first menu item number that has an image.
  ; If ByPositionOrCommand = #MF_BYCOMMAND, the value returned
  ;    is the ID of the menu item, and submenus will eventually
  ;    be explored to find the image.
  ; Else, the item position will be returned and submenus
  ;    won't be explored.
  Protected String$ = #GMI_SearchFirstImage$
  GetMenuItemInfos(hMenu, #GMI_Ignore, ByPositionOrCommand, @String$)
  If String$ = #GMI_SearchFirstImage$
    ProcedureReturn -1
  Else
    ProcedureReturn Val(String$)
  EndIf
EndProcedure
;
Procedure SetMenuItemInfos(hMenu, ItemNum, *ImageID = #GMI_Ignore, ItemString$ = "", ByPositionOrCommand = #MF_BYCOMMAND)
  ;
  ; If ByPositionOrCommand = #MF_BYPOSITION, ItemNum must contain the position
  ; of the item in the menu. Else, it must contain the item ID.
  ;
  ; If ByPositionOrCommand = #MF_BYCOMMAND, all the submenus of hMenu
  ; will be explored to find 'ItemNum'. Else, only the items of hMenu
  ; will be examined to find the required position of the item in the menu.
  ;
  ; *ImageID can contain the ImageID you want to attribute to the menu item.
  ; ItemString$ can contain the string you want to attribute to the menu item.
  ;
  Protected Counter, MenuItemInfo.MENUITEMINFO_Fixed, Result = #False
  Protected *PBMenuItemData.PBMenuItemData, Cont, hWindow, itemID
  ;
  ; Store ItemString$ in a static list to ensure that the strings
  ; pointers used by the menu will allways point to a valid memory
  ; address.
  Static NewList ListOfString.String()
  Protected Found = 0
  If ItemString$
    ForEach ListOfString()
      If ListOfString()\s = ItemString$
        Found = 1
        Break
      EndIf
    Next
    If Found = 0
      AddElement(ListOfString())
      ListOfString()\s = ItemString$
    EndIf
  EndIf
  ;
  If IsMenu(hMenu)
    hMenu = MenuID(hMenu)
  EndIf
  ;
  If IsImage(*ImageID)
    *ImageID = ImageID(*ImageID)
  EndIf
  ;
  For Counter = 0 To GetMenuItemCount_(hMenu) - 1
    Cont = 0
    If ByPositionOrCommand = #MF_BYPOSITION And Counter = ItemNum
      Cont = 1
    ElseIf ByPositionOrCommand = #MF_BYCOMMAND And GetMenuItemID_(hMenu, Counter) = ItemNum
      Cont = 1
    EndIf
    If Cont
      MenuItemInfo\cbSize     = SizeOf(MENUITEMINFO_Fixed)
      MenuItemInfo\fMask      = #MIIM_DATA
      GetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
      ;
      If MenuItemInfo\dwItemData = 0
        ; PureBasic has not created a *PBMenuItemData for this menu,
        ; probably because this menu has been created using CreateMenu()
        ; or CreatePopupMenu(), OR because this is the main window menu
        ; (PureBasic does'nt allow to add an image to the items of the
        ;  main menu when they have subitems).
        ;
        If ItemString$
          ; To set the text, use the classical way of doing the thing
          ; using Windows API.
          ; The content of ItemString$ has been saved in a static list
          ; to ensure that the given address always points to a valid
          ; string, whatever the user does whith the original string.
          MenuItemInfo\cbSize     = SizeOf(MENUITEMINFO_Fixed)
          MenuItemInfo\fMask      = #MIIM_STRING
          MenuItemInfo\dwTypeData = @ListOfString()\s
          SetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
          ;
          ; Now, redraw the menu to update it, if it is the window main menu:
          If IsWindow(EventWindow())
            hWindow = WindowID(EventWindow())
            If hMenu = GetMenu_(hWindow)
              DrawMenuBar_(hWindow)
            EndIf
          EndIf
          Result = 1
        EndIf
        ;
        If *ImageID <> #GMI_Ignore
          ; To set the image, use the classical way of doing the thing
          ; using Windows API.
          ; The ImageID is copied into the hbmpItem field of MenuItemInfo.
          ; Doing that, we can print a menu image EVEN IF the menu was created
          ; using CreateMenu() or CreatePopupMenu(). This also allows to print
          ; an image in a main menu title (even if it has subitems),
          ; while there is no way to do that using native PureBasic functions.
          ;
          MenuItemInfo\fMask      = #MIIM_BITMAP
          MenuItemInfo\hbmpItem   = *ImageID
          SetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
          ;
          ; Now, redraw the menu to update it, if it is the window main menu:
          If IsWindow(EventWindow())
            hWindow = WindowID(EventWindow())
            If hMenu = GetMenu_(hWindow)
              DrawMenuBar_(hWindow)
            EndIf
          EndIf
          Result = 1
        EndIf
      Else
        ; PureBasic has created a *PBMenuItemData for this menu.
        ; This means that this menu was created using CreateImageMenu()
        ; or CreatePopupImageMenu().
        *PBMenuItemData = MenuItemInfo\dwItemData
        If *ImageID <> #GMI_Ignore
          *PBMenuItemData\MenuItemImage = *ImageID
          Result = 1
        EndIf
        If ItemString$
          ; The content of ItemString$ has been saved in a static list
          ; to ensure that the given address always points to a valid
          ; string, whatever the user does whith the original string.
          *PBMenuItemData\MenuItemTextPntr = @ListOfString()\s
          Result = 1
        EndIf
      EndIf
      Break
    EndIf
    If ByPositionOrCommand = #MF_BYCOMMAND
      ; When ItemNum is an ID, look for
      ; a submenu having an item with this ID.
      Protected SubMenu = GetSubMenu_(hMenu, Counter)
      ; Another way of doing the same thing is the following:
;       MenuItemInfo\cbSize = SizeOf(MENUITEMINFO_Fixed)
;       MenuItemInfo\fMask     = #MIIM_SUBMENU
;       MenuItemInfo\fType     = 0
;       GetMenuItemInfo_(hMenu, Counter, #MF_BYPOSITION, @MenuItemInfo)
;       SubMenu = MenuItemInfo\hSubMenu
      If SubMenu
        ; The item is an entry of a submenu.
        ; Explore the submenu:
        Result = SetMenuItemInfos(SubMenu, ItemNum, *ImageID, ItemString$, ByPositionOrCommand)
        If Result
          Break
        EndIf
      EndIf
    EndIf
  Next
  ProcedureReturn Result
  ;
EndProcedure
;
Procedure SetMenuItemImageEx(hMenu, ItemNum, *ImageID, ByPositionOrCommand = #MF_BYCOMMAND)
  ;
  ; This function could be called 'SetMenuItemImage()' but it is possible that
  ; the PureBasic team decides to create seach a function with that name.
  ; So, the name 'SetMenuItemImageEx()' has been choosen.
  ProcedureReturn SetMenuItemInfos(hMenu, ItemNum, *ImageID, "", ByPositionOrCommand)
EndProcedure
;
Procedure SetMenuTitleImageEx(hMenu, ItemNum, *ImageID)
  ;
  ; This function could be called 'SetMenuTitleImage()' but it is possible that
  ; the PureBasic team decides to create seach a function with that name.
  ; So, the name 'SetMenuTitleImageEx()' has been choosen.
  ProcedureReturn SetMenuItemInfos(hMenu, ItemNum, *ImageID, "", #MF_BYPOSITION)
EndProcedure
;
Procedure SetMenuItemTextEx(hMenu, ItemNum, Text$, ByPositionOrCommand = #MF_BYCOMMAND)
  ;
  ; This function does the same as SetMenuItemText()
  ;
  ; The difference is that when a menu has not been created using CreateImageMenu()
  ; or CreatePopupImageMenu(), and you call the standard PureBasic functions
  ; SetMenuItemText(), PureBasic will erase the image eventually associated With
  ; the corresponding item.
  ;
  ; So, by using SetMenuItemTextEx() instead of using SetMenuItemText()
  ; you preserve the images you've attributed to the items using SetMenuItemImageEx(),
  ; even if the menu has been created by using CreateMenu() or CreatePopupMenu().
  ;
  ProcedureReturn SetMenuItemInfos(hMenu, ItemNum, #GMI_Ignore, Text$, ByPositionOrCommand)
EndProcedure
;
Procedure SetMenuTitleTextEx(hMenu, ItemNum, Text$)
  ;
  ; This function does the same as SetMenuTitleText()
  ;
  ; The difference is that when a menu has not been created using CreateImageMenu()
  ; or CreatePopupImageMenu(), and you call the standard PureBasic functions
  ; SetMenuTitleText(), PureBasic will erase the image eventually associated With
  ; the corresponding item.
  ;
  ; So, by using SetMenuTitleTextEx() instead of using SetMenuTitleText(),
  ; you preserve the images you've attributed to the items using SetMenuItemImageEx(),
  ; specially if you attributed an image to the main window menu main items.
  ;
  ProcedureReturn SetMenuItemInfos(hMenu, ItemNum, #GMI_Ignore, Text$, #MF_BYPOSITION)
EndProcedure
;
;
; *****************************************************************************
;
;-                      4. FORTH PART: A DEMONSTRATION
;
;
CompilerIf #PB_Compiler_IsMainFile
  ;
  ; The following won't run when this file is used as 'Included'.
  ;
  Procedure.s RefreshMsg(MainMenu)
    ;
    Protected ItemPosition, ItemID, ImageID
    Protected Msg$ = ""
    ;
    ItemPosition = GetFirstMenuItemImage(MainMenu, #MF_BYPOSITION)
    If ItemPosition <> -1
      Msg$ + "First found image for menu:" + #CR$
      Msg$ + "   Position = " + Str(ItemPosition) + "  -  ImageID = " + GetMenuTitleImageEx(MainMenu, ItemPosition) + #CR$
      Msg$ + "   Corresponding text is: "  + GetMenuTitleTextEx(MainMenu, ItemPosition) + #CR$
      Msg$ + #CR$
    Else
      ItemID = GetFirstMenuItemImage(MainMenu, #MF_BYCOMMAND)
      If ItemID <> -1
        Msg$ + "First found image for menu:" + #CR$
        Msg$ + "   ItemID   = " + Str(ItemID) + "  -  ImageID = " + GetMenuItemImageEx(MainMenu, ItemID) + #CR$
        Msg$ + "   Corresponding text is: "  + GetMenuItemTextEx(MainMenu, ItemID) + #CR$
        Msg$ + #CR$
      Else
        Msg$ + "There is no image in the menu." + #CR$
        Msg$ + #CR$
      EndIf
    EndIf
    
    ItemID = 3
    ImageID = GetMenuItemImageEx(MainMenu, ItemID)
    If ImageID
      Msg$ + "There is an image for ItemID " + Str(ItemID) + ": " + Str(ImageID) + #CR$
      Msg$ + "   Corresponding text is: "  + GetMenuItemTextEx(MainMenu, ItemID) + #CR$
    Else
      Msg$ + "There is no image for ItemID " + Str(ItemID) + "." + #CR$
      Msg$ + "   Corresponding text is: "  + GetMenuItemTextEx(MainMenu, ItemID) + #CR$
    EndIf
    Msg$ + #CR$
    Msg$ + "Looking by ID, the text having the ID 1 is: "  + GetMenuItemTextEx(MainMenu, 1, #MF_BYCOMMAND) + #CR$
    Msg$ + "Looking by position, the text at position 1 is: "  + GetMenuItemTextEx(MainMenu, 1, #MF_BYPOSITION) + #CR$
    Msg$ + "   because each time you call 'MenuTitle()', PureBasic open a submenu" + #CR$
    Msg$ + "   to register the items of the main menu title. By the way, 'MenuTitle()'" + #CR$
    Msg$ + "   does exactly the same thing as 'OpenSubmenu()', except that it first." + #CR$
    Msg$ + "   call CloseSubMenu() if a precedent submenu (or MenuTitle) has been" + #CR$
    Msg$ + "   opened." + #CR$
    Msg$ + "   So, the main menu has only two positions: 'File' at 0, and  'Edit' at 1." + #CR$
    ;
    Msg$ + #CR$
    Msg$ + #CR$
    Msg$ + "Open the 'File' menu and look at its content." + #CR$
    Msg$ + "Then click on the button below and look again" + #CR$
    Msg$ + "at the 'File' menu content." + #CR$
    ;
    ProcedureReturn Msg$
  EndProcedure
  ;
  ; Create a menu for démonstration
  If OpenWindow(0, 0, 0, 400, 420, "GetMenuInfo Example", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
    CreateImage(1, 24, 24, 32)
    CreateImage(2, 24, 24, 32)
    CreateImage(3, 24, 24, 32)
    Define LastImage = GetAnImageForFree(171, 100, 24, 1)
    LastImage = GetAnImageForFree(LastImage + 4, 100, 24, 2)
    LastImage = GetAnImageForFree(LastImage + 4, 100, 24, 3)
    ;
    Define MainMenu = CreateImageMenu(#PB_Any, WindowID(0))
    
    MenuTitle("File")
    MenuItem(1, "Open")
    MenuItem(2, "Save", ImageID(1))
    MenuBar()
    MenuItem(3, "Exit")
    ;
    MenuTitle("Edit")
    MenuItem(4, "Cut")
    ;
    Define TextGadget = TextGadget(#PB_Any, 10, 10, WindowWidth(0) - 20, 330, RefreshMsg(MainMenu))
    ;
    Define ButtonWidth = 290
    Define ButtonHeight = 25
    Define ButtonX = (WindowWidth(0) - ButtonWidth) / 2
    Define ButtonY = WindowHeight(0) - ButtonHeight - 30
    Define ChangeMenuButton = ButtonGadget(#PB_Any, ButtonX, ButtonY, ButtonWidth, ButtonHeight, "Add an image to Open and change 'Open' to 'Test'")
    ;  
    ;
    Define Event
    Repeat
      Event = WaitWindowEvent()
      If Event And EventGadget() = ChangeMenuButton
        SetMenuItemImageEx(MainMenu, 1, ImageID(2))
        ;
        ; Add an image to a main menu title:
        SetMenuItemImageEx(MainMenu, 0, ImageID(3), #MF_BYPOSITION)
        SetMenuTitleTextEx(MainMenu, 0, "File2")
        ;
        ;
        SetMenuItemTextEx(MainMenu, 1, "Test")
        
        SetGadgetText(TextGadget, RefreshMsg(MainMenu))

      EndIf
    Until Event = #PB_Event_CloseWindow
    
    CloseWindow(0)
  EndIf
  ;
CompilerEndIf

Code: Select all

Result = *PBMenuItemData\MenuItemImage

Code: Select all

Structure MENUITEMINFO_Fixed
  cbSize.l
  fMask.l
  fType.l
  fState.l
  wID.l
  hSubMenu.l
  hbmpChecked.l
  hbmpUnchecked.l
  dwItemData.l
  *dwTypeData
  cch.l
  hbmpItem.i ; This field is missing in the PureBasic native description of MENUITEMINFO.
EndStructure

Code: Select all

Structure MENUITEMINFO_Fixed Align #PB_Structure_AlignC
  cbSize.l
  fMask.l
  fType.l
  fState.l
  wID.l
  hSubMenu.i
  hbmpChecked.i
  hbmpUnchecked.i
  dwItemData.i
  *dwTypeData
  cch.l
  hbmpItem.i ; This field is missing in the PureBasic native description of MENUITEMINFO.
EndStructure