Mercurial > ecos

comparison host/tools/configtool/standalone/win32/BCMenu.cpp @ 76:435cced73e2f ecos-v1_3_1-release

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eCos v1.3.1 merged from eCos master repository on 2000-03-27-23:22:51-BST
author jlarmour
date Tue, 28 Mar 2000 14:10:45 +0000
parents
children 74dbf4c3f2e1
comparison
equal deleted inserted replaced
75:41bf073c0c32 76:435cced73e2f
1 //####COPYRIGHTBEGIN####
2 //
3 // ----------------------------------------------------------------------------
4 // Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
5 //
6 // This program is part of the eCos host tools.
7 //
8 // This program is free software; you can redistribute it and/or modify it
9 // under the terms of the GNU General Public License as published by the Free
10 // Software Foundation; either version 2 of the License, or (at your option)
11 // any later version.
12 //
13 // This program is distributed in the hope that it will be useful, but WITHOUT
14 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 // more details.
17 //
18 // You should have received a copy of the GNU General Public License along with
19 // this program; if not, write to the Free Software Foundation, Inc.,
20 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 //
22 // ----------------------------------------------------------------------------
23 //
24 //####COPYRIGHTEND####
25
26 //#####DESCRIPTIONBEGIN####
27 //
28 //*************************************************************************
29 // BCMenu.cpp : implementation file
30 // Version : 2.63
31 // Date : December 2, 1999
32 // Author : Brent Corkum
33 // Email : corkum@rocscience.com
34 // Latest Version : http://www.rocscience.com/~corkum/BCMenu.html
35 //
36 // Bug Fixes and portions of code supplied by:
37 //
38 // Ben Ashley,Girish Bharadwaj,Jean-Edouard Lachand-Robert,
39 // Robert Edward Caldecott,Kenny Goers,Leonardo Zide,
40 // Stefan Kuhr,Reiner Jung,Martin Vladic,Kim Yoo Chul,
41 // Oz Solomonovich
42 //
43 // You are free to use/modify this code but leave this header intact.
44 // This class is public domain so you are free to use it any of
45 // your applications (Freeware,Shareware,Commercial). All I ask is
46 // that you let me know so that if you have a real winner I can
47 // brag to my buddies that some of my code is in your app. I also
48 // wouldn't mind if you sent me a copy of your application since I
49 // like to play with new stuff.
50 //*************************************************************************
51 //####DESCRIPTIONEND####
52 //==========================================================================
53
54 #include "stdafx.h" // Standard windows header file
55 #include "BCMenu.h" // BCMenu class declaration
56 #include <afxpriv.h> //SK: makes A2W and other spiffy AFX macros work
57
58 #ifdef _DEBUG
59 #define new DEBUG_NEW
60 #undef THIS_FILE
61 static char THIS_FILE[] = __FILE__;
62 #endif
63
64 #define GAP 1
65 #ifndef OBM_CHECK
66 #define OBM_CHECK 32760 // from winuser.h
67 #endif
68
69 #if _MFC_VER <0x400
70 #error This code does not work on Versions of MFC prior to 4.0
71 #endif
72
73 static CPINFO CPInfo;
74
75 enum Win32Type{
76 Win32s,
77 Windoze95,
78 WinNT3,
79 WinNT4orHigher
80 };
81
82
83 Win32Type IsShellType()
84 {
85 Win32Type ShellType;
86 DWORD winVer;
87 OSVERSIONINFO *osvi;
88
89 winVer=GetVersion();
90 if(winVer<0x80000000){/*NT */
91 ShellType=WinNT3;
92 osvi= (OSVERSIONINFO *)malloc(sizeof(OSVERSIONINFO));
93 if (osvi!=NULL){
94 memset(osvi,0,sizeof(OSVERSIONINFO));
95 osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
96 GetVersionEx(osvi);
97 if (osvi->dwMajorVersion>=4L)
98 ShellType=WinNT4orHigher;//yup, it is NT 4 or higher!
99 free(osvi);
100 }
101 }
102 else if (LOBYTE(LOWORD(winVer))<4)
103 ShellType=Win32s;/*Win32s*/
104 else
105 ShellType=Windoze95;/*Windoze95*/
106 return ShellType;
107 }
108
109 static Win32Type g_Shell=IsShellType();
110
111 void BCMenuData::SetAnsiString(LPCSTR szAnsiString)
112 {
113 USES_CONVERSION;
114 SetWideString(A2W(szAnsiString)); //SK: see MFC Tech Note 059
115 }
116
117 CString BCMenuData::GetString(void)//returns the menu text in ANSI or UNICODE
118 //depending on the MFC-Version we are using
119 {
120 CString strText;
121 if (m_szMenuText)
122 {
123 #ifdef UNICODE
124 strText = m_szMenuText;
125 #else
126 USES_CONVERSION;
127 strText=W2A(m_szMenuText); //SK: see MFC Tech Note 059
128 #endif
129 }
130 return strText;
131 }
132
133 CTypedPtrArray<CPtrArray, HMENU> BCMenu::m_AllSubMenus; // Stores list of all sub-menus
134
135 /*
136
137 ===============================================================================
138 BCMenu::BCMenu()
139 TCMeny::~BCMenu()
140 -----------------
141
142 Constructor and Destructor.
143
144 ===============================================================================
145 */
146
147 BCMenu::BCMenu()
148 {
149 m_bDynIcons = FALSE; // O.S. - no dynamic icons by default
150 disable_old_style=FALSE;
151 m_iconX = 16; // Icon sizes default to 16 x 16
152 m_iconY = 15; // ...
153 m_selectcheck = -1;
154 m_unselectcheck = -1;
155 checkmaps=NULL;
156 checkmapsshare=FALSE;
157 // set the color used for the transparent background in all bitmaps
158 m_bitmapBackground=RGB(192,192,192); //gray
159 m_bitmapBackgroundFlag=FALSE;
160 GetCPInfo(CP_ACP,&CPInfo);
161 }
162
163
164 BCMenu::~BCMenu()
165 {
166 DestroyMenu();
167 }
168
169 BOOL BCMenu::IsNewShell ()
170 {
171 return (Windoze95==g_Shell || WinNT4orHigher==g_Shell);
172 }
173
174
175 BCMenuData::~BCMenuData()
176 {
177 if(bitmap)
178 delete(bitmap);
179
180 delete[] m_szMenuText; //Need not check for NULL because ANSI X3J16 allows "delete NULL"
181 }
182
183
184 void BCMenuData::SetWideString(const wchar_t *szWideString)
185 {
186 delete[] m_szMenuText;//Need not check for NULL because ANSI X3J16 allows "delete NULL"
187
188 if (szWideString)
189 {
190 m_szMenuText = new wchar_t[sizeof(wchar_t)*(wcslen(szWideString)+1)];
191 if (m_szMenuText)
192 wcscpy(m_szMenuText,szWideString);
193 }
194 else
195 m_szMenuText=NULL;//set to NULL so we need not bother about dangling non-NULL Ptrs
196 }
197
198 BOOL BCMenu::IsMenu(CMenu *submenu)
199 {
200 int m;
201 int numSubMenus = m_AllSubMenus.GetUpperBound();
202 for(m=0;m<=numSubMenus;++m){
203 if(submenu->m_hMenu==m_AllSubMenus[m])return(TRUE);
204 }
205 return(FALSE);
206 }
207
208 BOOL BCMenu::IsMenu(HMENU submenu)
209 {
210 int m;
211 int numSubMenus = m_AllSubMenus.GetUpperBound();
212 for(m=0;m<=numSubMenus;++m){
213 if(submenu==m_AllSubMenus[m])return(TRUE);
214 }
215 return(FALSE);
216 }
217
218 BOOL BCMenu::DestroyMenu()
219 {
220 // Destroy Sub menus:
221 int m,n;
222 int numAllSubMenus = m_AllSubMenus.GetUpperBound();
223 for(n = numAllSubMenus; n>= 0; n--){
224 if(m_AllSubMenus[n]==this->m_hMenu)m_AllSubMenus.RemoveAt(n);
225 }
226 int numSubMenus = m_SubMenus.GetUpperBound();
227 for(m = numSubMenus; m >= 0; m--){
228 numAllSubMenus = m_AllSubMenus.GetUpperBound();
229 for(n = numAllSubMenus; n>= 0; n--){
230 if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
231 }
232 delete((BCMenu *)FromHandle(m_SubMenus[m]));
233 }
234 m_SubMenus.RemoveAll();
235 // Destroy menu data
236 int numItems = m_MenuList.GetUpperBound();
237 for(m = 0; m <= numItems; m++)delete(m_MenuList[m]);
238 m_MenuList.RemoveAll();
239 if(checkmaps&&!checkmapsshare){
240 delete checkmaps;
241 checkmaps=NULL;
242 }
243 // Call base-class implementation last:
244 return(CMenu::DestroyMenu());
245 };
246
247
248 ///////////////////////////////////////////////////////////////////////////
249 //
250 // BCMenu message handlers
251
252
253 /*
254 ==========================================================================
255 void BCMenu::DrawItem(LPDRAWITEMSTRUCT)
256 ---------------------------------------
257
258 Called by the framework when a particular item needs to be drawn. We
259 overide this to draw the menu item in a custom-fashion, including icons
260 and the 3D rectangle bar.
261 ==========================================================================
262 */
263
264
265 void BCMenu::DrawItem (LPDRAWITEMSTRUCT lpDIS)
266 {
267 ASSERT(lpDIS != NULL);
268 CDC* pDC = CDC::FromHandle(lpDIS->hDC);
269 CRect rect;
270 UINT state = (((BCMenuData*)(lpDIS->itemData))->nFlags);
271 if(state & MF_SEPARATOR){
272 rect.CopyRect(&lpDIS->rcItem);
273 rect.top+=rect.Height()>>1;
274 pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
275 }
276 else{
277 CRect rect2;
278 BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
279 BOOL checkflag=FALSE;
280 COLORREF crText = GetSysColor(COLOR_MENUTEXT);
281 COLORREF m_clrBack=GetSysColor(COLOR_MENU);
282 CBrush m_brBackground,m_brSelect;
283 CPen m_penBack;
284 int x0,y0,dy;
285 int nIconNormal=-1,xoffset=-1;
286 CImageList *bitmap=NULL;
287 CFont m_fontMenu;
288 LOGFONT m_lf;
289
290 // set some colors and the font
291 m_penBack.CreatePen (PS_SOLID,0,GetSysColor(COLOR_MENU));
292 m_brBackground.CreateSolidBrush(GetSysColor(COLOR_MENU));
293 m_brSelect.CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
294 ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
295 NONCLIENTMETRICS nm;
296 nm.cbSize = sizeof (NONCLIENTMETRICS);
297 VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0));
298 m_lf = nm.lfMenuFont;
299 m_fontMenu.CreateFontIndirect (&m_lf);
300
301 // draw the colored rectangle portion
302
303 rect.CopyRect(&lpDIS->rcItem);
304 rect2=rect;
305
306 // draw the up/down/focused/disabled state
307
308 UINT state = lpDIS->itemState;
309 CString strText;
310 LOGFONT lf;
311 lf = m_lf;
312
313 CFont dispFont;
314 CFont *pFont=NULL;
315
316 if(lpDIS->itemData != NULL){
317 nIconNormal = (((BCMenuData*)(lpDIS->itemData))->menuIconNormal);
318 xoffset = (((BCMenuData*)(lpDIS->itemData))->xoffset);
319 bitmap = (((BCMenuData*)(lpDIS->itemData))->bitmap);
320 strText = ((BCMenuData*) (lpDIS->itemData))->GetString();
321
322 if(state&ODS_CHECKED && nIconNormal<0){
323 if(state&ODS_SELECTED && m_selectcheck>0)checkflag=TRUE;
324 else if(m_unselectcheck>0) checkflag=TRUE;
325 }
326 else if(nIconNormal != -1){
327 standardflag=TRUE;
328 if(state&ODS_SELECTED && !(state&ODS_GRAYED))selectedflag=TRUE;
329 else if(state&ODS_GRAYED) disableflag=TRUE;
330 }
331 }
332 else{
333 strText.Empty();
334 }
335
336 if(state&ODS_SELECTED){ // draw the down edges
337
338 CPen *pOldPen = pDC->SelectObject (&m_penBack);
339
340 // You need only Text highlight and thats what you get
341
342 if(checkflag||standardflag||selectedflag||disableflag||state&ODS_CHECKED)
343 rect2.SetRect(rect.left+m_iconX+4+GAP,rect.top,rect.right,rect.bottom);
344 pDC->FillRect (rect2,&m_brSelect);
345
346 pDC->SelectObject (pOldPen);
347 if((HFONT)dispFont != NULL)dispFont.DeleteObject ();
348 dispFont.CreateFontIndirect (&lf);
349 crText = GetSysColor(COLOR_HIGHLIGHTTEXT);
350 }
351 else {
352 CPen *pOldPen = pDC->SelectObject (&m_penBack);
353 pDC->FillRect (rect,&m_brBackground);
354 pDC->SelectObject (pOldPen);
355
356 // draw the up edges
357
358 pDC->Draw3dRect (rect,m_clrBack,m_clrBack);
359 if ((HFONT)dispFont != NULL) dispFont.DeleteObject ();
360 dispFont.CreateFontIndirect (&lf); //Normal
361 }
362
363 // draw the text if there is any
364 //We have to paint the text only if the image is nonexistant
365
366 dy = (rect.Height()-4-m_iconY)/2;
367 dy = dy<0 ? 0 : dy;
368
369 if(checkflag||standardflag||selectedflag||disableflag){
370 rect2.SetRect(rect.left+1,rect.top+1+dy,rect.left+m_iconX+3,
371 rect.top+m_iconY+3+dy);
372 pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
373 if(checkflag && checkmaps){
374 pDC->FillRect (rect2,&m_brBackground);
375 rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
376 rect.top+m_iconY+4+dy);
377
378 pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
379 CPoint ptImage(rect.left+2,rect.top+2+dy);
380
381 if(state&ODS_SELECTED)checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
382 else checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
383 }
384 else if(disableflag){
385 if(!selectedflag){
386 CBitmap bitmapstandard;
387 GetBitmapFromImageList(pDC,bitmap,xoffset,bitmapstandard);
388 rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
389 rect.top+m_iconY+4+dy);
390 pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
391 if(disable_old_style)
392 DitherBlt(lpDIS->hDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
393 (HBITMAP)(bitmapstandard),0,0);
394 else
395 DitherBlt2(pDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
396 bitmapstandard,0,0);
397 bitmapstandard.DeleteObject();
398 }
399 }
400 else if(selectedflag){
401 pDC->FillRect (rect2,&m_brBackground);
402 rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
403 rect.top+m_iconY+4+dy);
404 if (IsNewShell()){
405 if(state&ODS_CHECKED)
406 pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
407 GetSysColor(COLOR_3DHILIGHT));
408 else
409 pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DHILIGHT),
410 GetSysColor(COLOR_3DSHADOW));
411 }
412 CPoint ptImage(rect.left+2,rect.top+2+dy);
413 if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
414 }
415 else{
416 if(state&ODS_CHECKED){
417 CBrush brush;
418 COLORREF col =GetSysColor(COLOR_3DLIGHT);
419 brush.CreateSolidBrush(col);
420 pDC->FillRect(rect2,&brush);
421 brush.DeleteObject();
422 rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
423 rect.top+m_iconY+4+dy);
424 if (IsNewShell())
425 pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
426 GetSysColor(COLOR_3DHILIGHT));
427 }
428 else{
429 pDC->FillRect (rect2,&m_brBackground);
430 rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
431 rect.top+m_iconY+4+dy);
432 pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
433 }
434 CPoint ptImage(rect.left+2,rect.top+2+dy);
435 if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
436 }
437 }
438 if(nIconNormal<0 && state&ODS_CHECKED && !checkflag){
439 rect2.SetRect(rect.left+1,rect.top+2+dy,rect.left+m_iconX+1,
440 rect.top+m_iconY+2+dy);
441 CMenuItemInfo info;
442 info.fMask = MIIM_CHECKMARKS;
443 ::GetMenuItemInfo((HMENU)lpDIS->hwndItem,lpDIS->itemID,
444 MF_BYCOMMAND, &info);
445 if(state&ODS_CHECKED || info.hbmpUnchecked) {
446 Draw3DCheckmark(pDC, rect2, state&ODS_SELECTED,
447 state&ODS_CHECKED ? info.hbmpChecked :
448 info.hbmpUnchecked);
449 }
450 }
451
452 //This is needed always so that we can have the space for check marks
453
454 x0=rect.left;y0=rect.top;
455 rect.left = rect.left + m_iconX + 8 + GAP;
456
457 if(!strText.IsEmpty()){
458
459 CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
460
461 // Find tabs
462
463 CString leftStr,rightStr;
464 leftStr.Empty();rightStr.Empty();
465 int tablocr=strText.ReverseFind(_T('\t'));
466 if(tablocr!=-1){
467 rightStr=strText.Mid(tablocr+1);
468 leftStr=strText.Left(strText.Find(_T('\t')));
469 rectt.right-=m_iconX;
470 }
471 else leftStr=strText;
472
473 int iOldMode = pDC->GetBkMode();
474 pDC->SetBkMode( TRANSPARENT);
475
476 // Draw the text in the correct colour:
477
478 UINT nFormat = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
479 UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
480 if(!(lpDIS->itemState & ODS_GRAYED)){
481 pDC->SetTextColor(crText);
482 pDC->DrawText (leftStr,rectt,nFormat);
483 if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
484 }
485 else{
486
487 // Draw the disabled text
488 if(!(state & ODS_SELECTED)){
489 RECT offset = *rectt;
490 offset.left+=1;
491 offset.right+=1;
492 offset.top+=1;
493 offset.bottom+=1;
494 pDC->SetTextColor(GetSysColor(COLOR_BTNHILIGHT));
495 pDC->DrawText(leftStr,&offset, nFormat);
496 if(tablocr!=-1) pDC->DrawText (rightStr,&offset,nFormatr);
497 pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
498 pDC->DrawText(leftStr,rectt, nFormat);
499 if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
500 }
501 else{
502 // And the standard Grey text:
503 pDC->SetTextColor(m_clrBack);
504 pDC->DrawText(leftStr,rectt, nFormat);
505 if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
506 }
507 }
508 pFont = pDC->SelectObject (&dispFont);
509 pDC->SetBkMode( iOldMode );
510 pDC->SelectObject (pFont); //set it to the old font
511 }
512
513 m_penBack.DeleteObject();
514 m_brBackground.DeleteObject();
515 m_fontMenu.DeleteObject();
516 m_brSelect.DeleteObject();
517 dispFont.DeleteObject ();
518 }
519 }
520
521 BOOL BCMenu::GetBitmapFromImageList(CDC* pDC,CImageList *imglist,int nIndex,CBitmap &bmp)
522 {
523 HICON hIcon = imglist->ExtractIcon(nIndex);
524 CDC dc;
525 dc.CreateCompatibleDC(pDC);
526 bmp.CreateCompatibleBitmap(pDC,m_iconX,m_iconY);
527 CBitmap* pOldBmp = dc.SelectObject(&bmp);
528 CBrush brush ;
529 brush.CreateSolidBrush(GetSysColor(COLOR_MENU));
530 ::DrawIconEx(
531 dc.GetSafeHdc(),
532 0,
533 0,
534 hIcon,
535 m_iconX,
536 m_iconY,
537 0,
538 (HBRUSH)brush,
539 DI_NORMAL
540 );
541 dc.SelectObject( pOldBmp );
542 dc.DeleteDC();
543 // the icon is not longer needed
544 DestroyIcon(hIcon);
545 return(TRUE);
546 }
547
548 /*
549 ==========================================================================
550 void BCMenu::MeasureItem(LPMEASUREITEMSTRUCT)
551 ---------------------------------------------
552
553 Called by the framework when it wants to know what the width and height
554 of our item will be. To accomplish this we provide the width of the
555 icon plus the width of the menu text, and then the height of the icon.
556
557 ==========================================================================
558 */
559
560 void BCMenu::MeasureItem( LPMEASUREITEMSTRUCT lpMIS )
561 {
562 UINT state = (((BCMenuData*)(lpMIS->itemData))->nFlags);
563 if(state & MF_SEPARATOR){
564 lpMIS->itemWidth = 0;
565 lpMIS->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
566 }
567 else{
568 CFont m_fontMenu;
569 LOGFONT m_lf;
570 ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
571 NONCLIENTMETRICS nm;
572 nm.cbSize = sizeof (NONCLIENTMETRICS);
573 VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
574 nm.cbSize,&nm,0));
575 m_lf = nm.lfMenuFont;
576 m_fontMenu.CreateFontIndirect (&m_lf);
577
578 // Obtain the width of the text:
579 CWnd *pWnd = AfxGetMainWnd(); // Get main window
580 CDC *pDC = pWnd->GetDC(); // Get device context
581 CFont* pFont=NULL; // Select menu font in...
582
583 if (IsNewShell())
584 pFont = pDC->SelectObject (&m_fontMenu);// Select menu font in...
585
586 //Get pointer to text SK
587 const wchar_t *lpstrText = ((BCMenuData*)(lpMIS->itemData))->GetWideString();//SK: we use const to prevent misuse
588
589
590 SIZE size;
591
592 if (Win32s!=g_Shell)
593 VERIFY(::GetTextExtentPoint32W(pDC->m_hDC,lpstrText,
594 wcslen(lpstrText),&size)); //SK should also work on 95
595 #ifndef UNICODE //can't be UNICODE for Win32s
596 else{//it's Win32suckx
597 RECT rect;
598 rect.left=rect.top=0;
599 size.cy=DrawText(pDC->m_hDC,(LPCTSTR)lpstrText,
600 wcslen(lpstrText),&rect,
601 DT_SINGLELINE|DT_LEFT|DT_VCENTER|DT_CALCRECT);
602 //+3 makes at least three pixels space to the menu border
603 size.cx=rect.right-rect.left+3;
604 size.cx += 3*(size.cx/wcslen(lpstrText));
605 }
606 #endif
607
608 CSize t = CSize(size);
609 if(IsNewShell())
610 pDC->SelectObject (pFont); // Select old font in
611 AfxGetMainWnd()->ReleaseDC(pDC); // Release the DC
612
613 // Set width and height:
614
615 lpMIS->itemWidth = m_iconX + t.cx + m_iconX + GAP;
616 int temp = GetSystemMetrics(SM_CYMENU);
617 lpMIS->itemHeight = temp>m_iconY+4 ? temp : m_iconY+4;
618 m_fontMenu.DeleteObject();
619 }
620 }
621
622 void BCMenu::SetIconSize (int width, int height)
623 {
624 m_iconX = width;
625 m_iconY = height;
626 }
627
628 BOOL BCMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID,
629 int nIconNormal)
630 {
631 USES_CONVERSION;
632 return AppendODMenuW(A2W(lpstrText),nFlags,nID,nIconNormal);//SK: See MFC Tech Note 059
633 }
634
635
636 BOOL BCMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID,
637 int nIconNormal)
638 {
639 // Add the MF_OWNERDRAW flag if not specified:
640 if(!nID){
641 if(nFlags&MF_BYPOSITION)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
642 else nFlags=MF_SEPARATOR|MF_OWNERDRAW;
643 }
644 else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
645
646 if(nFlags & MF_POPUP){
647 m_AllSubMenus.Add((HMENU)nID);
648 m_SubMenus.Add((HMENU)nID);
649 }
650
651 BCMenuData *mdata = new BCMenuData;
652 m_MenuList.Add(mdata);
653 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
654
655 mdata->menuIconNormal = nIconNormal;
656 mdata->xoffset=-1;
657 if(nIconNormal>=0){
658 mdata->xoffset=0;
659 LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
660 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
661 else mdata->bitmap=new(CImageList);
662 mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
663 if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
664 mdata->bitmap->DeleteImageList();
665 delete mdata->bitmap;
666 mdata->bitmap=NULL;
667 mdata->menuIconNormal = nIconNormal = -1;
668 mdata->xoffset = -1;
669 }
670 }
671 mdata->nFlags = nFlags;
672 mdata->nID = nID;
673 return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
674 }
675
676 BOOL BCMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID,
677 CImageList *il,int xoffset)
678 {
679 USES_CONVERSION;
680 return AppendODMenuW(A2W(lpstrText),nFlags,nID,il,xoffset);
681 }
682
683 BOOL BCMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID,
684 CImageList *il,int xoffset)
685 {
686 // Add the MF_OWNERDRAW flag if not specified:
687 if(!nID){
688 if(nFlags&MF_BYPOSITION)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
689 else nFlags=MF_SEPARATOR|MF_OWNERDRAW;
690 }
691 else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
692
693 if(nFlags & MF_POPUP){
694 m_AllSubMenus.Add((HMENU)nID);
695 m_SubMenus.Add((HMENU)nID);
696 }
697
698 BCMenuData *mdata = new BCMenuData;
699 m_MenuList.Add(mdata);
700 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
701
702 if(il){
703 mdata->menuIconNormal = 0;
704 mdata->xoffset=0;
705 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
706 else mdata->bitmap=new(CImageList);
707 ImageListDuplicate(il,xoffset,mdata->bitmap);
708 }
709 else{
710 mdata->menuIconNormal = -1;
711 mdata->xoffset = -1;
712 }
713 mdata->nFlags = nFlags;
714 mdata->nID = nID;
715 return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
716 }
717
718 BOOL BCMenu::InsertODMenuA(UINT nPosition,LPCSTR lpstrText,UINT nFlags,UINT nID,
719 int nIconNormal)
720 {
721 USES_CONVERSION;
722 return InsertODMenuW(nPosition,A2W(lpstrText),nFlags,nID,nIconNormal);
723 }
724
725
726 BOOL BCMenu::InsertODMenuW(UINT nPosition,wchar_t *lpstrText,UINT nFlags,UINT nID,
727 int nIconNormal)
728 {
729 if(!(nFlags & MF_BYPOSITION)){
730 int iPosition =0;
731 BCMenu* pMenu = FindMenuOption(nPosition,iPosition);
732 if(pMenu){
733 return(pMenu->InsertODMenuW(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,nIconNormal));
734 }
735 else return(FALSE);
736 }
737
738 if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
739 else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
740
741 if(nFlags & MF_POPUP){
742 m_AllSubMenus.Add((HMENU)nID);
743 m_SubMenus.InsertAt(nPosition,(HMENU)nID);
744 }
745
746 BCMenuData *mdata = new BCMenuData;
747 m_MenuList.InsertAt(nPosition,mdata);
748 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
749
750 mdata->menuIconNormal = nIconNormal;
751 mdata->xoffset=-1;
752 if(nIconNormal>=0){
753 mdata->xoffset=0;
754 LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
755 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
756 else mdata->bitmap=new(CImageList);
757 mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
758 if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
759 mdata->bitmap->DeleteImageList();
760 delete mdata->bitmap;
761 mdata->bitmap=NULL;
762 mdata->menuIconNormal = nIconNormal = -1;
763 mdata->xoffset = -1;
764 }
765 }
766 mdata->nFlags = nFlags;
767 mdata->nID = nID;
768 return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
769 }
770
771 BOOL BCMenu::InsertODMenuA(UINT nPosition,LPCSTR lpstrText,UINT nFlags,UINT nID,
772 CImageList *il,int xoffset)
773 {
774 USES_CONVERSION;
775 return InsertODMenuW(nPosition,A2W(lpstrText),nFlags,nID,il,xoffset);
776 }
777
778 BOOL BCMenu::InsertODMenuW(UINT nPosition,wchar_t *lpstrText,UINT nFlags,UINT nID,
779 CImageList *il,int xoffset)
780 {
781 if(!(nFlags & MF_BYPOSITION)){
782 int iPosition =0;
783 BCMenu* pMenu = FindMenuOption(nPosition,iPosition);
784 if(pMenu){
785 return(pMenu->InsertODMenuW(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,il,xoffset));
786 }
787 else return(FALSE);
788 }
789
790 if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
791 else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
792
793 if(nFlags & MF_POPUP){
794 m_AllSubMenus.Add((HMENU)nID);
795 m_SubMenus.InsertAt(nPosition,(HMENU)nID);
796 }
797
798 BCMenuData *mdata = new BCMenuData;
799 m_MenuList.InsertAt(nPosition,mdata);
800 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
801
802 if(il){
803 mdata->menuIconNormal = 0;
804 mdata->xoffset=0;
805 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
806 else mdata->bitmap=new(CImageList);
807 ImageListDuplicate(il,xoffset,mdata->bitmap);
808 }
809 else{
810 mdata->menuIconNormal = -1;
811 mdata->xoffset = -1;
812 }
813 mdata->nFlags = nFlags;
814 mdata->nID = nID;
815 return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
816 }
817
818 BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,int nIconNormal)
819 {
820 USES_CONVERSION;
821 return ModifyODMenuW(A2W(lpstrText),nID,nIconNormal);//SK: see MFC Tech Note 059
822 }
823
824 BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,int nIconNormal)
825 {
826 int nLoc;
827 BCMenuData *mdata;
828
829 // Find the old BCMenuData structure:
830 BCMenu *psubmenu = FindMenuOption(nID,nLoc);
831 if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
832 else{
833 // Create a new BCMenuData structure:
834 mdata = new BCMenuData;
835 m_MenuList.Add(mdata);
836 }
837
838 ASSERT(mdata);
839 if(lpstrText)
840 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
841 mdata->menuIconNormal = nIconNormal;
842 mdata->xoffset=-1;
843 if(nIconNormal>=0){
844 mdata->xoffset=0;
845 LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
846 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
847 else mdata->bitmap=new CImageList;
848 mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
849 if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
850 mdata->bitmap->DeleteImageList();
851 delete mdata->bitmap;
852 mdata->bitmap=NULL;
853 mdata->menuIconNormal = nIconNormal = -1;
854 mdata->xoffset = -1;
855 }
856 }
857 mdata->nFlags = MF_BYCOMMAND | MF_OWNERDRAW;
858 mdata->nID = nID;
859 return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
860 }
861
862 BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,CImageList *il,int xoffset)
863 {
864 USES_CONVERSION;
865 return ModifyODMenuW(A2W(lpstrText),nID,il,xoffset);
866 }
867
868 BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,CImageList *il,int xoffset)
869 {
870 int nLoc;
871 BCMenuData *mdata;
872
873 // Find the old BCMenuData structure:
874 BCMenu *psubmenu = FindMenuOption(nID,nLoc);
875 if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
876 else{
877 // Create a new BCMenuData structure:
878 mdata = new BCMenuData;
879 m_MenuList.Add(mdata);
880 }
881
882 ASSERT(mdata);
883 if(lpstrText)
884 mdata->SetWideString(lpstrText); //SK: modified for dynamic allocation
885 if(il){
886 mdata->menuIconNormal = 0;
887 mdata->xoffset=0;
888 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
889 else mdata->bitmap=new(CImageList);
890 ImageListDuplicate(il,xoffset,mdata->bitmap);
891 }
892 else{
893 mdata->menuIconNormal = -1;
894 mdata->xoffset = -1;
895 }
896 mdata->nFlags = MF_BYCOMMAND | MF_OWNERDRAW;
897 mdata->nID = nID;
898 return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
899 }
900
901 BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,CBitmap *bmp)
902 {
903 USES_CONVERSION;
904 return ModifyODMenuW(A2W(lpstrText),nID,bmp);
905 }
906
907 BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,CBitmap *bmp)
908 {
909 if(bmp){
910 CImageList temp;
911 temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
912 if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
913 else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
914 return ModifyODMenuW(lpstrText,nID,&temp,0);
915 }
916 return ModifyODMenuW(lpstrText,nID,NULL,0);
917 }
918
919
920 BOOL BCMenu::ModifyODMenuA(const char *lpstrText,const char *OptionText,
921 int nIconNormal)
922 {
923 USES_CONVERSION;
924 return ModifyODMenuW(A2W(lpstrText),A2W(OptionText),nIconNormal);//SK: see MFC Tech Note 059
925 }
926
927 BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,wchar_t *OptionText,
928 int nIconNormal)
929 {
930 BCMenuData *mdata;
931
932 // Find the old BCMenuData structure:
933 CString junk=OptionText;
934 mdata=FindMenuOption(OptionText);
935 if(mdata){
936 if(lpstrText)
937 mdata->SetWideString(lpstrText);//SK: modified for dynamic allocation
938 mdata->menuIconNormal = nIconNormal;
939 mdata->xoffset=-1;
940 if(nIconNormal>=0){
941 mdata->xoffset=0;
942 if(mdata->bitmap)mdata->bitmap->DeleteImageList();
943 else mdata->bitmap=new(CImageList);
944 mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
945 if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
946 mdata->bitmap->DeleteImageList();
947 delete mdata->bitmap;
948 mdata->bitmap=NULL;
949 mdata->menuIconNormal = nIconNormal = -1;
950 mdata->xoffset = -1;
951 }
952 }
953 return(TRUE);
954 }
955 return(FALSE);
956 }
957
958 BCMenuData *BCMenu::NewODMenu(UINT pos,UINT nFlags,UINT nID,CString string)
959 {
960 BCMenuData *mdata;
961
962 mdata = new BCMenuData;
963 mdata->menuIconNormal = -1;
964 mdata->xoffset=-1;
965 #ifdef UNICODE
966 mdata->SetWideString((LPCTSTR)string);//SK: modified for dynamic allocation
967 #else
968 mdata->SetAnsiString(string);
969 #endif
970 mdata->nFlags = nFlags;
971 mdata->nID = nID;
972
973 if(nFlags & MF_POPUP)m_AllSubMenus.Add((HMENU)nID);
974
975 if (nFlags&MF_OWNERDRAW){
976 ASSERT(!(nFlags&MF_STRING));
977 ModifyMenu(pos,nFlags,nID,(LPCTSTR)mdata);
978 }
979 else if (nFlags&MF_STRING){
980 ASSERT(!(nFlags&MF_OWNERDRAW));
981 ModifyMenu(pos,nFlags,nID,mdata->GetString());
982 }
983 else{
984 ASSERT(nFlags&MF_SEPARATOR);
985 ModifyMenu(pos,nFlags,nID);
986 }
987
988 return(mdata);
989 };
990
991 BOOL BCMenu::LoadToolbars(const UINT *arID,int n)
992 {
993 ASSERT(arID);
994 BOOL returnflag=TRUE;
995 for(int i=0;i<n;++i){
996 if(!LoadToolbar(arID[i]))returnflag=FALSE;
997 }
998 return(returnflag);
999 }
1000
1001 BOOL BCMenu::LoadToolbar(UINT nToolBar)
1002 {
1003 UINT nID;
1004 BOOL returnflag=FALSE;
1005 CToolBar bar;
1006
1007 bar.Create(AfxGetMainWnd());
1008 if(bar.LoadToolBar(nToolBar)){
1009 for(int i=0;i<bar.GetCount();++i){
1010 nID = bar.GetItemID(i);
1011 if(nID && GetMenuState(nID, MF_BYCOMMAND)
1012 !=0xFFFFFFFF){
1013 ModifyODMenu(NULL,nID,nToolBar);
1014 }
1015 }
1016 returnflag=TRUE;
1017 }
1018 return(returnflag);
1019 }
1020
1021 BOOL BCMenu::LoadFromToolBar(UINT nID,UINT nToolBar,int& xoffset)
1022 {
1023 int xset,offset;
1024 UINT nStyle;
1025 BOOL returnflag=FALSE;
1026 CToolBar bar;
1027
1028 bar.Create(AfxGetMainWnd());
1029 if(bar.LoadToolBar(nToolBar)){
1030 offset=bar.CommandToIndex(nID);
1031 if(offset>=0){
1032 bar.GetButtonInfo(offset,nID,nStyle,xset);
1033 if(xset>0)xoffset=xset;
1034 returnflag=TRUE;
1035 }
1036 }
1037 return(returnflag);
1038 }
1039
1040 // O.S.
1041 BCMenuData *BCMenu::FindMenuItem(UINT nID)
1042 {
1043 BCMenuData *pData = NULL;
1044 int i;
1045
1046 for(i = 0; i <= m_MenuList.GetUpperBound(); i++){
1047 if (m_MenuList[i]->nID == nID){
1048 pData = m_MenuList[i];
1049 break;
1050 }
1051 }
1052 if (!pData){
1053 int loc;
1054 BCMenu *pMenu = FindMenuOption(nID, loc);
1055 ASSERT(pMenu != this);
1056 if (loc >= 0){
1057 return pMenu->FindMenuItem(nID);
1058 }
1059 }
1060 return pData;
1061 }
1062
1063 BCMenu *BCMenu::FindMenuOption(int nId,int& nLoc)
1064 {
1065 int i;
1066 BCMenu *psubmenu,*pgoodmenu;
1067
1068 for(i=0;i<(int)(GetMenuItemCount());++i){
1069 #ifdef _CPPRTTI
1070 psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
1071 #else
1072 psubmenu=(BCMenu *)GetSubMenu(i);
1073 #endif
1074 if(psubmenu){
1075 pgoodmenu=psubmenu->FindMenuOption(nId,nLoc);
1076 if(pgoodmenu)return(pgoodmenu);
1077 }
1078 else if(nId==(int)GetMenuItemID(i)){
1079 nLoc=i;
1080 return(this);
1081 }
1082 }
1083 nLoc = -1;
1084 return(NULL);
1085 }
1086
1087 BCMenuData *BCMenu::FindMenuOption(wchar_t *lpstrText)
1088 {
1089 int i,j;
1090 BCMenu *psubmenu;
1091 BCMenuData *pmenulist;
1092
1093 for(i=0;i<(int)(GetMenuItemCount());++i){
1094 #ifdef _CPPRTTI
1095 psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
1096 #else
1097 psubmenu=(BCMenu *)GetSubMenu(i);
1098 #endif
1099 if(psubmenu){
1100 pmenulist=psubmenu->FindMenuOption(lpstrText);
1101 if(pmenulist)return(pmenulist);
1102 }
1103 else{
1104 const wchar_t *szWide;//SK: we use const to prevent misuse of this Ptr
1105 for(j=0;j<=m_MenuList.GetUpperBound();++j){
1106 szWide = m_MenuList[j]->GetWideString ();
1107 if(szWide && !wcscmp(lpstrText,szWide))//SK: modified for dynamic allocation
1108 return(m_MenuList[j]);
1109 }
1110 }
1111 }
1112 return(NULL);
1113 }
1114
1115
1116 BOOL BCMenu::LoadMenu(int nResource)
1117 {
1118 return(BCMenu::LoadMenu(MAKEINTRESOURCE(nResource)));
1119 };
1120
1121 BOOL BCMenu::LoadMenu(LPCTSTR lpszResourceName)
1122 {
1123 TRACE(_T(
1124 "IMPORTANT:Use BCMenu::DestroyMenu to destroy Loaded Menu's\n"));
1125 ASSERT_VALID(this);
1126 ASSERT(lpszResourceName != NULL);
1127
1128 // Find the Menu Resource:
1129 HINSTANCE m_hInst = AfxFindResourceHandle(lpszResourceName,RT_MENU);
1130 HRSRC hRsrc = ::FindResource(m_hInst,lpszResourceName,RT_MENU);
1131 if(hRsrc == NULL)return FALSE;
1132
1133 // Load the Menu Resource:
1134
1135 HGLOBAL hGlobal = LoadResource(m_hInst, hRsrc);
1136 if(hGlobal == NULL)return FALSE;
1137
1138 // Attempt to create us as a menu...
1139
1140 if(!CMenu::CreateMenu())return FALSE;
1141
1142 // Get Item template Header, and calculate offset of MENUITEMTEMPLATES
1143
1144 MENUITEMTEMPLATEHEADER *pTpHdr=
1145 (MENUITEMTEMPLATEHEADER*)LockResource(hGlobal);
1146 BYTE* pTp=(BYTE*)pTpHdr +
1147 (sizeof(MENUITEMTEMPLATEHEADER) + pTpHdr->offset);
1148
1149
1150 // Variables needed during processing of Menu Item Templates:
1151
1152 int j=0;
1153 WORD dwFlags = 0; // Flags of the Menu Item
1154 WORD dwID = 0; // ID of the Menu Item
1155 UINT uFlags; // Actual Flags.
1156 wchar_t *szCaption=NULL;
1157 int nLen = 0; // Length of caption
1158 CTypedPtrArray<CPtrArray, BCMenu*> m_Stack; // Popup menu stack
1159 CArray<BOOL,BOOL> m_StackEnd; // Popup menu stack
1160 m_Stack.Add(this); // Add it to this...
1161 m_StackEnd.Add(FALSE);
1162
1163 do{
1164 // Obtain Flags and (if necessary), the ID...
1165 memcpy(&dwFlags, pTp, sizeof(WORD));pTp+=sizeof(WORD);// Obtain Flags
1166 if(!(dwFlags & MF_POPUP)){
1167 memcpy(&dwID, pTp, sizeof(WORD)); // Obtain ID
1168 pTp+=sizeof(WORD);
1169 }
1170 else dwID = 0;
1171
1172 uFlags = (UINT)dwFlags; // Remove MF_END from the flags that will
1173 if(uFlags & MF_END) // be passed to the Append(OD)Menu functions.
1174 uFlags -= MF_END;
1175
1176 // Obtain Caption (and length)
1177
1178 nLen = 0;
1179 szCaption=new wchar_t[wcslen((wchar_t *)pTp)+1];
1180 wcscpy(szCaption,(wchar_t *)pTp);
1181 pTp=&pTp[(wcslen((wchar_t *)pTp)+1)*sizeof(wchar_t)];//modified SK
1182
1183 // Handle popup menus first....
1184
1185 //WideCharToMultiByte
1186 if(dwFlags & MF_POPUP){
1187 if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
1188 BCMenu* pSubMenu = new BCMenu;
1189 pSubMenu->m_unselectcheck=m_unselectcheck;
1190 pSubMenu->m_selectcheck=m_selectcheck;
1191 pSubMenu->checkmaps=checkmaps;
1192 pSubMenu->checkmapsshare=TRUE;
1193 pSubMenu->CreatePopupMenu();
1194
1195 // Append it to the top of the stack:
1196
1197 m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption,uFlags,
1198 (UINT)pSubMenu->m_hMenu, -1);
1199 m_Stack.Add(pSubMenu);
1200 m_StackEnd.Add(FALSE);
1201 }
1202 else {
1203 m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption, uFlags,
1204 dwID, -1);
1205 if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
1206 j = m_Stack.GetUpperBound();
1207 while(j>=0 && m_StackEnd.GetAt(j)){
1208 m_Stack[m_Stack.GetUpperBound()]->InsertSpaces();
1209 m_Stack.RemoveAt(j);
1210 m_StackEnd.RemoveAt(j);
1211 --j;
1212 }
1213 }
1214
1215 delete[] szCaption;
1216 }while(m_Stack.GetUpperBound() != -1);
1217
1218 for(int i=0;i<(int)GetMenuItemCount();++i){
1219 CString str=m_MenuList[i]->GetString();
1220
1221 if(GetSubMenu(i)){
1222 m_MenuList[i]->nFlags=MF_POPUP|MF_BYPOSITION;
1223 ModifyMenu(i,MF_POPUP|MF_BYPOSITION,
1224 (UINT)GetSubMenu(i)->m_hMenu,str);
1225 }
1226 else{
1227 m_MenuList[i]->nFlags=MF_STRING|MF_BYPOSITION;
1228 ModifyMenu(i,MF_STRING|MF_BYPOSITION,m_MenuList[i]->nID,str);
1229 }
1230 }
1231
1232 return(TRUE);
1233 }
1234
1235 void BCMenu::InsertSpaces(void)
1236 {
1237 int i,j,numitems,maxlength;
1238 CString string,newstring;
1239 CSize t;
1240 CFont m_fontMenu;
1241 LOGFONT m_lf;
1242
1243 ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
1244 NONCLIENTMETRICS nm;
1245 nm.cbSize = sizeof (NONCLIENTMETRICS);
1246 VERIFY (SystemParametersInfo (SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0));
1247 m_lf = nm.lfMenuFont;
1248 m_fontMenu.CreateFontIndirect (&m_lf);
1249
1250 CWnd *pWnd = AfxGetMainWnd();
1251 CDC *pDC = pWnd->GetDC();
1252 CFont* pFont = pDC->SelectObject (&m_fontMenu);
1253
1254 numitems=GetMenuItemCount();
1255 maxlength = -1;
1256 for(i=0;i<numitems;++i){
1257 string=m_MenuList[i]->GetString();
1258 j=string.Find((char)9);
1259 newstring.Empty();
1260 if(j!=-1)newstring=string.Left(j);
1261 else newstring=string;
1262 newstring+=_T(" ");//SK: modified for Unicode correctness.
1263 LPCTSTR lpstrText = (LPCTSTR)newstring;
1264 t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
1265 if(t.cx>maxlength)maxlength = t.cx;
1266 }
1267 for(i=0;i<numitems;++i){
1268 string=m_MenuList[i]->GetString();
1269 j=string.Find((char)9);
1270 if(j!=-1){
1271 newstring.Empty();
1272 newstring=string.Left(j);
1273 LPCTSTR lpstrText = (LPCTSTR)(newstring);
1274 t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
1275 while(t.cx<maxlength){
1276 newstring+=_T(' ');//SK: modified for Unicode correctness
1277 LPCTSTR lpstrText = (LPCTSTR)(newstring);
1278 t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
1279 }
1280 newstring+=string.Mid(j);
1281 #ifdef UNICODE
1282 m_MenuList[i]->SetWideString(newstring);//SK: modified for dynamic allocation
1283 #else
1284 m_MenuList[i]->SetAnsiString(newstring);
1285 #endif
1286 }
1287 }
1288 pDC->SelectObject (pFont); // Select old font in
1289 AfxGetMainWnd()->ReleaseDC(pDC); // Release the DC
1290 m_fontMenu.DeleteObject();
1291 }
1292
1293 void BCMenu::LoadCheckmarkBitmap(int unselect, int select)
1294 {
1295 if(unselect>0 && select>0){
1296 m_selectcheck=select;
1297 m_unselectcheck=unselect;
1298 if(checkmaps)checkmaps->DeleteImageList();
1299 else checkmaps=new(CImageList);
1300 checkmaps->Create(m_iconX,m_iconY,ILC_MASK,2,1);
1301 BOOL flag1=AddBitmapToImageList(checkmaps,unselect);
1302 BOOL flag2=AddBitmapToImageList(checkmaps,select);
1303 if(!flag1||!flag2){
1304 checkmaps->DeleteImageList();
1305 delete checkmaps;
1306 checkmaps=NULL;
1307 }
1308 }
1309 }
1310
1311 //--------------------------------------------------------------------------
1312 //[18.06.99 rj]
1313 BOOL BCMenu::GetMenuText(UINT id, CString& string, UINT nFlags/*= MF_BYPOSITION*/)
1314 {
1315 BOOL returnflag=FALSE;
1316
1317 if(MF_BYPOSITION&nFlags){
1318 UINT numMenuItems = m_MenuList.GetUpperBound();
1319 if(id<=numMenuItems){
1320 string=m_MenuList[id]->GetString();
1321 returnflag=TRUE;
1322 }
1323 }
1324 else{
1325 int uiLoc;
1326 BCMenu* pMenu = FindMenuOption(id,uiLoc);
1327 if(NULL!=pMenu) returnflag = pMenu->GetMenuText(uiLoc,string);
1328 }
1329 return(returnflag);
1330 }
1331
1332
1333 void BCMenu::DrawRadioDot(CDC *pDC,int x,int y,COLORREF color)
1334 {
1335 CRect rcDot(x,y,x+6,y+6);
1336 CBrush brush;
1337 CPen pen;
1338 brush.CreateSolidBrush(color);
1339 pen.CreatePen(PS_SOLID,0,color);
1340 CBrush *pOldBrush=pDC->SelectObject(&brush);
1341 CPen *pOldPen=pDC->SelectObject(&pen);
1342 pDC->Ellipse(&rcDot);
1343 pDC->SelectObject(pOldBrush);
1344 pDC->SelectObject(pOldPen);
1345 pen.DeleteObject();
1346 brush.DeleteObject();
1347 }
1348
1349 void BCMenu::DrawCheckMark(CDC* pDC,int x,int y,COLORREF color)
1350 {
1351 pDC->SetPixel(x,y+2,color);
1352 pDC->SetPixel(x,y+3,color);
1353 pDC->SetPixel(x,y+4,color);
1354
1355 pDC->SetPixel(x+1,y+3,color);
1356 pDC->SetPixel(x+1,y+4,color);
1357 pDC->SetPixel(x+1,y+5,color);
1358
1359 pDC->SetPixel(x+2,y+4,color);
1360 pDC->SetPixel(x+2,y+5,color);
1361 pDC->SetPixel(x+2,y+6,color);
1362
1363 pDC->SetPixel(x+3,y+3,color);
1364 pDC->SetPixel(x+3,y+4,color);
1365 pDC->SetPixel(x+3,y+5,color);
1366
1367 pDC->SetPixel(x+4,y+2,color);
1368 pDC->SetPixel(x+4,y+3,color);
1369 pDC->SetPixel(x+4,y+4,color);
1370
1371 pDC->SetPixel(x+5,y+1,color);
1372 pDC->SetPixel(x+5,y+2,color);
1373 pDC->SetPixel(x+5,y+3,color);
1374
1375 pDC->SetPixel(x+6,y,color);
1376 pDC->SetPixel(x+6,y+1,color);
1377 pDC->SetPixel(x+6,y+2,color);
1378 }
1379
1380 BCMenuData *BCMenu::FindMenuList(UINT nID)
1381 {
1382 for(int i=0;i<=m_MenuList.GetUpperBound();++i){
1383 if(m_MenuList[i]->nID==nID && !m_MenuList[i]->syncflag){
1384 m_MenuList[i]->syncflag=1;
1385 return(m_MenuList[i]);
1386 }
1387 }
1388 return(NULL);
1389 }
1390
1391 void BCMenu::InitializeMenuList(int value)
1392 {
1393 for(int i=0;i<=m_MenuList.GetUpperBound();++i)
1394 m_MenuList[i]->syncflag=value;
1395 }
1396
1397 void BCMenu::DeleteMenuList(void)
1398 {
1399 for(int i=0;i<=m_MenuList.GetUpperBound();++i){
1400 if(!m_MenuList[i]->syncflag){
1401 delete m_MenuList[i];
1402 }
1403 }
1404 }
1405
1406 void BCMenu::SynchronizeMenu(void)
1407 {
1408 CTypedPtrArray<CPtrArray, BCMenuData*> temp;
1409 BCMenuData *mdata;
1410 CString string;
1411 UINT submenu,nID=0,state,j;
1412
1413 InitializeMenuList(0);
1414 for(j=0;j<GetMenuItemCount();++j){
1415 mdata=NULL;
1416 state=GetMenuState(j,MF_BYPOSITION);
1417 if(state&MF_POPUP){
1418 submenu=(UINT)GetSubMenu(j)->m_hMenu;
1419 mdata=FindMenuList(submenu);
1420 GetMenuString(j,string,MF_BYPOSITION);
1421 if(!mdata)mdata=NewODMenu(j,
1422 (state&0xFF)|MF_BYPOSITION|MF_POPUP|MF_OWNERDRAW,submenu,string);
1423 else if(string.GetLength()>0)
1424 #ifdef UNICODE
1425 mdata->SetWideString(string); //SK: modified for dynamic allocation
1426 #else
1427 mdata->SetAnsiString(string);
1428 #endif
1429 }
1430 else if(state&MF_SEPARATOR){
1431 mdata=FindMenuList(0);
1432 if(!mdata)mdata=NewODMenu(j,
1433 state|MF_BYPOSITION|MF_SEPARATOR|MF_OWNERDRAW,0,_T(""));//SK: modified for Unicode correctness
1434 else ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
1435 }
1436 else{
1437 nID=GetMenuItemID(j);
1438 mdata=FindMenuList(nID);
1439 GetMenuString(j,string,MF_BYPOSITION);
1440 if(!mdata)mdata=NewODMenu(j,state|MF_BYPOSITION|MF_OWNERDRAW,
1441 nID,string);
1442 else{
1443 mdata->nFlags=state|MF_BYPOSITION|MF_OWNERDRAW;
1444 if(string.GetLength()>0)
1445 #ifdef UNICODE
1446 mdata->SetWideString(string);//SK: modified for dynamic allocation
1447 #else
1448 mdata->SetAnsiString(string);
1449 #endif
1450
1451 ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
1452 }
1453 }
1454 if(mdata)temp.Add(mdata);
1455 }
1456 DeleteMenuList();
1457 m_MenuList.RemoveAll();
1458 m_MenuList.Append(temp);
1459 temp.RemoveAll();
1460 }
1461
1462 void BCMenu::UpdateMenu(CMenu *pmenu)
1463 {
1464 #ifdef _CPPRTTI
1465 BCMenu *psubmenu = dynamic_cast<BCMenu *>(pmenu);
1466 #else
1467 BCMenu *psubmenu = (BCMenu *)pmenu;
1468 #endif
1469 if(psubmenu)psubmenu->SynchronizeMenu();
1470 }
1471
1472 LRESULT BCMenu::FindKeyboardShortcut(UINT nChar, UINT nFlags,
1473 CMenu *pMenu)
1474 {
1475 #ifdef _CPPRTTI
1476 BCMenu *pBCMenu = dynamic_cast<BCMenu *>(pMenu);
1477 #else
1478 BCMenu *pBCMenu = (BCMenu *)pMenu;
1479 #endif
1480 if(pBCMenu && nFlags&MF_POPUP){
1481 CString key(_T('&'),2);//SK: modified for Unicode correctness
1482 key.SetAt(1,(TCHAR)nChar);
1483 key.MakeLower();
1484 CString menutext;
1485 int menusize = (int)pBCMenu->GetMenuItemCount();
1486 if(menusize!=(pBCMenu->m_MenuList.GetUpperBound()+1))
1487 pBCMenu->SynchronizeMenu();
1488 for(int i=0;i<menusize;++i){
1489 if(pBCMenu->GetMenuText(i,menutext)){
1490 menutext.MakeLower();
1491 if(menutext.Find(key)>=0)return(MAKELRESULT(i,2));
1492 }
1493 }
1494 }
1495 return(0);
1496 }
1497
1498 void BCMenu::DitherBlt (HDC hdcDest, int nXDest, int nYDest, int nWidth,
1499 int nHeight, HBITMAP hbm, int nXSrc, int nYSrc)
1500 {
1501 ASSERT(hdcDest && hbm);
1502 ASSERT(nWidth > 0 && nHeight > 0);
1503
1504 // Create a generic DC for all BitBlts
1505 HDC hDC = CreateCompatibleDC(hdcDest);
1506 ASSERT(hDC);
1507
1508 if (hDC)
1509 {
1510 // Create a DC for the monochrome DIB section
1511 HDC bwDC = CreateCompatibleDC(hDC);
1512 ASSERT(bwDC);
1513
1514 if (bwDC)
1515 {
1516 // Create the monochrome DIB section with a black and white palette
1517 struct {
1518 BITMAPINFOHEADER bmiHeader;
1519 RGBQUAD bmiColors[2];
1520 } RGBBWBITMAPINFO = {
1521
1522 { // a BITMAPINFOHEADER
1523 sizeof(BITMAPINFOHEADER), // biSize
1524 nWidth, // biWidth;
1525 nHeight, // biHeight;
1526 1, // biPlanes;
1527 1, // biBitCount
1528 BI_RGB, // biCompression;
1529 0, // biSizeImage;
1530 0, // biXPelsPerMeter;
1531 0, // biYPelsPerMeter;
1532 0, // biClrUsed;
1533 0 // biClrImportant;
1534 },
1535 {
1536 { 0x00, 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF, 0x00 }
1537 }
1538 };
1539 VOID *pbitsBW;
1540 HBITMAP hbmBW = CreateDIBSection(bwDC,
1541 (LPBITMAPINFO)&RGBBWBITMAPINFO, DIB_RGB_COLORS, &pbitsBW, NULL, 0);
1542 ASSERT(hbmBW);
1543
1544 if (hbmBW)
1545 {
1546 // Attach the monochrome DIB section and the bitmap to the DCs
1547 HBITMAP olddib = (HBITMAP)SelectObject(bwDC, hbmBW);
1548 HBITMAP hdcolddib = (HBITMAP)SelectObject(hDC, hbm);
1549
1550 // BitBlt the bitmap into the monochrome DIB section
1551 BitBlt(bwDC, 0, 0, nWidth, nHeight, hDC, nXSrc, nYSrc, SRCCOPY);
1552
1553 // Paint the destination rectangle in gray
1554 FillRect(hdcDest, CRect(nXDest, nYDest, nXDest + nWidth, nYDest +
1555 nHeight), GetSysColorBrush((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
1556 //SK: looks better on the old shell
1557 // BitBlt the black bits in the monochrome bitmap into COLOR_3DHILIGHT
1558 // bits in the destination DC
1559 // The magic ROP comes from the Charles Petzold's book
1560 HBRUSH hb = CreateSolidBrush(GetSysColor(COLOR_3DHILIGHT));
1561 HBRUSH oldBrush = (HBRUSH)SelectObject(hdcDest, hb);
1562 BitBlt(hdcDest,nXDest+1,nYDest+1,nWidth,nHeight,bwDC,0,0,0xB8074A);
1563
1564 // BitBlt the black bits in the monochrome bitmap into COLOR_3DSHADOW
1565 // bits in the destination DC
1566 hb = CreateSolidBrush(GetSysColor(COLOR_3DSHADOW));
1567 DeleteObject(SelectObject(hdcDest, hb));
1568 BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight,bwDC,0,0,0xB8074A);
1569 DeleteObject(SelectObject(hdcDest, oldBrush));
1570 VERIFY(DeleteObject(SelectObject(bwDC, olddib)));
1571 SelectObject(hDC, hdcolddib);
1572 }
1573
1574 VERIFY(DeleteDC(bwDC));
1575 }
1576
1577 VERIFY(DeleteDC(hDC));
1578 }
1579 }
1580
1581 BOOL BCMenu::AddBitmapToImageList(CImageList *bmplist,UINT nResourceID)
1582 {
1583 // O.S.
1584 if (m_bDynIcons){
1585 bmplist->Add((HICON)nResourceID);
1586 return TRUE;
1587 }
1588
1589 BOOL bReturn=TRUE;
1590
1591 HBITMAP hbmp=LoadSysColorBitmap(nResourceID);
1592 if(hbmp){
1593 CBitmap bmp;
1594 bmp.Attach(hbmp);
1595 if(m_bitmapBackgroundFlag) bmplist->Add(&bmp,m_bitmapBackground);
1596 else bmplist->Add(&bmp,GetSysColor(COLOR_3DFACE));
1597 bmp.Detach();
1598 DeleteObject(hbmp);
1599 bReturn=TRUE;
1600 }
1601 else bReturn = FALSE;
1602 return(bReturn);
1603 }
1604
1605 void BCMenu::SetBitmapBackground(COLORREF color)
1606 {
1607 m_bitmapBackground=color;
1608 m_bitmapBackgroundFlag=TRUE;
1609 }
1610
1611 void BCMenu::UnSetBitmapBackground(void)
1612 {
1613 m_bitmapBackgroundFlag=FALSE;
1614 }
1615
1616 // Given a toolbar, append all the options from it to this menu
1617 // Passed a ptr to the toolbar object and the toolbar ID
1618 // Author : Robert Edward Caldecott
1619 void BCMenu::AddFromToolBar(CToolBar* pToolBar, int nResourceID)
1620 {
1621 for (int i = 0; i < pToolBar->GetCount(); i++) {
1622 UINT nID = pToolBar->GetItemID(i);
1623 // See if this toolbar option
1624 // appears as a command on this
1625 // menu or is a separator
1626 if (nID == 0 || GetMenuState(nID, MF_BYCOMMAND) == 0xFFFFFFFF)
1627 continue; // Item doesn't exist
1628 UINT nStyle;
1629 int nImage;
1630 // Get the toolbar button info
1631 pToolBar->GetButtonInfo(i, nID, nStyle, nImage);
1632 // OK, we have the command ID of the toolbar
1633 // option, and the tollbar bitmap offset
1634 int nLoc;
1635 BCMenuData* pData;
1636 BCMenu *pSubMenu = FindMenuOption(nID, nLoc);
1637 if (pSubMenu && nLoc >= 0)pData = pSubMenu->m_MenuList[nLoc];
1638 else {
1639 // Create a new BCMenuData structure
1640 pData = new BCMenuData;
1641 m_MenuList.Add(pData);
1642 }
1643 // Set some default structure members
1644 pData->menuIconNormal = nResourceID;
1645 pData->nID = nID;
1646 pData->nFlags = MF_BYCOMMAND | MF_OWNERDRAW;
1647 pData->xoffset = nImage;
1648 if (pData->bitmap)pData->bitmap->DeleteImageList();
1649 else pData->bitmap = new CImageList;
1650 pData->bitmap->Create(m_iconX, m_iconY,ILC_COLORDDB|ILC_MASK, 1, 1);
1651
1652 if(!AddBitmapToImageList(pData->bitmap, nResourceID)){
1653 pData->bitmap->DeleteImageList();
1654 delete pData->bitmap;
1655 pData->bitmap=NULL;
1656 pData->menuIconNormal = -1;
1657 pData->xoffset = -1;
1658 }
1659
1660 // Modify our menu
1661 ModifyMenu(nID,pData->nFlags,nID,(LPCTSTR)pData);
1662 }
1663 }
1664
1665 BOOL BCMenu::Draw3DCheckmark(CDC *dc, const CRect& rc,
1666 BOOL bSelected, HBITMAP hbmCheck)
1667 {
1668 CRect rcDest = rc;
1669 CBrush brush;
1670 COLORREF col=GetSysColor((bSelected||!IsNewShell())?COLOR_MENU:COLOR_3DLIGHT);//SK: Looks better on the old shell
1671 brush.CreateSolidBrush(col);
1672 dc->FillRect(rcDest,&brush);
1673 brush.DeleteObject();
1674 if (IsNewShell()) //SK: looks better on the old shell
1675 dc->DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
1676 if (!hbmCheck)DrawCheckMark(dc,rc.left+4,rc.top+4,GetSysColor(COLOR_MENUTEXT));
1677 else DrawRadioDot(dc,rc.left+5,rc.top+4,GetSysColor(COLOR_MENUTEXT));
1678 return TRUE;
1679 }
1680
1681 void BCMenu::DitherBlt2(CDC *drawdc, int nXDest, int nYDest, int nWidth,
1682 int nHeight, CBitmap &bmp, int nXSrc, int nYSrc)
1683 {
1684 // create a monochrome memory DC
1685 CDC ddc;
1686 ddc.CreateCompatibleDC(0);
1687 CBitmap bwbmp;
1688 bwbmp.CreateCompatibleBitmap(&ddc, nWidth, nHeight);
1689 CBitmap * pddcOldBmp = ddc.SelectObject(&bwbmp);
1690
1691 CDC dc;
1692 dc.CreateCompatibleDC(0);
1693 CBitmap * pdcOldBmp = dc.SelectObject(&bmp);
1694
1695 // build a mask
1696 ddc.PatBlt(0, 0, nWidth, nHeight, WHITENESS);
1697 dc.SetBkColor(GetSysColor(COLOR_BTNFACE));
1698 ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCCOPY);
1699 dc.SetBkColor(GetSysColor(COLOR_BTNHILIGHT));
1700 ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCPAINT);
1701
1702 // Copy the image from the toolbar into the memory DC
1703 // and draw it (grayed) back into the toolbar.
1704 dc.FillSolidRect(0,0, nWidth, nHeight, GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
1705 //SK: Looks better on the old shell
1706 dc.SetBkColor(RGB(0, 0, 0));
1707 dc.SetTextColor(RGB(255, 255, 255));
1708 CBrush brShadow, brHilight;
1709 brHilight.CreateSolidBrush(GetSysColor(COLOR_BTNHILIGHT));
1710 brShadow.CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
1711 CBrush * pOldBrush = dc.SelectObject(&brHilight);
1712 dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
1713 drawdc->BitBlt(nXDest+1,nYDest+1,nWidth, nHeight, &dc,0,0,SRCCOPY);
1714 dc.BitBlt(1,1, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
1715 dc.SelectObject(&brShadow);
1716 dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
1717 drawdc->BitBlt(nXDest,nYDest,nWidth, nHeight, &dc,0,0,SRCCOPY);
1718 // reset DCs
1719 ddc.SelectObject(pddcOldBmp);
1720 ddc.DeleteDC();
1721 dc.SelectObject(pOldBrush);
1722 dc.SelectObject(pdcOldBmp);
1723 dc.DeleteDC();
1724
1725 brShadow.DeleteObject();
1726 brHilight.DeleteObject();
1727 bwbmp.DeleteObject();
1728 }
1729
1730 void BCMenu::SetDisableOldStyle(void)
1731 {
1732 disable_old_style=TRUE;
1733 }
1734
1735 void BCMenu::UnSetDisableOldStyle(void)
1736 {
1737 disable_old_style=FALSE;
1738 }
1739
1740 BOOL BCMenu::GetDisableOldStyle(void)
1741 {
1742 return(disable_old_style);
1743 }
1744
1745
1746 HBITMAP BCMenu::LoadSysColorBitmap(int nResourceId)
1747 {
1748 HINSTANCE hInst =
1749 AfxFindResourceHandle(MAKEINTRESOURCE(nResourceId),RT_BITMAP);
1750 HRSRC hRsrc =
1751 ::FindResource(hInst,MAKEINTRESOURCE(nResourceId),RT_BITMAP);
1752 if (hRsrc == NULL)
1753 return NULL;
1754 return AfxLoadSysColorBitmap(hInst, hRsrc, FALSE);
1755 }
1756
1757 BOOL BCMenu::RemoveMenu(UINT uiId,UINT nFlags)
1758 {
1759 if(MF_BYPOSITION&nFlags){
1760 UINT uint = GetMenuState(uiId,MF_BYPOSITION);
1761 if(uint&MF_SEPARATOR && !(uint&MF_POPUP)){
1762 delete m_MenuList.GetAt(uiId);
1763 m_MenuList.RemoveAt(uiId);
1764 }
1765 else{
1766 BCMenu* pSubMenu = (BCMenu*) GetSubMenu(uiId);
1767 if(NULL==pSubMenu){
1768 UINT uiCommandId = GetMenuItemID(uiId);
1769 for(int i=0;i<m_MenuList.GetSize(); i++){
1770 if(m_MenuList[i]->nID==uiCommandId){
1771 delete m_MenuList.GetAt(i);
1772 m_MenuList.RemoveAt(i);
1773 break;
1774 }
1775 }
1776 }
1777 else{
1778 int numSubMenus = m_SubMenus.GetUpperBound();
1779 for(int m = numSubMenus; m >= 0; m--){
1780 if(m_SubMenus[m]==pSubMenu->m_hMenu){
1781 int numAllSubMenus = m_AllSubMenus.GetUpperBound();
1782 for(int n = numAllSubMenus; n>= 0; n--){
1783 if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
1784 }
1785 m_SubMenus.RemoveAt(m);
1786 }
1787 }
1788 int num = pSubMenu->GetMenuItemCount();
1789 for(int i=num-1;i>=0;--i)pSubMenu->RemoveMenu(i,MF_BYPOSITION);
1790 for(i=m_MenuList.GetUpperBound();i>=0;i--){
1791 if(m_MenuList[i]->nID==(UINT)pSubMenu->m_hMenu){
1792 delete m_MenuList.GetAt(i);
1793 m_MenuList.RemoveAt(i);
1794 break;
1795 }
1796 }
1797 delete pSubMenu;
1798 }
1799 }
1800 }
1801 else{
1802 int iPosition =0;
1803 BCMenu* pMenu = FindMenuOption(uiId,iPosition);
1804 if(pMenu)pMenu->RemoveMenu(iPosition,MF_BYPOSITION);
1805 }
1806 return CMenu::RemoveMenu(uiId,nFlags);
1807 }
1808
1809 BOOL BCMenu::DeleteMenu(UINT uiId,UINT nFlags)
1810 {
1811 if(MF_BYPOSITION&nFlags){
1812 UINT uint = GetMenuState(uiId,MF_BYPOSITION);
1813 if(uint&MF_SEPARATOR && !(uint&MF_POPUP)){
1814 delete m_MenuList.GetAt(uiId);
1815 m_MenuList.RemoveAt(uiId);
1816 }
1817 else{
1818 BCMenu* pSubMenu = (BCMenu*) GetSubMenu(uiId);
1819 if(NULL==pSubMenu){
1820 UINT uiCommandId = GetMenuItemID(uiId);
1821 for(int i=0;i<m_MenuList.GetSize(); i++){
1822 if(m_MenuList[i]->nID==uiCommandId){
1823 delete m_MenuList.GetAt(i);
1824 m_MenuList.RemoveAt(i);
1825 break;
1826 }
1827 }
1828 }
1829 else{
1830 int numSubMenus = m_SubMenus.GetUpperBound();
1831 for(int m = numSubMenus; m >= 0; m--){
1832 if(m_SubMenus[m]==pSubMenu->m_hMenu){
1833 int numAllSubMenus = m_AllSubMenus.GetUpperBound();
1834 for(int n = numAllSubMenus; n>= 0; n--){
1835 if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
1836 }
1837 m_SubMenus.RemoveAt(m);
1838 }
1839 }
1840 int num = pSubMenu->GetMenuItemCount();
1841 for(int i=num-1;i>=0;--i)pSubMenu->DeleteMenu(i,MF_BYPOSITION);
1842 for(i=m_MenuList.GetUpperBound();i>=0;i--){
1843 if(m_MenuList[i]->nID==(UINT)pSubMenu->m_hMenu){
1844 delete m_MenuList.GetAt(i);
1845 m_MenuList.RemoveAt(i);
1846 break;
1847 }
1848 }
1849 delete pSubMenu;
1850 }
1851 }
1852 }
1853 else{
1854 int iPosition =0;
1855 BCMenu* pMenu = FindMenuOption(uiId,iPosition);
1856 if(pMenu)pMenu->DeleteMenu(iPosition,MF_BYPOSITION);
1857 }
1858 return CMenu::DeleteMenu(uiId,nFlags);
1859 }
1860
1861
1862 BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,int nIconNormal)
1863 {
1864 USES_CONVERSION;
1865 return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),nIconNormal);
1866 }
1867
1868 BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,int nIconNormal)
1869 {
1870 return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,nIconNormal);
1871 }
1872
1873 BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CImageList *il,int xoffset)
1874 {
1875 USES_CONVERSION;
1876 return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),il,xoffset);
1877 }
1878
1879 BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CImageList *il,int xoffset)
1880 {
1881 return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,il,xoffset);
1882 }
1883
1884 BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CBitmap *bmp)
1885 {
1886 USES_CONVERSION;
1887 return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),bmp);
1888 }
1889
1890 BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CBitmap *bmp)
1891 {
1892 if(bmp){
1893 CImageList temp;
1894 temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
1895 if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
1896 else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
1897 return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,&temp,0);
1898 }
1899 return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,NULL,0);
1900 }
1901
1902 BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,int nIconNormal)
1903 {
1904 USES_CONVERSION;
1905 return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),nIconNormal);
1906 }
1907
1908 BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,int nIconNormal)
1909 {
1910 return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,nIconNormal);
1911 }
1912
1913 BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CImageList *il,int xoffset)
1914 {
1915 USES_CONVERSION;
1916 return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),il,xoffset);
1917 }
1918
1919 BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CImageList *il,int xoffset)
1920 {
1921 return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,il,xoffset);
1922 }
1923
1924 BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CBitmap *bmp)
1925 {
1926 USES_CONVERSION;
1927 return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),bmp);
1928 }
1929
1930 BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CBitmap *bmp)
1931 {
1932 if(bmp){
1933 CImageList temp;
1934 temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
1935 if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
1936 else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
1937 return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,&temp,0);
1938 }
1939 return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,NULL,0);
1940 }
1941
1942 //--------------------------------------------------------------------------
1943 //[21.06.99 rj]
1944 BCMenu* BCMenu::AppendODPopupMenuW(wchar_t *lpstrText)
1945 {
1946 BCMenu* pSubMenu = new BCMenu;
1947 pSubMenu->m_unselectcheck=m_unselectcheck;
1948 pSubMenu->m_selectcheck=m_selectcheck;
1949 pSubMenu->checkmaps=checkmaps;
1950 pSubMenu->checkmapsshare=TRUE;
1951 pSubMenu->CreatePopupMenu();
1952 AppendODMenuW(lpstrText,MF_POPUP,(UINT)pSubMenu->m_hMenu, -1);
1953 return pSubMenu;
1954 }
1955
1956 //--------------------------------------------------------------------------
1957 //[21.06.99 rj]
1958 BCMenu* BCMenu::AppendODPopupMenuA(LPCSTR lpstrText)
1959 {
1960 USES_CONVERSION;
1961 return AppendODPopupMenuW(A2W(lpstrText));
1962 }
1963
1964 BOOL BCMenu::ImageListDuplicate(CImageList *il,int xoffset,CImageList *newlist)
1965 {
1966 if (il == NULL||newlist==NULL||xoffset<0) return FALSE;
1967 HICON hIcon = il->ExtractIcon(xoffset);
1968 int cx, cy;
1969 ImageList_GetIconSize(il->m_hImageList, &cx, &cy);
1970 newlist->Create(cx,cy,ILC_COLOR32|ILC_MASK,1,1);
1971 newlist->Add(hIcon);
1972 ::DestroyIcon(hIcon);
1973 return TRUE;
1974 }
1975
1976 //*************************************************************************