WDL/swell/swell-menu-generic.cpp

   1 /* Cockos SWELL (Simple/Small Win32 Emulation Layer for Linux/OSX)
   2    Copyright (C) 2006 and later, Cockos, Inc.
   3
   4     This software is provided 'as-is', without any express or implied
   5     warranty.  In no event will the authors be held liable for any damages
   6     arising from the use of this software.
   7
   8     Permission is granted to anyone to use this software for any purpose,
   9     including commercial applications, and to alter it and redistribute it
  10     freely, subject to the following restrictions:
  11
  12     1. The origin of this software must not be misrepresented; you must not
  13        claim that you wrote the original software. If you use this software
  14        in a product, an acknowledgment in the product documentation would be
  15        appreciated but is not required.
  16     2. Altered source versions must be plainly marked as such, and must not be
  17        misrepresented as being the original software.
  18     3. This notice may not be removed or altered from any source distribution.
  19
  20
  21     This file provides basic windows menu API
  22
  23   */
  24
  25 #ifndef SWELL_PROVIDED_BY_APP
  26
  27 #include "swell.h"
  28 #include "swell-menugen.h"
  29
  30 #include "swell-internal.h"
  31
  32 #include "../ptrlist.h"
  33 #include "../wdlcstring.h"
  34
  35 HMENU__ *HMENU__::Duplicate()
  36 {
  37   HMENU__ *p = new HMENU__;
  38   int x;
  39   for (x = 0; x < items.GetSize(); x ++)
  40   {
  41     MENUITEMINFO *s = items.Get(x);
  42     MENUITEMINFO *inf = (MENUITEMINFO*)calloc(sizeof(MENUITEMINFO),1);
  43
  44     *inf = *s;
  45     if (inf->dwTypeData && inf->fType == MFT_STRING) inf->dwTypeData=strdup(inf->dwTypeData);
  46     if (inf->hSubMenu) inf->hSubMenu = inf->hSubMenu->Duplicate();
  47
  48     p->items.Add(inf);
  49   }
  50   return p;
  51 }
  52
  53 void HMENU__::freeMenuItem(void *p)
  54 {
  55   MENUITEMINFO *inf = (MENUITEMINFO *)p;
  56   if (!inf) return;
  57   if (inf->hSubMenu) inf->hSubMenu->Release();
  58   if (inf->fType == MFT_STRING) free(inf->dwTypeData);
  59   free(inf);
  60 }
  61
  62 static MENUITEMINFO *GetMenuItemByID(HMENU menu, int id, bool searchChildren=true)
  63 {
  64   if (!menu) return 0;
  65   int x;
  66   for (x = 0; x < menu->items.GetSize(); x ++)
  67     if (menu->items.Get(x)->wID == (UINT)id) return menu->items.Get(x);
  68
  69   if (searchChildren) for (x = 0; x < menu->items.GetSize(); x ++)
  70   {
  71     if (menu->items.Get(x)->hSubMenu)
  72     {
  73       MENUITEMINFO *ret = GetMenuItemByID(menu->items.Get(x)->hSubMenu,id,true);
  74       if (ret) return ret;
  75     }
  76   }
  77
  78   return 0;
  79 }
  80
  81 bool SetMenuItemText(HMENU hMenu, int idx, int flag, const char *text)
  82 {
  83   MENUITEMINFO *item = hMenu ? ((flag & MF_BYPOSITION) ? hMenu->items.Get(idx) : GetMenuItemByID(hMenu,idx)) : NULL;
  84   if (!item) return false;
  85
  86   if (item->fType == MFT_STRING) free(item->dwTypeData);
  87   item->fType = MFT_STRING;
  88   item->dwTypeData=strdup(text?text:"");
  89
  90   return true;
  91 }
  92
  93 bool EnableMenuItem(HMENU hMenu, int idx, int en)
  94 {
  95   MENUITEMINFO *item = hMenu ? ((en & MF_BYPOSITION) ? hMenu->items.Get(idx) : GetMenuItemByID(hMenu,idx)) : NULL;
  96   if (!item) return false;
  97
  98   int mask = MF_ENABLED|MF_DISABLED|MF_GRAYED;
  99   item->fState &= ~mask;
 100   item->fState |= en&mask;
 101
 102   return true;
 103 }
 104
 105 bool CheckMenuItem(HMENU hMenu, int idx, int chk)
 106 {
 107   MENUITEMINFO *item = hMenu ? ((chk & MF_BYPOSITION) ? hMenu->items.Get(idx) : GetMenuItemByID(hMenu,idx)) : NULL;
 108   if (!item) return false;
 109
 110   int mask = MF_CHECKED;
 111   item->fState &= ~mask;
 112   item->fState |= chk&mask;
 113
 114   return true;
 115 }
 116 HMENU SWELL_GetCurrentMenu()
 117 {
 118   return NULL; // not osx
 119 }
 120 void SWELL_SetCurrentMenu(HMENU hmenu)
 121 {
 122 }
 123
 124 HMENU GetSubMenu(HMENU hMenu, int pos)
 125 {
 126   MENUITEMINFO *item = hMenu ? hMenu->items.Get(pos) : NULL;
 127   if (item) return item->hSubMenu;
 128   return 0;
 129 }
 130
 131 int GetMenuItemCount(HMENU hMenu)
 132 {
 133   if (hMenu) return hMenu->items.GetSize();
 134   return 0;
 135 }
 136
 137 int GetMenuItemID(HMENU hMenu, int pos)
 138 {
 139   MENUITEMINFO *item = hMenu ? hMenu->items.Get(pos) : NULL;
 140   if (!item || item->hSubMenu) return -1;
 141   return item->wID;
 142 }
 143
 144 bool SetMenuItemModifier(HMENU hMenu, int idx, int flag, int code, unsigned int mask)
 145 {
 146   return false;
 147 }
 148
 149 HMENU CreatePopupMenu()
 150 {
 151   return new HMENU__;
 152 }
 153 HMENU CreatePopupMenuEx(const char *title)
 154 {
 155   return CreatePopupMenu();
 156 }
 157
 158 void DestroyMenu(HMENU hMenu)
 159 {
 160   if (hMenu) hMenu->Release();
 161 }
 162
 163 int AddMenuItem(HMENU hMenu, int pos, const char *name, int tagid)
 164 {
 165   if (!hMenu) return -1;
 166   MENUITEMINFO *inf = (MENUITEMINFO*)calloc(1,sizeof(MENUITEMINFO));
 167   inf->wID = tagid;
 168   inf->fType = MFT_STRING;
 169   inf->dwTypeData = strdup(name?name:"");
 170   hMenu->items.Insert(pos,inf);
 171   return 0;
 172 }
 173
 174 bool DeleteMenu(HMENU hMenu, int idx, int flag)
 175 {
 176   if (!hMenu) return false;
 177   if (flag&MF_BYPOSITION)
 178   {
 179     if (hMenu->items.Get(idx))
 180     {
 181       hMenu->items.Delete(idx,true,HMENU__::freeMenuItem);
 182       return true;
 183     }
 184     return false;
 185   }
 186   else
 187   {
 188     int x;
 189     int cnt=0;
 190     for (x=0;x<hMenu->items.GetSize(); x ++)
 191     {
 192       if (!hMenu->items.Get(x)->hSubMenu && hMenu->items.Get(x)->wID == (UINT)idx)
 193       {
 194         hMenu->items.Delete(x--,true,HMENU__::freeMenuItem);
 195         cnt++;
 196       }
 197     }
 198     if (!cnt)
 199     {
 200       for (x=0;x<hMenu->items.GetSize(); x ++)
 201       {
 202         if (hMenu->items.Get(x)->hSubMenu) cnt += DeleteMenu(hMenu->items.Get(x)->hSubMenu,idx,flag)?1:0;
 203       }
 204     }
 205     return !!cnt;
 206   }
 207 }
 208
 209
 210 BOOL SetMenuItemInfo(HMENU hMenu, int pos, BOOL byPos, MENUITEMINFO *mi)
 211 {
 212   if (!hMenu) return 0;
 213   MENUITEMINFO *item = byPos ? hMenu->items.Get(pos) : GetMenuItemByID(hMenu, pos, true);
 214   if (!item) return 0;
 215
 216   if ((mi->fMask & MIIM_SUBMENU) && mi->hSubMenu != item->hSubMenu)
 217   {
 218     if (item->hSubMenu) item->hSubMenu->Release();
 219     item->hSubMenu = mi->hSubMenu;
 220   }
 221   if (mi->fMask & MIIM_TYPE)
 222   {
 223     if (item->fType == MFT_STRING) free(item->dwTypeData);
 224     item->dwTypeData=0;
 225
 226     if (mi->fType == MFT_STRING && mi->dwTypeData) item->dwTypeData = strdup( mi->dwTypeData );
 227     else if (mi->fType == MFT_BITMAP) item->dwTypeData = mi->dwTypeData;
 228     item->fType = mi->fType;
 229   }
 230
 231   if (mi->fMask & MIIM_STATE) item->fState = mi->fState;
 232   if (mi->fMask & MIIM_ID) item->wID = mi->wID;
 233   if (mi->fMask & MIIM_DATA) item->dwItemData = mi->dwItemData;
 234
 235   return true;
 236 }
 237
 238 BOOL GetMenuItemInfo(HMENU hMenu, int pos, BOOL byPos, MENUITEMINFO *mi)
 239 {
 240   if (!hMenu) return 0;
 241   MENUITEMINFO *item = byPos ? hMenu->items.Get(pos) : GetMenuItemByID(hMenu, pos, true);
 242   if (!item) return 0;
 243
 244   if (mi->fMask & MIIM_TYPE)
 245   {
 246     mi->fType = item->fType;
 247     if (item->fType == MFT_STRING && mi->dwTypeData && mi->cch)
 248     {
 249       lstrcpyn_safe(mi->dwTypeData,item->dwTypeData?item->dwTypeData:"",mi->cch);
 250     }
 251     else if (item->fType == MFT_BITMAP) mi->dwTypeData = item->dwTypeData;
 252   }
 253
 254   if (mi->fMask & MIIM_DATA) mi->dwItemData = item->dwItemData;
 255   if (mi->fMask & MIIM_STATE) mi->fState = item->fState;
 256   if (mi->fMask & MIIM_ID) mi->wID = item->wID;
 257   if (mi->fMask & MIIM_SUBMENU) mi->hSubMenu = item->hSubMenu;
 258
 259   return 1;
 260
 261 }
 262
 263 void SWELL_InsertMenu(HMENU menu, int pos, unsigned int flag, UINT_PTR idx, const char *str)
 264 {
 265   MENUITEMINFO mi={sizeof(mi),MIIM_ID|MIIM_STATE|MIIM_TYPE,MFT_STRING,
 266     (flag & ~MF_BYPOSITION),(flag&MF_POPUP) ? 0 : (UINT)idx,NULL,NULL,NULL,0,(char *)str};
 267
 268   if (flag&MF_POPUP)
 269   {
 270     mi.hSubMenu = (HMENU)idx;
 271     mi.fMask |= MIIM_SUBMENU;
 272     mi.fState &= ~MF_POPUP;
 273   }
 274
 275   if (flag&MF_SEPARATOR)
 276   {
 277     mi.fMask=MIIM_TYPE;
 278     mi.fType=MFT_SEPARATOR;
 279     mi.fState &= ~MF_SEPARATOR;
 280   }
 281
 282   if (flag&MF_BITMAP)
 283   {
 284     mi.fType=MFT_BITMAP;
 285     mi.fState &= ~MF_BITMAP;
 286   }
 287
 288   InsertMenuItem(menu,pos,(flag&MF_BYPOSITION) ?  TRUE : FALSE, &mi);
 289 }
 290
 291 void InsertMenuItem(HMENU hMenu, int pos, BOOL byPos, MENUITEMINFO *mi)
 292 {
 293   if (!hMenu) return;
 294   int ni=hMenu->items.GetSize();
 295
 296   if (!byPos)
 297   {
 298     int x;
 299     for (x=0;x<ni && hMenu->items.Get(x)->wID != (UINT)pos; x++);
 300     pos = x;
 301   }
 302   if (pos < 0 || pos > ni) pos=ni;
 303
 304   MENUITEMINFO *inf = (MENUITEMINFO*)calloc(sizeof(MENUITEMINFO),1);
 305   inf->fType = mi->fType;
 306   if (mi->fType == MFT_STRING)
 307   {
 308     inf->dwTypeData = strdup(mi->dwTypeData?mi->dwTypeData:"");
 309   }
 310   else if (mi->fType == MFT_BITMAP)
 311   {
 312     inf->dwTypeData = mi->dwTypeData;
 313   }
 314   else if (mi->fType == MFT_SEPARATOR)
 315   {
 316   }
 317   if (mi->fMask&MIIM_SUBMENU) inf->hSubMenu = mi->hSubMenu;
 318   if (mi->fMask & MIIM_STATE) inf->fState = mi->fState;
 319   if (mi->fMask & MIIM_DATA) inf->dwItemData = mi->dwItemData;
 320   if (mi->fMask & MIIM_ID) inf->wID = mi->wID;
 321
 322   hMenu->items.Insert(pos,inf);
 323 }
 324
 325
 326 void SWELL_SetMenuDestination(HMENU menu, HWND hwnd)
 327 {
 328   // only needed for Cocoa
 329 }
 330
 331 extern RECT g_trackpopup_yroot;
 332 static POINT m_trackingPt, m_trackingPt2;
 333 static int m_trackingMouseFlag;
 334 static int m_trackingFlags,m_trackingRet;
 335 static HWND m_trackingPar;
 336 static WDL_PtrList<HWND__> m_trackingMenus; // each HWND as userdata = HMENU
 337
 338 int swell_delegate_menu_message(HWND src, LPARAM lParam, int msg, bool screencoords)
 339 {
 340   static bool _reent;
 341   if (_reent) return 0;
 342
 343   _reent = true;
 344
 345   POINT sp = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 346   if (!screencoords) ClientToScreen(src,&sp);
 347
 348   for (int x = m_trackingMenus.GetSize()-1; x>=0; x--)
 349   {
 350     HWND sw = m_trackingMenus.Get(x);
 351     if (!sw) continue;
 352
 353     if (sw == src) break; // stop searching (don't delegate to parent)
 354
 355     RECT r;
 356     GetWindowRect(sw,&r);
 357     if (PtInRect(&r,sp))
 358     {
 359       POINT p = sp;
 360       ScreenToClient(sw,&p);
 361       SendMessage(sw,msg,0,MAKELPARAM(p.x,p.y));
 362       _reent = false;
 363       return 1;
 364     }
 365   }
 366
 367   _reent = false;
 368   return 0;
 369 }
 370
 371 bool swell_isOSwindowmenu(SWELL_OSWINDOW osw)
 372 {
 373   int x = m_trackingMenus.GetSize();
 374   if (osw) while (--x>=0)
 375   {
 376     HWND__ *p = m_trackingMenus.Get(x);
 377     if (p->m_oswindow == osw) return true;
 378   }
 379   return false;
 380 }
 381
 382 int menuBarNavigate(int dir); // -1 if no menu bar active, 0 if did nothing, 1 if navigated
 383 HWND GetFocusIncludeMenus(void);
 384
 385 static LRESULT WINAPI submenuWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 386 {
 387   static int lcol, rcol, mcol, top_margin, separator_ht, text_ht_pad, bitmap_ht_pad, scroll_margin;
 388   if (!lcol)
 389   {
 390     lcol=SWELL_UI_SCALE(24); rcol=SWELL_UI_SCALE(12); mcol=SWELL_UI_SCALE(10);
 391     top_margin=SWELL_UI_SCALE(4); separator_ht=SWELL_UI_SCALE(8);
 392     text_ht_pad=SWELL_UI_SCALE(4); bitmap_ht_pad=SWELL_UI_SCALE(4);
 393     scroll_margin=SWELL_UI_SCALE(10);
 394   }
 395   switch (uMsg)
 396   {
 397     case WM_CREATE:
 398       hwnd->m_classname = "__SWELL_MENU";
 399       m_trackingMenus.Add(hwnd);
 400       SetWindowLongPtr(hwnd,GWLP_USERDATA,lParam);
 401
 402       if (m_trackingPar && !(m_trackingFlags&TPM_NONOTIFY))
 403         SendMessage(m_trackingPar,WM_INITMENUPOPUP,(WPARAM)lParam,0);
 404
 405       {
 406         HDC hdc = GetDC(hwnd);
 407         HMENU__ *menu = (HMENU__*)lParam;
 408         int ht = 0, wid=SWELL_UI_SCALE(100),wid2=0;
 409         int x;
 410         for (x=0; x < menu->items.GetSize(); x++)
 411         {
 412           MENUITEMINFO *inf = menu->items.Get(x);
 413           if (inf->fType == MFT_STRING)
 414           {
 415             RECT r={0,};
 416             const char *str = inf->dwTypeData;
 417             if (!str || !*str) str="XXXXX";
 418             const char *pt2 = strstr(str,"\t");
 419             DrawText(hdc,str,pt2 ? (int)(pt2-str) : -1,&r,DT_CALCRECT|DT_SINGLELINE);
 420             if (r.right > wid) wid=r.right;
 421             ht += r.bottom + text_ht_pad;
 422
 423             if (pt2)
 424             {
 425               r.right=r.left;
 426               DrawText(hdc,pt2+1,-1,&r,DT_CALCRECT|DT_SINGLELINE);
 427               if (r.right > wid2) wid2=r.right;
 428             }
 429           }
 430           else if (inf->fType == MFT_BITMAP)
 431           {
 432             BITMAP bm={16,16};
 433             if (inf->dwTypeData) GetObject((HBITMAP)inf->dwTypeData,sizeof(bm),&bm);
 434             if (bm.bmWidth > wid) wid = bm.bmWidth;
 435
 436             ht += bm.bmHeight + bitmap_ht_pad;
 437           }
 438           else
 439           {
 440             // treat as separator
 441             ht += separator_ht;
 442           }
 443         }
 444         wid+=lcol+rcol + (wid2?wid2+mcol:0);
 445         ReleaseDC(hwnd,hdc);
 446
 447         RECT tr={m_trackingPt.x,m_trackingPt.y,
 448                  m_trackingPt.x+wid+SWELL_UI_SCALE(4),m_trackingPt.y+ht+top_margin * 2}, vp;
 449         SWELL_GetViewPort(&vp,&tr,true);
 450         vp.bottom -= 8;
 451
 452         if (g_trackpopup_yroot.bottom > g_trackpopup_yroot.top &&
 453             g_trackpopup_yroot.bottom > vp.top &&
 454             g_trackpopup_yroot.top < vp.bottom)
 455         {
 456           if (vp.bottom - g_trackpopup_yroot.bottom < g_trackpopup_yroot.top - vp.top)
 457             vp.bottom = g_trackpopup_yroot.top;
 458           else
 459             vp.top = g_trackpopup_yroot.bottom;
 460         }
 461
 462         if (tr.bottom > vp.bottom) { tr.top += vp.bottom-tr.bottom; tr.bottom=vp.bottom; }
 463         if (tr.right > vp.right)
 464         {
 465           if ((vp.right - m_trackingPt2.x) <  (m_trackingPt2.x - vp.left))
 466           {
 467             tr.left = m_trackingPt2.x - (tr.right-tr.left);
 468             tr.right = m_trackingPt2.x;
 469           }
 470           else
 471           {
 472             tr.left += vp.right-tr.right; tr.right=vp.right;
 473           }
 474         }
 475
 476         if (tr.left < vp.left) { tr.right += vp.left-tr.left; tr.left=vp.left; }
 477         if (tr.top < vp.top) { tr.bottom += vp.top-tr.top; tr.top=vp.top; }
 478         if (tr.bottom > vp.bottom) tr.bottom=vp.bottom;
 479         if (tr.right > vp.right) tr.right=vp.right;
 480
 481         SetWindowPos(hwnd,NULL,tr.left,tr.top,tr.right-tr.left,tr.bottom-tr.top,SWP_NOZORDER);
 482
 483         hwnd->m_extra[0] = 0; // Y scroll offset
 484         hwnd->m_extra[1] = 0; // &1=allow scroll flag (set from paint), &2=force scroll down (if sel_vis is offscreen positive)
 485       }
 486
 487       SetWindowLong(hwnd,GWL_STYLE,GetWindowLong(hwnd,GWL_STYLE)&~WS_CAPTION);
 488       ShowWindow(hwnd,SW_SHOW);
 489       SetFocus(hwnd);
 490       SetTimer(hwnd,1,100,NULL);
 491       SetTimer(hwnd,2,15,NULL);
 492     break;
 493     case WM_PAINT:
 494       {
 495         PAINTSTRUCT ps;
 496         if (BeginPaint(hwnd,&ps))
 497         {
 498           RECT cr;
 499           GetClientRect(hwnd,&cr);
 500           HBRUSH br=CreateSolidBrush(g_swell_ctheme.menu_bg);
 501           HBRUSH br2 = CreateSolidBrushAlpha(g_swell_ctheme.menu_scroll,0.5f);
 502           HBRUSH br3 = CreateSolidBrush(g_swell_ctheme.menu_scroll_arrow);
 503           HBRUSH br_submenu_arrow = CreateSolidBrush(g_swell_ctheme.menu_submenu_arrow);
 504           HPEN pen=CreatePen(PS_SOLID,0,g_swell_ctheme.menu_shadow);
 505           HPEN pen2=CreatePen(PS_SOLID,0,g_swell_ctheme.menu_hilight);
 506           HGDIOBJ oldbr = SelectObject(ps.hdc,br);
 507           HGDIOBJ oldpen = SelectObject(ps.hdc,pen2);
 508           Rectangle(ps.hdc,cr.left,cr.top,cr.right,cr.bottom);
 509           SetBkMode(ps.hdc,TRANSPARENT);
 510           HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 511           int x;
 512           int ypos = top_margin;
 513
 514           MoveToEx(ps.hdc,cr.left+lcol-SWELL_UI_SCALE(4),cr.top,NULL);
 515           LineTo(ps.hdc,cr.left+lcol-SWELL_UI_SCALE(4),cr.bottom);
 516           SelectObject(ps.hdc,pen);
 517           MoveToEx(ps.hdc,cr.left+lcol-SWELL_UI_SCALE(5),cr.top,NULL);
 518           LineTo(ps.hdc,cr.left+lcol-SWELL_UI_SCALE(5),cr.bottom);
 519
 520           hwnd->m_extra[1]=0;
 521           for (x=wdl_max(hwnd->m_extra[0],0); x < (menu->items.GetSize()); x++)
 522           {
 523             if (ypos >= cr.bottom)
 524             {
 525               hwnd->m_extra[1] = 1; // allow scrolling down
 526               break;
 527             }
 528             MENUITEMINFO *inf = menu->items.Get(x);
 529             RECT r={lcol,ypos,cr.right, };
 530             bool dis = !!(inf->fState & MF_GRAYED);
 531             BITMAP bm={16,16};
 532
 533             if (inf->fType == MFT_STRING)
 534             {
 535               const char *str = inf->dwTypeData;
 536               if (!str || !*str) str="XXXXX";
 537               RECT mr={0,};
 538               DrawText(ps.hdc,str,-1,&mr,DT_CALCRECT|DT_SINGLELINE);
 539
 540               ypos += mr.bottom + text_ht_pad;
 541               r.bottom = ypos;
 542             }
 543             else if (inf->fType == MFT_BITMAP)
 544             {
 545               if (inf->dwTypeData) GetObject((HBITMAP)inf->dwTypeData,sizeof(bm),&bm);
 546
 547               ypos += bm.bmHeight + bitmap_ht_pad;
 548               r.bottom = ypos;
 549
 550             }
 551             else
 552             {
 553               dis=true;
 554               ypos += separator_ht;
 555               r.bottom = ypos;
 556             }
 557
 558             if (x == menu->sel_vis && !dis)
 559             {
 560               HBRUSH brs=CreateSolidBrush(g_swell_ctheme.menu_bg_sel);
 561               RECT r2=r;
 562               FillRect(ps.hdc,&r2,brs);
 563               DeleteObject(brs);
 564               SetTextColor(ps.hdc,g_swell_ctheme.menu_text_sel);
 565             }
 566             else
 567             {
 568               SetTextColor(ps.hdc,
 569                  dis ? g_swell_ctheme.menu_text_disabled :
 570                  g_swell_ctheme.menu_text);
 571             }
 572
 573             if (inf->fType == MFT_STRING)
 574             {
 575               const char *str = inf->dwTypeData;
 576               if (!str) str="";
 577               const char *pt2 = strstr(str,"\t");
 578
 579               if (*str)
 580               {
 581                 DrawText(ps.hdc,str,pt2 ? (int)(pt2-str) : -1,&r,DT_VCENTER|DT_SINGLELINE);
 582                 if (pt2)
 583                 {
 584                   RECT tr=r; tr.right-=rcol;
 585                   DrawText(ps.hdc,pt2+1,-1,&tr,DT_VCENTER|DT_SINGLELINE|DT_RIGHT);
 586                 }
 587               }
 588             }
 589             else if (inf->fType == MFT_BITMAP)
 590             {
 591               if (inf->dwTypeData)
 592               {
 593                 RECT tr = r;
 594                 tr.top += bitmap_ht_pad/2;
 595                 tr.right = tr.left + bm.bmWidth;
 596                 tr.bottom = tr.top + bm.bmHeight;
 597                 DrawImageInRect(ps.hdc,(HBITMAP)inf->dwTypeData,&tr);
 598               }
 599             }
 600             else
 601             {
 602               SelectObject(ps.hdc,pen2);
 603               int y = r.top/2+r.bottom/2, right = r.right-rcol*3/2;
 604               MoveToEx(ps.hdc,r.left,y,NULL);
 605               LineTo(ps.hdc,right,y);
 606               SelectObject(ps.hdc,pen);
 607
 608               y++;
 609               MoveToEx(ps.hdc,r.left,y,NULL);
 610               LineTo(ps.hdc,right,y);
 611             }
 612             if (inf->hSubMenu)
 613             {
 614                const int sz = (r.bottom-r.top)/4, xp = r.right - sz*2, yp = (r.top + r.bottom)/2;
 615
 616                POINT pts[3] = {
 617                  {xp, yp-sz},
 618                  {xp, yp+sz},
 619                  {xp + sz,yp}
 620                };
 621                HGDIOBJ oldPen = SelectObject(ps.hdc,GetStockObject(NULL_PEN));
 622                SelectObject(ps.hdc,br_submenu_arrow);
 623                Polygon(ps.hdc,pts,3);
 624
 625                SelectObject(ps.hdc,oldPen);
 626             }
 627             if (inf->fState&MF_CHECKED)
 628             {
 629                SetTextColor(ps.hdc,
 630                  dis ? g_swell_ctheme.menu_text_disabled :
 631                  g_swell_ctheme.menu_text);
 632                RECT r2=r; r2.left = 0; r2.right=lcol;
 633                DrawText(ps.hdc,"X",-1,&r2,DT_VCENTER|DT_CENTER|DT_SINGLELINE);
 634             }
 635             if ((r.top+ypos)/2 > cr.bottom)
 636             {
 637               hwnd->m_extra[1] = 1; // allow scrolling down if last item was halfway off
 638             }
 639           }
 640           if (x <= menu->sel_vis) hwnd->m_extra[1]|=2;
 641
 642
 643           // lower scroll indicator
 644           int mid=(cr.right-cr.left)/2;
 645           SelectObject(ps.hdc,GetStockObject(NULL_PEN));
 646           SelectObject(ps.hdc,br3);
 647           POINT pts[3];
 648           const int smm = SWELL_UI_SCALE(2);
 649           const int smh = scroll_margin-smm*2;
 650           if (hwnd->m_extra[1]&1)
 651           {
 652             RECT fr = {cr.left, cr.bottom-scroll_margin, cr.right,cr.bottom};
 653             FillRect(ps.hdc,&fr,br2);
 654             pts[0].x = mid; pts[0].y = cr.bottom - smm;
 655             pts[1].x = mid-smh; pts[1].y = pts[0].y - smh;
 656             pts[2].x = mid+smh; pts[2].y = pts[1].y;
 657             Polygon(ps.hdc,pts,3);
 658           }
 659           // upper scroll indicator
 660           if (hwnd->m_extra[0] > 0)
 661           {
 662             RECT fr = {cr.left, cr.top, cr.right, cr.top+scroll_margin};
 663             FillRect(ps.hdc,&fr,br2);
 664
 665             pts[0].x = mid; pts[0].y = cr.top + smm;
 666             pts[1].x = mid-smh; pts[1].y = pts[0].y + smh;
 667             pts[2].x = mid+smh; pts[2].y = pts[1].y;
 668             Polygon(ps.hdc,pts,3);
 669           }
 670
 671           SelectObject(ps.hdc,oldbr);
 672           SelectObject(ps.hdc,oldpen);
 673           DeleteObject(br);
 674           DeleteObject(br2);
 675           DeleteObject(br3);
 676           DeleteObject(br_submenu_arrow);
 677           DeleteObject(pen);
 678           DeleteObject(pen2);
 679           EndPaint(hwnd,&ps);
 680         }
 681       }
 682     break;
 683     case WM_TIMER:
 684       if (wParam==1)
 685       {
 686         HWND h = GetFocusIncludeMenus();
 687         if (h!=hwnd)
 688         {
 689           int a = h ? m_trackingMenus.Find(h) : -1;
 690           if (a<0 || a < m_trackingMenus.Find(hwnd))
 691           {
 692             if (m_trackingMouseFlag && m_trackingMenus.Get(0))
 693             {
 694               SetFocus(m_trackingMenus.Get(0));
 695               m_trackingMouseFlag=0;
 696             }
 697             else DestroyWindow(hwnd);
 698           }
 699         }
 700       }
 701       else if (wParam == 2)
 702       {
 703         // menu scroll
 704         RECT tr;
 705         GetWindowRect(hwnd,&tr);
 706
 707         POINT curM;
 708         GetCursorPos(&curM);
 709         const bool xmatch = (curM.x >= tr.left && curM.x < tr.right);
 710         if (xmatch || (hwnd->m_extra[1]&3)==3)
 711         {
 712           HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 713           int xFirst = wdl_max(hwnd->m_extra[0],0);
 714           const bool ymatch = curM.y >= tr.bottom-scroll_margin && curM.y < tr.bottom+scroll_margin;
 715           if ((hwnd->m_extra[1]&1) && ((hwnd->m_extra[1]&2) || ymatch))
 716           {
 717             hwnd->m_extra[0]=++xFirst;
 718             hwnd->m_extra[1]=0;
 719             if (ymatch) menu->sel_vis=-1;
 720             InvalidateRect(hwnd,NULL,FALSE);
 721           }
 722           else if (xFirst > 0 && curM.y >= tr.top-scroll_margin && curM.y < tr.top+scroll_margin)
 723           {
 724             hwnd->m_extra[0]=--xFirst;
 725             menu->sel_vis=-1;
 726             InvalidateRect(hwnd,NULL,FALSE);
 727           }
 728         }
 729       }
 730     break;
 731     case WM_KEYUP:
 732     return 1;
 733     case WM_KEYDOWN:
 734       if (wParam == VK_ESCAPE || wParam == VK_LEFT)
 735       {
 736         HWND l = m_trackingMenus.Get(m_trackingMenus.Find(hwnd)-1);
 737         if (l) SetFocus(l);
 738         else
 739         {
 740           if (wParam != VK_LEFT || menuBarNavigate(-1) < 0)
 741             DestroyWindow(hwnd);
 742         }
 743       }
 744       else if (wParam == VK_RETURN || wParam == VK_RIGHT)
 745       {
 746         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 747         if (wParam == VK_RIGHT)
 748         {
 749           MENUITEMINFO *inf = menu->items.Get(menu->sel_vis);
 750           if (!inf || !inf->hSubMenu)
 751           {
 752             menuBarNavigate(1);
 753             return 1;
 754           }
 755         }
 756         SendMessage(hwnd,WM_USER+100,1,menu->sel_vis);
 757       }
 758       else if (wParam == VK_UP || wParam == VK_PRIOR)
 759       {
 760         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 761         int l = menu->sel_vis;
 762         for (int i= wParam == VK_UP ? 0 : 9; i>=0; i--)
 763         {
 764           int mc = menu->items.GetSize();
 765           while (mc--)
 766           {
 767             if (l<1)
 768             {
 769               if (wParam != VK_UP) break;
 770               l = menu->items.GetSize();
 771             }
 772             MENUITEMINFO *inf = menu->items.Get(--l);
 773             if (!inf) break;
 774             if (!(inf->fState & MF_GRAYED) && inf->fType != MFT_SEPARATOR)
 775             {
 776               menu->sel_vis=l;
 777               break;
 778             }
 779           }
 780         }
 781         if (menu->sel_vis < hwnd->m_extra[0])
 782           hwnd->m_extra[0] = menu->sel_vis;
 783         InvalidateRect(hwnd,NULL,FALSE);
 784       }
 785       else if (wParam == VK_DOWN || wParam == VK_NEXT)
 786       {
 787         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 788         int l = menu->sel_vis;
 789         const int n =menu->items.GetSize()-1;
 790         for (int i = wParam == VK_DOWN ? 0 : 9; i>=0; i--)
 791         {
 792           int mc = n+1;
 793           while (mc--)
 794           {
 795             if (l>=n)
 796             {
 797               if (wParam != VK_DOWN) break;
 798               l=-1;
 799               hwnd->m_extra[0]=0;
 800             }
 801             MENUITEMINFO *inf = menu->items.Get(++l);
 802             if (!inf) break;
 803             if (!(inf->fState & MF_GRAYED) && inf->fType != MFT_SEPARATOR)
 804             {
 805               menu->sel_vis=l;
 806               break;
 807             }
 808           }
 809         }
 810         InvalidateRect(hwnd,NULL,FALSE);
 811       }
 812       else if (wParam == VK_END)
 813       {
 814         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 815         int l = menu->items.GetSize();
 816         while (l > 0)
 817         {
 818           MENUITEMINFO *inf = menu->items.Get(--l);
 819           if (!inf) break;
 820           if (!(inf->fState & MF_GRAYED) && inf->fType != MFT_SEPARATOR)
 821           {
 822             menu->sel_vis=l;
 823             break;
 824           }
 825         }
 826         if (menu->sel_vis < hwnd->m_extra[0])
 827           hwnd->m_extra[0] = menu->sel_vis;
 828         InvalidateRect(hwnd,NULL,FALSE);
 829       }
 830       else if (wParam == VK_HOME)
 831       {
 832         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 833         int l = 0;
 834         while (l < menu->items.GetSize())
 835         {
 836           MENUITEMINFO *inf = menu->items.Get(l++);
 837           if (!inf) break;
 838           if (!(inf->fState & MF_GRAYED) && inf->fType != MFT_SEPARATOR)
 839           {
 840             menu->sel_vis=l-1;
 841             break;
 842           }
 843         }
 844         if (menu->sel_vis < hwnd->m_extra[0])
 845           hwnd->m_extra[0] = menu->sel_vis;
 846         InvalidateRect(hwnd,NULL,FALSE);
 847       }
 848       else if ((lParam & FVIRTKEY) && (
 849               (wParam >= 'A' && wParam <= 'Z') ||
 850               (wParam >= '0' && wParam <= '9')))
 851       {
 852         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 853         const int n=menu->items.GetSize();
 854
 855         int offs = menu->sel_vis+1;
 856         if (offs<0||offs>=n) offs=0;
 857         int matchcnt=0;
 858         for(int x=0;x<n+n;x++)
 859         {
 860           MENUITEMINFO *inf = menu->items.Get(offs);
 861           if (inf->fType == MFT_STRING &&
 862               !(inf->fState & MF_GRAYED) &&
 863               inf->dwTypeData)
 864           {
 865             const char *p = inf->dwTypeData;
 866             bool is_prefix_mode = x<n;
 867             if (!is_prefix_mode && matchcnt)
 868             {
 869               if (matchcnt == 1)
 870               {
 871                 // implies prefix mode, only one matching item
 872                 SendMessage(hwnd,WM_USER+100,1,menu->sel_vis);
 873               }
 874               break;
 875             }
 876
 877             if (is_prefix_mode) while (*p)
 878             {
 879               if (*p++ == '&')
 880               {
 881                 if (*p != '&') break;
 882                 p++;
 883               }
 884             }
 885
 886             if (*p > 0 && (WPARAM)toupper(*p) == wParam)
 887             {
 888               if (!matchcnt++)
 889               {
 890                 menu->sel_vis = offs;
 891                 if (menu->sel_vis < hwnd->m_extra[0])
 892                   hwnd->m_extra[0] = menu->sel_vis;
 893                 InvalidateRect(hwnd,NULL,FALSE);
 894               }
 895               if (!is_prefix_mode) break;
 896             }
 897           }
 898           if (++offs >= n) offs=0;
 899         }
 900       }
 901
 902     return 1;
 903     case WM_DESTROY:
 904       {
 905         int a = m_trackingMenus.Find(hwnd);
 906         m_trackingMenus.Delete(a);
 907         if (m_trackingMenus.Get(a)) DestroyWindow(m_trackingMenus.Get(a));
 908         RemoveProp(hwnd,"SWELL_MenuOwner");
 909       }
 910     break;
 911     case WM_USER+100:
 912       if (wParam == 1 || wParam == 2 || wParam == 3 || wParam == 4)
 913       {
 914         int which = (int) lParam;
 915         int item_ypos = which;
 916
 917         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
 918
 919         int ht = top_margin;
 920         HDC hdc=GetDC(hwnd);
 921         if (wParam > 1) which = -1;
 922         else item_ypos = 0;
 923         for (int x=wdl_max(hwnd->m_extra[0],0); x < (menu->items.GetSize()); x++)
 924         {
 925           if (wParam == 1 && which == x) { item_ypos = ht; break; }
 926           MENUITEMINFO *inf = menu->items.Get(x);
 927           int lastht = ht;
 928           if (inf->fType == MFT_STRING)
 929           {
 930             RECT r={0,};
 931             const char *str = inf->dwTypeData;
 932             if (!str || !*str) str="XXXXX";
 933             const char *pt2 = strstr(str,"\t");
 934             DrawText(hdc,str,pt2 ? (int)(pt2-str) : -1,&r,DT_CALCRECT|DT_SINGLELINE);
 935             ht += r.bottom + text_ht_pad;
 936           }
 937           else if (inf->fType == MFT_BITMAP)
 938           {
 939             BITMAP bm={16,16};
 940             if (inf->dwTypeData) GetObject((HBITMAP)inf->dwTypeData,sizeof(bm),&bm);
 941             ht += bm.bmHeight + bitmap_ht_pad;
 942           }
 943           else
 944           {
 945             ht += separator_ht;
 946           }
 947           if (wParam > 1 && item_ypos < ht)
 948           {
 949             item_ypos = lastht;
 950             which = x;
 951             if (wParam == 4 && inf->hSubMenu)
 952             {
 953               HWND nextmenu = m_trackingMenus.Get(m_trackingMenus.Find(hwnd)+1);
 954               if (!nextmenu || GetWindowLongPtr(nextmenu,GWLP_USERDATA) != (LPARAM)inf->hSubMenu)
 955               {
 956                 wParam = 1; // activate if not already visible
 957                 menu->sel_vis = which;
 958               }
 959             }
 960             break;
 961           }
 962         }
 963         ReleaseDC(hwnd,hdc);
 964         if (wParam == 3 || wParam == 4)
 965         {
 966           MENUITEMINFO *inf = menu->items.Get(which);
 967           HWND next = m_trackingMenus.Get(m_trackingMenus.Find(hwnd)+1);
 968           if (next && inf && (!inf->hSubMenu || (LPARAM)inf->hSubMenu != GetWindowLongPtr(next,GWLP_USERDATA))) DestroyWindow(next);
 969           menu->sel_vis = which;
 970           return 0;
 971         }
 972
 973         MENUITEMINFO *inf = menu->items.Get(which);
 974
 975         if (inf)
 976         {
 977           if (inf->fState&MF_GRAYED){ }
 978           else if (inf->hSubMenu)
 979           {
 980             const int nextidx = m_trackingMenus.Find(hwnd)+1;
 981             HWND hh = m_trackingMenus.Get(nextidx);
 982
 983             inf->hSubMenu->sel_vis=-1;
 984
 985             if (hh)
 986             {
 987               m_trackingMenus.Delete(nextidx);
 988               int a = m_trackingMenus.GetSize();
 989               while (a > nextidx) DestroyWindow(m_trackingMenus.Get(--a));
 990             }
 991             else
 992             {
 993               hh = new HWND__(NULL,0,NULL,"menu",false,submenuWndProc,NULL, hwnd);
 994               SetProp(hh,"SWELL_MenuOwner",GetProp(hwnd,"SWELL_MenuOwner"));
 995             }
 996
 997             RECT r;
 998             GetClientRect(hwnd,&r);
 999             m_trackingPt.x=r.right - SWELL_UI_SCALE(3);
1000             m_trackingPt.y=item_ypos;
1001             m_trackingPt2.x=r.left + lcol/4;
1002             m_trackingPt2.y=item_ypos;
1003             ClientToScreen(hwnd,&m_trackingPt);
1004             ClientToScreen(hwnd,&m_trackingPt2);
1005
1006             submenuWndProc(hh, WM_CREATE,0,(LPARAM)inf->hSubMenu);
1007             InvalidateRect(hwnd,NULL,FALSE);
1008           }
1009           else if (inf->wID) m_trackingRet = inf->wID;
1010         }
1011       }
1012     return 0;
1013     case WM_MOUSEMOVE:
1014       {
1015         if (swell_delegate_menu_message(hwnd, lParam,uMsg, false))
1016           return 0;
1017
1018         RECT r;
1019         GetClientRect(hwnd,&r);
1020         HMENU__ *menu = (HMENU__*)GetWindowLongPtr(hwnd,GWLP_USERDATA);
1021         const int oldsel = menu->sel_vis;
1022         if (GET_X_LPARAM(lParam)>=r.left && GET_X_LPARAM(lParam)<r.right)
1023         {
1024           int mode = 4;//GET_X_LPARAM(lParam) >= r.right - rcol*2 ? 4 : 3;
1025           SendMessage(hwnd,WM_USER+100,mode,GET_Y_LPARAM(lParam));
1026         }
1027         else menu->sel_vis = -1;
1028         if (oldsel != menu->sel_vis) InvalidateRect(hwnd,NULL,FALSE);
1029       }
1030     return 0;
1031     case WM_LBUTTONUP:
1032     case WM_RBUTTONUP:
1033       {
1034         if (swell_delegate_menu_message(hwnd, lParam, uMsg, false))
1035           return 0;
1036
1037         RECT r;
1038         GetClientRect(hwnd,&r);
1039         if (GET_X_LPARAM(lParam)>=r.left && GET_X_LPARAM(lParam)<r.right)
1040         {
1041           SendMessage(hwnd,WM_USER+100,2,GET_Y_LPARAM(lParam));
1042           return 0;
1043         }
1044         else DestroyWindow(hwnd);
1045       }
1046     return 0;
1047   }
1048   return DefWindowProc(hwnd,uMsg,wParam,lParam);
1049 }
1050
1051 void DestroyPopupMenus()
1052 {
1053   if (m_trackingMenus.GetSize()) DestroyWindow(m_trackingMenus.Get(0));
1054 }
1055
1056 int TrackPopupMenu(HMENU hMenu, int flags, int xpos, int ypos, int resvd, HWND hwnd, const RECT *r)
1057 {
1058   if (!hMenu || m_trackingMenus.GetSize()) return 0;
1059
1060   ReleaseCapture();
1061
1062   hMenu->Retain();
1063   m_trackingPar=hwnd;
1064   m_trackingFlags=flags;
1065   m_trackingRet=-1;
1066   m_trackingPt2.x=m_trackingPt.x=xpos;
1067   m_trackingPt2.y=m_trackingPt.y=ypos;
1068   m_trackingMouseFlag = 0;
1069   if (GetAsyncKeyState(VK_LBUTTON)) m_trackingMouseFlag |= 1;
1070   if (GetAsyncKeyState(VK_RBUTTON)) m_trackingMouseFlag |= 2;
1071   if (GetAsyncKeyState(VK_MBUTTON)) m_trackingMouseFlag |= 4;
1072
1073 //  HWND oldFoc = GetFocus();
1074  // bool oldFoc_child = oldFoc && (IsChild(hwnd,oldFoc) || oldFoc == hwnd || oldFoc==GetParent(hwnd));
1075
1076   if (hwnd) hwnd->Retain();
1077
1078   hMenu->sel_vis=-1;
1079   HWND hh=new HWND__(NULL,0,NULL,"menu",false,submenuWndProc,NULL, hwnd);
1080
1081   submenuWndProc(hh,WM_CREATE,0,(LPARAM)hMenu);
1082
1083   SetProp(hh,"SWELL_MenuOwner",(HANDLE)hwnd);
1084
1085   while (m_trackingRet<0 && m_trackingMenus.GetSize())
1086   {
1087     void SWELL_RunMessageLoop();
1088     SWELL_RunMessageLoop();
1089     Sleep(10);
1090   }
1091
1092   int x=m_trackingMenus.GetSize()-1;
1093   while (x>=0)
1094   {
1095     HWND h = m_trackingMenus.Get(x);
1096     m_trackingMenus.Delete(x);
1097     if (h) DestroyWindow(h);
1098     x--;
1099   }
1100
1101 //  if (oldFoc_child) SetFocus(oldFoc);
1102
1103   if (!(flags&TPM_NONOTIFY) && m_trackingRet>0)
1104     SendMessage(hwnd,WM_COMMAND,m_trackingRet,0);
1105
1106   if (hwnd) hwnd->Release();
1107
1108   hMenu->Release();
1109
1110   return m_trackingRet>0?m_trackingRet:0;
1111 }
1112
1113
1114
1115
1116 void SWELL_Menu_AddMenuItem(HMENU hMenu, const char *name, int idx, unsigned int flags)
1117 {
1118   MENUITEMINFO mi={sizeof(mi),MIIM_ID|MIIM_STATE|MIIM_TYPE,MFT_STRING,
1119     (UINT)((flags)?MFS_GRAYED:0),(UINT)idx,NULL,NULL,NULL,0,(char *)name};
1120   if (!name)
1121   {
1122     mi.fType = MFT_SEPARATOR;
1123     mi.fMask&=~(MIIM_STATE|MIIM_ID);
1124   }
1125   InsertMenuItem(hMenu,GetMenuItemCount(hMenu),TRUE,&mi);
1126 }
1127
1128
1129 SWELL_MenuResourceIndex *SWELL_curmodule_menuresource_head; // todo: move to per-module thingy
1130
1131 static SWELL_MenuResourceIndex *resById(SWELL_MenuResourceIndex *head, const char *resid)
1132 {
1133   SWELL_MenuResourceIndex *p=head;
1134   while (p)
1135   {
1136     if (p->resid == resid) return p;
1137     p=p->_next;
1138   }
1139   return 0;
1140 }
1141
1142 HMENU SWELL_LoadMenu(SWELL_MenuResourceIndex *head, const char *resid)
1143 {
1144   SWELL_MenuResourceIndex *p;
1145
1146   if (!(p=resById(head,resid))) return 0;
1147   HMENU hMenu=CreatePopupMenu();
1148   if (hMenu) p->createFunc(hMenu);
1149   return hMenu;
1150 }
1151
1152 HMENU SWELL_DuplicateMenu(HMENU menu)
1153 {
1154   if (!menu) return 0;
1155   return menu->Duplicate();
1156 }
1157
1158 BOOL  SetMenu(HWND hwnd, HMENU menu)
1159 {
1160   if (!hwnd) return 0;
1161   HMENU oldmenu = hwnd->m_menu;
1162
1163   hwnd->m_menu = menu;
1164
1165   if (!hwnd->m_parent && !!hwnd->m_menu != !!oldmenu)
1166   {
1167     WNDPROC oldwc = hwnd->m_wndproc;
1168     hwnd->m_wndproc = DefWindowProc;
1169     RECT r;
1170     GetWindowRect(hwnd,&r);
1171
1172     if (oldmenu) r.bottom -= g_swell_ctheme.menubar_height; // hack: we should WM_NCCALCSIZE before and after, really
1173     else r.bottom += g_swell_ctheme.menubar_height;
1174
1175     SetWindowPos(hwnd,NULL,0,0,r.right-r.left,r.bottom-r.top,SWP_NOZORDER|SWP_NOMOVE|SWP_NOACTIVATE);
1176     hwnd->m_wndproc = oldwc;
1177     // resize
1178   }
1179
1180   return TRUE;
1181 }
1182
1183 HMENU GetMenu(HWND hwnd)
1184 {
1185   if (!hwnd) return 0;
1186   return hwnd->m_menu;
1187 }
1188
1189 void DrawMenuBar(HWND hwnd)
1190 {
1191   if (hwnd && hwnd->m_menu)
1192   {
1193     RECT r;
1194     GetClientRect(hwnd,&r);
1195     r.top = - g_swell_ctheme.menubar_height;
1196     r.bottom=0;
1197     InvalidateRect(hwnd,&r,FALSE);
1198   }
1199 }
1200
1201
1202 // copied from swell-menu.mm, can have a common impl someday
1203 int SWELL_GenerateMenuFromList(HMENU hMenu, const void *_list, int listsz)
1204 {
1205   SWELL_MenuGen_Entry *list = (SWELL_MenuGen_Entry *)_list;
1206   const int l1=strlen(SWELL_MENUGEN_POPUP_PREFIX);
1207   while (listsz>0)
1208   {
1209     int cnt=1;
1210     if (!list->name) SWELL_Menu_AddMenuItem(hMenu,NULL,-1,0);
1211     else if (!strcmp(list->name,SWELL_MENUGEN_ENDPOPUP)) return list + 1 - (SWELL_MenuGen_Entry *)_list;
1212     else if (!strncmp(list->name,SWELL_MENUGEN_POPUP_PREFIX,l1))
1213     {
1214       MENUITEMINFO mi={sizeof(mi),MIIM_SUBMENU|MIIM_STATE|MIIM_TYPE,MFT_STRING,0,0,CreatePopupMenuEx(list->name+l1),NULL,NULL,0,(char *)list->name+l1};
1215       cnt += SWELL_GenerateMenuFromList(mi.hSubMenu,list+1,listsz-1);
1216       InsertMenuItem(hMenu,GetMenuItemCount(hMenu),TRUE,&mi);
1217     }
1218     else SWELL_Menu_AddMenuItem(hMenu,list->name,list->idx,list->flags);
1219
1220     list+=cnt;
1221     listsz -= cnt;
1222   }
1223   return list + 1 - (SWELL_MenuGen_Entry *)_list;
1224 }
1225 #endif