xref: /aoo4110/main/vcl/source/window/menu.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26 
27 #include "tools/list.hxx"
28 #include "tools/debug.hxx"
29 #include "tools/diagnose_ex.h"
30 #include "tools/rc.h"
31 #include "tools/stream.hxx"
32 
33 #include "vcl/svapp.hxx"
34 #include "vcl/mnemonic.hxx"
35 #include "vcl/image.hxx"
36 #include "vcl/event.hxx"
37 #include "vcl/help.hxx"
38 #include "vcl/floatwin.hxx"
39 #include "vcl/wrkwin.hxx"
40 #include "vcl/timer.hxx"
41 #include "vcl/sound.hxx"
42 #include "vcl/decoview.hxx"
43 #include "vcl/bitmap.hxx"
44 #include "vcl/menu.hxx"
45 #include "vcl/button.hxx"
46 #include "vcl/gradient.hxx"
47 #include "vcl/i18nhelp.hxx"
48 #include "vcl/taskpanelist.hxx"
49 #include "vcl/controllayout.hxx"
50 #include "vcl/toolbox.hxx"
51 #include "vcl/dockingarea.hxx"
52 
53 #include "salinst.hxx"
54 #include "svdata.hxx"
55 #include "svids.hrc"
56 #include "window.h"
57 #include "salmenu.hxx"
58 #include "salframe.hxx"
59 
60 
61 #include <com/sun/star/uno/Reference.h>
62 #include <com/sun/star/i18n/XCharacterClassification.hpp>
63 #include <com/sun/star/lang/XComponent.hpp>
64 #include <com/sun/star/accessibility/XAccessible.hpp>
65 #include <com/sun/star/accessibility/AccessibleRole.hpp>
66 #include <vcl/unowrap.hxx>
67 
68 #include <vcl/unohelp.hxx>
69 #include <vcl/configsettings.hxx>
70 
71 #include "vcl/lazydelete.hxx"
72 
73 #include <map>
74 
75 namespace vcl
76 {
77 
78 struct MenuLayoutData : public ControlLayoutData
79 {
80     std::vector< sal_uInt16 >				m_aLineItemIds;
81     std::vector< sal_uInt16 >				m_aLineItemPositions;
82     std::map< sal_uInt16, Rectangle >		m_aVisibleItemBoundRects;
83 };
84 
85 }
86 
87 using namespace ::com::sun::star;
88 using namespace vcl;
89 
DBG_NAME(Menu)90 DBG_NAME( Menu )
91 
92 #define ITEMPOS_INVALID     0xFFFF
93 
94 #define EXTRASPACEY         2
95 #define EXTRAITEMHEIGHT     4
96 #define GUTTERBORDER        8
97 
98 // document closer
99 #define IID_DOCUMENTCLOSE 1
100 
101 #ifdef OS2
102 
103 #include "svsys.h"
104 #include "os2/salmenu.h"
105 
106 // return sal_True if hilite should be executed: left mouse button down
107 // or xwp mouse hook enabled
108 static sal_Bool ImplHilite( const MouseEvent& rMEvt )
109 {
110 	static sal_Bool init = sal_False;
111 	static HOOKCONFIG hc;
112 
113 	// read XWP settings at program startup
114 	if (init == sal_False) {
115 		sal_Bool	rc;
116 		sal_uLong 	cb = sizeof(HOOKCONFIG);
117 		memset(&hc, 0, sizeof(HOOKCONFIG));
118 		rc = PrfQueryProfileData( HINI_USER, INIAPP_XWPHOOK, INIKEY_HOOK_CONFIG,
119 			&hc, &cb);
120 		init = sal_True;
121 	}
122 	// check mouse left button
123 	if (rMEvt.GetButtons() == MOUSE_LEFT)
124 		return sal_True;
125 	// return xwp flag
126 	return hc.fSlidingMenus;
127 }
128 
129 #endif
130 
ImplAccelDisabled()131 static sal_Bool ImplAccelDisabled()
132 {
133     // display of accelerator strings may be suppressed via configuration
134     static int nAccelDisabled = -1;
135 
136     if( nAccelDisabled == -1 )
137     {
138         rtl::OUString aStr =
139             vcl::SettingsConfigItem::get()->
140             getValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Menu" ) ),
141                         rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SuppressAccelerators" ) ) );
142         nAccelDisabled = aStr.equalsIgnoreAsciiCaseAscii( "true" ) ? 1 : 0;
143     }
144     return (nAccelDisabled == 1) ? sal_True : sal_False;
145 }
146 
147 struct MenuItemData
148 {
149     sal_uInt16          nId;					// SV Id
150     MenuItemType    eType;					// MenuItem-Type
151     MenuItemBits    nBits;					// MenuItem-Bits
152     Menu*           pSubMenu;				// Pointer auf das SubMenu
153     Menu*           pAutoSubMenu;			// Pointer auf SubMenu aus Resource
154     XubString       aText;					// Menu-Text
155     XubString       aHelpText;				// Help-String
156     XubString       aTipHelpText;			// TipHelp-String (eg, expanded filenames)
157     XubString       aCommandStr;			// CommandString
158     XubString       aHelpCommandStr;        // Help command string (to reference external help)
159     rtl::OString    aHelpId;				// Help-Id
160     sal_uLong           nUserValue;				// User value
161     Image           aImage;					// Image
162     KeyCode         aAccelKey;				// Accelerator-Key
163     sal_Bool            bChecked;				// Checked
164     sal_Bool            bEnabled;				// Enabled
165     sal_Bool            bVisible;				// Visible (note: this flag will not override MENU_FLAG_HIDEDISABLEDENTRIES when true)
166     sal_Bool            bIsTemporary;			// Temporary inserted ('No selection possible')
167     sal_Bool			bMirrorMode;
168     long			nItemImageAngle;
169     Size            aSz;					// nur temporaer gueltig
170 	XubString		aAccessibleName;		// accessible name
171 	XubString		aAccessibleDescription;	// accessible description
172 
173     SalMenuItem*    pSalMenuItem;           // access to native menu
174 
MenuItemDataMenuItemData175                     MenuItemData() :
176                         pSalMenuItem ( NULL )
177                     {}
MenuItemDataMenuItemData178                     MenuItemData( const XubString& rStr, const Image& rImage ) :
179                         aText( rStr ),
180                         aImage( rImage ),
181                         pSalMenuItem ( NULL )
182                     {}
183                     ~MenuItemData();
HasCheckMenuItemData184 		bool HasCheck()
185 		{
186 			return bChecked || ( nBits & ( MIB_RADIOCHECK | MIB_CHECKABLE | MIB_AUTOCHECK ) );
187 		}
188 };
189 
~MenuItemData()190 MenuItemData::~MenuItemData()
191 {
192     if( pAutoSubMenu )
193     {
194         ((PopupMenu*)pAutoSubMenu)->pRefAutoSubMenu = NULL;
195         delete pAutoSubMenu;
196         pAutoSubMenu = NULL;
197     }
198     if( pSalMenuItem )
199         ImplGetSVData()->mpDefInst->DestroyMenuItem( pSalMenuItem );
200 }
201 
202 class MenuItemList : public List
203 {
204 private:
205     uno::Reference< i18n::XCharacterClassification > xCharClass;
206 
207 
208 public:
MenuItemList()209                     MenuItemList() : List( 16, 4 ) {}
210                     ~MenuItemList();
211 
212     MenuItemData*   Insert( sal_uInt16 nId, MenuItemType eType, MenuItemBits nBits,
213                             const XubString& rStr, const Image& rImage,
214                             Menu* pMenu, sal_uInt16 nPos );
215     void            InsertSeparator( sal_uInt16 nPos );
216     void            Remove( sal_uInt16 nPos );
217 
218 
219     MenuItemData*   GetData( sal_uInt16 nSVId, sal_uInt16& rPos ) const;
GetData(sal_uInt16 nSVId) const220     MenuItemData*   GetData( sal_uInt16 nSVId ) const
221                         { sal_uInt16 nTemp; return GetData( nSVId, nTemp ); }
GetDataFromPos(sal_uLong nPos) const222     MenuItemData*   GetDataFromPos( sal_uLong nPos ) const
223                         { return (MenuItemData*)List::GetObject( nPos ); }
224 
225     MenuItemData*   SearchItem( xub_Unicode cSelectChar, KeyCode aKeyCode, sal_uInt16& rPos, sal_uInt16& nDuplicates, sal_uInt16 nCurrentPos ) const;
226 	sal_uInt16			GetItemCount( xub_Unicode cSelectChar ) const;
227     sal_uInt16          GetItemCount( KeyCode aKeyCode ) const;
228 
229     uno::Reference< i18n::XCharacterClassification > GetCharClass() const;
230 };
231 
232 
233 
~MenuItemList()234 MenuItemList::~MenuItemList()
235 {
236     for ( sal_uLong n = Count(); n; )
237     {
238         MenuItemData* pData = GetDataFromPos( --n );
239         delete pData;
240     }
241 }
242 
Insert(sal_uInt16 nId,MenuItemType eType,MenuItemBits nBits,const XubString & rStr,const Image & rImage,Menu * pMenu,sal_uInt16 nPos)243 MenuItemData* MenuItemList::Insert( sal_uInt16 nId, MenuItemType eType,
244                                     MenuItemBits nBits,
245                                     const XubString& rStr, const Image& rImage,
246                                     Menu* pMenu, sal_uInt16 nPos )
247 {
248     MenuItemData* pData		= new MenuItemData( rStr, rImage );
249     pData->nId          	= nId;
250     pData->eType        	= eType;
251     pData->nBits        	= nBits;
252     pData->pSubMenu     	= NULL;
253     pData->pAutoSubMenu 	= NULL;
254     pData->nUserValue   	= 0;
255     pData->bChecked     	= sal_False;
256     pData->bEnabled     	= sal_True;
257     pData->bVisible     	= sal_True;
258     pData->bIsTemporary 	= sal_False;
259     pData->bMirrorMode		= sal_False;
260     pData->nItemImageAngle	= 0;
261 
262     SalItemParams aSalMIData;
263     aSalMIData.nId = nId;
264     aSalMIData.eType = eType;
265     aSalMIData.nBits = nBits;
266     aSalMIData.pMenu = pMenu;
267     aSalMIData.aText = rStr;
268     aSalMIData.aImage = rImage;
269 
270     // Native-support: returns NULL if not supported
271     pData->pSalMenuItem = ImplGetSVData()->mpDefInst->CreateMenuItem( &aSalMIData );
272 
273     List::Insert( (void*)pData, nPos );
274     return pData;
275 }
276 
InsertSeparator(sal_uInt16 nPos)277 void MenuItemList::InsertSeparator( sal_uInt16 nPos )
278 {
279     MenuItemData* pData		= new MenuItemData;
280     pData->nId          	= 0;
281     pData->eType        	= MENUITEM_SEPARATOR;
282     pData->nBits        	= 0;
283     pData->pSubMenu     	= NULL;
284     pData->pAutoSubMenu 	= NULL;
285     pData->nUserValue   	= 0;
286     pData->bChecked     	= sal_False;
287     pData->bEnabled     	= sal_True;
288     pData->bVisible     	= sal_True;
289     pData->bIsTemporary 	= sal_False;
290     pData->bMirrorMode		= sal_False;
291     pData->nItemImageAngle	= 0;
292 
293     SalItemParams aSalMIData;
294     aSalMIData.nId = 0;
295     aSalMIData.eType = MENUITEM_SEPARATOR;
296     aSalMIData.nBits = 0;
297     aSalMIData.pMenu = NULL;
298     aSalMIData.aText = XubString();
299     aSalMIData.aImage = Image();
300 
301     // Native-support: returns NULL if not supported
302     pData->pSalMenuItem = ImplGetSVData()->mpDefInst->CreateMenuItem( &aSalMIData );
303 
304     List::Insert( (void*)pData, nPos );
305 }
306 
Remove(sal_uInt16 nPos)307 void MenuItemList::Remove( sal_uInt16 nPos )
308 {
309     MenuItemData* pData = (MenuItemData*)List::Remove( (sal_uLong)nPos );
310     if ( pData )
311         delete pData;
312 }
313 
GetData(sal_uInt16 nSVId,sal_uInt16 & rPos) const314 MenuItemData* MenuItemList::GetData( sal_uInt16 nSVId, sal_uInt16& rPos ) const
315 {
316     rPos = 0;
317     MenuItemData* pData = (MenuItemData*)GetObject( rPos );
318     while ( pData )
319     {
320         if ( pData->nId == nSVId )
321             return pData;
322 
323         rPos++;
324         pData = (MenuItemData*)GetObject( rPos );
325     }
326 
327     return NULL;
328 }
329 
SearchItem(xub_Unicode cSelectChar,KeyCode aKeyCode,sal_uInt16 & rPos,sal_uInt16 & nDuplicates,sal_uInt16 nCurrentPos) const330 MenuItemData* MenuItemList::SearchItem( xub_Unicode cSelectChar, KeyCode aKeyCode, sal_uInt16& rPos, sal_uInt16& nDuplicates, sal_uInt16 nCurrentPos ) const
331 {
332     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
333 
334 	sal_uInt16 nListCount = (sal_uInt16)Count();
335 
336     // try character code first
337 	nDuplicates = GetItemCount( cSelectChar );	// return number of duplicates
338     if( nDuplicates )
339     {
340         for ( rPos = 0; rPos < nListCount; rPos++)
341         {
342             MenuItemData* pData = GetDataFromPos( rPos );
343             if ( pData->bEnabled && rI18nHelper.MatchMnemonic( pData->aText, cSelectChar ) )
344             {
345 			    if( nDuplicates > 1 && rPos == nCurrentPos )
346 				    continue;	// select next entry with the same mnemonic
347 			    else
348 				    return pData;
349             }
350         }
351     }
352 
353     // nothing found, try keycode instead
354 	nDuplicates = GetItemCount( aKeyCode );	// return number of duplicates
355 
356     if( nDuplicates )
357     {
358         char ascii = 0;
359         if( aKeyCode.GetCode() >= KEY_A && aKeyCode.GetCode() <= KEY_Z )
360             ascii = sal::static_int_cast<char>('A' + (aKeyCode.GetCode() - KEY_A));
361 
362         for ( rPos = 0; rPos < nListCount; rPos++)
363         {
364             MenuItemData* pData = GetDataFromPos( rPos );
365             if ( pData->bEnabled )
366             {
367                 sal_uInt16 n = pData->aText.Search( '~' );
368                 if ( n != STRING_NOTFOUND )
369                 {
370                     KeyCode mnKeyCode;
371                     xub_Unicode mnUnicode = pData->aText.GetChar(n+1);
372                     Window* pDefWindow = ImplGetDefaultWindow();
373                     if( (pDefWindow && pDefWindow->ImplGetFrame()->MapUnicodeToKeyCode( mnUnicode, Application::GetSettings().GetUILanguage(), mnKeyCode )
374                         && aKeyCode.GetCode() == mnKeyCode.GetCode())
375                         || (ascii && rI18nHelper.MatchMnemonic( pData->aText, ascii ) ) )
376 
377                     {
378 			            if( nDuplicates > 1 && rPos == nCurrentPos )
379 				            continue;	// select next entry with the same mnemonic
380 			            else
381 				            return pData;
382                     }
383                 }
384             }
385         }
386     }
387 
388     return NULL;
389 }
390 
GetItemCount(xub_Unicode cSelectChar) const391 sal_uInt16 MenuItemList::GetItemCount( xub_Unicode cSelectChar ) const
392 {
393 	// returns number of entries with same mnemonic
394     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
395 
396 	sal_uInt16 nItems = 0, nPos;
397     for ( nPos = (sal_uInt16)Count(); nPos; )
398     {
399         MenuItemData* pData = GetDataFromPos( --nPos );
400         if ( pData->bEnabled && rI18nHelper.MatchMnemonic( pData->aText, cSelectChar ) )
401             nItems++;
402     }
403 
404     return nItems;
405 }
406 
GetItemCount(KeyCode aKeyCode) const407 sal_uInt16 MenuItemList::GetItemCount( KeyCode aKeyCode ) const
408 {
409 	// returns number of entries with same mnemonic
410     // uses key codes instead of character codes
411     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
412     char ascii = 0;
413     if( aKeyCode.GetCode() >= KEY_A && aKeyCode.GetCode() <= KEY_Z )
414         ascii = sal::static_int_cast<char>('A' + (aKeyCode.GetCode() - KEY_A));
415 
416 	sal_uInt16 nItems = 0, nPos;
417     for ( nPos = (sal_uInt16)Count(); nPos; )
418     {
419         MenuItemData* pData = GetDataFromPos( --nPos );
420         if ( pData->bEnabled )
421         {
422             sal_uInt16 n = pData->aText.Search( '~' );
423             if ( n != STRING_NOTFOUND )
424             {
425                 KeyCode mnKeyCode;
426                 // if MapUnicodeToKeyCode fails or is unsupported we try the pure ascii mapping of the keycodes
427                 // so we have working shortcuts when ascii mnemonics are used
428                 Window* pDefWindow = ImplGetDefaultWindow();
429                 if( (pDefWindow && pDefWindow->ImplGetFrame()->MapUnicodeToKeyCode( pData->aText.GetChar(n+1), Application::GetSettings().GetUILanguage(), mnKeyCode )
430                     && aKeyCode.GetCode() == mnKeyCode.GetCode())
431                     || ( ascii && rI18nHelper.MatchMnemonic( pData->aText, ascii ) ) )
432                     nItems++;
433             }
434         }
435     }
436 
437     return nItems;
438 }
439 
GetCharClass() const440 uno::Reference< i18n::XCharacterClassification > MenuItemList::GetCharClass() const
441 {
442     if ( !xCharClass.is() )
443         ((MenuItemList*)this)->xCharClass = vcl::unohelper::CreateCharacterClassification();
444     return xCharClass;
445 }
446 
447 
448 
449 // ----------------------
450 // - MenuFloatingWindow -
451 // ----------------------
452 
453 class MenuFloatingWindow : public FloatingWindow
454 {
455     friend void Menu::ImplFillLayoutData() const;
456     friend Menu::~Menu();
457 
458 private:
459     Menu*           pMenu;
460     PopupMenu*      pActivePopup;
461     Timer           aHighlightChangedTimer;
462     Timer           aSubmenuCloseTimer;
463     Timer           aScrollTimer;
464     sal_uLong           nSaveFocusId;
465 //    long            nStartY;
466     sal_uInt16          nHighlightedItem;       // gehighlightetes/selektiertes Item
467     sal_uInt16          nMBDownPos;
468     sal_uInt16          nScrollerHeight;
469     sal_uInt16          nFirstEntry;
470     sal_uInt16          nBorder;
471     sal_uInt16          nPosInParent;
472     sal_Bool            bInExecute;
473 
474     sal_Bool            bScrollMenu;
475     sal_Bool            bScrollUp;
476     sal_Bool            bScrollDown;
477     sal_Bool            bIgnoreFirstMove;
478     sal_Bool            bKeyInput;
479 
480                     DECL_LINK( PopupEnd, FloatingWindow* );
481                     DECL_LINK( HighlightChanged, Timer* );
482                     DECL_LINK( SubmenuClose, Timer* );
483                     DECL_LINK( AutoScroll, Timer* );
484                     DECL_LINK( ShowHideListener, VclWindowEvent* );
485 
486     void            StateChanged( StateChangedType nType );
487     void            DataChanged( const DataChangedEvent& rDCEvt );
488 protected:
489     Region          ImplCalcClipRegion( sal_Bool bIncludeLogo = sal_True ) const;
490     void            ImplInitClipRegion();
491     void            ImplDrawScroller( sal_Bool bUp );
492     using Window::ImplScroll;
493     void            ImplScroll( const Point& rMousePos );
494     void            ImplScroll( sal_Bool bUp );
495     void            ImplCursorUpDown( sal_Bool bUp, sal_Bool bHomeEnd = sal_False );
496     void            ImplHighlightItem( const MouseEvent& rMEvt, sal_Bool bMBDown );
497     long            ImplGetStartY() const;
498 	Rectangle		ImplGetItemRect( sal_uInt16 nPos );
499 
500 public:
501                     MenuFloatingWindow( Menu* pMenu, Window* pParent, WinBits nStyle );
502                     ~MenuFloatingWindow();
503 
504             void    doShutdown();
505 
506     virtual void    MouseMove( const MouseEvent& rMEvt );
507     virtual void    MouseButtonDown( const MouseEvent& rMEvt );
508     virtual void    MouseButtonUp( const MouseEvent& rMEvt );
509     virtual void    KeyInput( const KeyEvent& rKEvent );
510     virtual void    Command( const CommandEvent& rCEvt );
511     virtual void    Paint( const Rectangle& rRect );
512     virtual void    RequestHelp( const HelpEvent& rHEvt );
513     virtual void    Resize();
514 
SetFocusId(sal_uLong nId)515     void            SetFocusId( sal_uLong nId ) { nSaveFocusId = nId; }
GetFocusId() const516     sal_uLong           GetFocusId() const      { return nSaveFocusId; }
517 
518     void            EnableScrollMenu( sal_Bool b );
IsScrollMenu() const519     sal_Bool            IsScrollMenu() const        { return bScrollMenu; }
GetScrollerHeight() const520     sal_uInt16          GetScrollerHeight() const   { return nScrollerHeight; }
521 
522     void            Execute();
523     void            StopExecute( sal_uLong nFocusId = 0 );
524     void            EndExecute();
525     void            EndExecute( sal_uInt16 nSelectId );
526 
GetActivePopup() const527     PopupMenu*      GetActivePopup() const  { return pActivePopup; }
528     void            KillActivePopup( PopupMenu* pThisOnly = NULL );
529 
530     void            HighlightItem( sal_uInt16 nPos, sal_Bool bHighlight );
531     void            ChangeHighlightItem( sal_uInt16 n, sal_Bool bStartPopupTimer );
GetHighlightedItem() const532     sal_uInt16          GetHighlightedItem() const { return nHighlightedItem; }
533 
SetPosInParent(sal_uInt16 nPos)534     void            SetPosInParent( sal_uInt16 nPos ) { nPosInParent = nPos; }
GetPosInParent() const535     sal_uInt16          GetPosInParent() const { return nPosInParent; }
536 
537     virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
538 };
539 
540 // To get the transparent mouse-over look, the closer is actually a toolbox
541 // overload DataChange to handle style changes correctly
542 class DecoToolBox : public ToolBox
543 {
544     long lastSize;
545     Size maMinSize;
546 
547     using Window::ImplInit;
548 public:
549             DecoToolBox( Window* pParent, WinBits nStyle = 0 );
550             DecoToolBox( Window* pParent, const ResId& rResId );
551     void    ImplInit();
552 
553     void    DataChanged( const DataChangedEvent& rDCEvt );
554 
555     void    SetImages( long nMaxHeight = 0, bool bForce = false );
556 
557     void    calcMinSize();
558     Size    getMinSize();
559 
560     Image   maImage;
561     Image   maImageHC;
562 };
563 
DecoToolBox(Window * pParent,WinBits nStyle)564 DecoToolBox::DecoToolBox( Window* pParent, WinBits nStyle ) :
565     ToolBox( pParent, nStyle )
566 {
567     ImplInit();
568 }
DecoToolBox(Window * pParent,const ResId & rResId)569 DecoToolBox::DecoToolBox( Window* pParent, const ResId& rResId ) :
570     ToolBox( pParent, rResId )
571 {
572     ImplInit();
573 }
574 
ImplInit()575 void DecoToolBox::ImplInit()
576 {
577     lastSize = -1;
578     calcMinSize();
579 }
580 
DataChanged(const DataChangedEvent & rDCEvt)581 void DecoToolBox::DataChanged( const DataChangedEvent& rDCEvt )
582 {
583     Window::DataChanged( rDCEvt );
584 
585     if ( rDCEvt.GetFlags() & SETTINGS_STYLE )
586     {
587         calcMinSize();
588         SetBackground();
589         SetImages( 0, true);
590     }
591 }
592 
calcMinSize()593 void DecoToolBox::calcMinSize()
594 {
595     ToolBox aTbx( GetParent() );
596     if( GetItemCount() == 0 )
597     {
598         ResMgr* pResMgr = ImplGetResMgr();
599 
600         Bitmap aBitmap;
601         if( pResMgr )
602             aBitmap = Bitmap( ResId( SV_RESID_BITMAP_CLOSEDOC, *pResMgr ) );
603         aTbx.InsertItem( IID_DOCUMENTCLOSE, Image( aBitmap ) );
604     }
605     else
606     {
607         sal_uInt16 nItems = GetItemCount();
608         for( sal_uInt16 i = 0; i < nItems; i++ )
609         {
610             sal_uInt16 nId = GetItemId( i );
611             aTbx.InsertItem( nId, GetItemImage( nId ) );
612         }
613     }
614     aTbx.SetOutStyle( TOOLBOX_STYLE_FLAT );
615     maMinSize = aTbx.CalcWindowSizePixel();
616 }
617 
getMinSize()618 Size DecoToolBox::getMinSize()
619 {
620     return maMinSize;
621 }
622 
SetImages(long nMaxHeight,bool bForce)623 void DecoToolBox::SetImages( long nMaxHeight, bool bForce )
624 {
625     long border = getMinSize().Height() - maImage.GetSizePixel().Height();
626 
627     if( !nMaxHeight && lastSize != -1 )
628         nMaxHeight = lastSize + border; // don't change anything if called with 0
629 
630     if( nMaxHeight < getMinSize().Height() )
631         nMaxHeight = getMinSize().Height();
632 
633     if( (lastSize != nMaxHeight - border) || bForce )
634     {
635         lastSize = nMaxHeight - border;
636 
637 		Color		aEraseColor( 255, 255, 255, 255 );
638         BitmapEx 	aBmpExDst( maImage.GetBitmapEx() );
639         BitmapEx 	aBmpExSrc( GetSettings().GetStyleSettings().GetHighContrastMode() ?
640             			  	maImageHC.GetBitmapEx() : aBmpExDst );
641 
642 		aEraseColor.SetTransparency( 255 );
643 		aBmpExDst.Erase( aEraseColor );
644         aBmpExDst.SetSizePixel( Size( lastSize, lastSize ) );
645 
646         Rectangle aSrcRect( Point(0,0), maImage.GetSizePixel() );
647         Rectangle aDestRect( Point((lastSize - maImage.GetSizePixel().Width())/2,
648 								(lastSize - maImage.GetSizePixel().Height())/2 ),
649 							maImage.GetSizePixel() );
650 
651 
652 		aBmpExDst.CopyPixel( aDestRect, aSrcRect, &aBmpExSrc );
653         SetItemImage( IID_DOCUMENTCLOSE, Image( aBmpExDst ) );
654     }
655 }
656 
657 
658 // Eine Basicklasse fuer beide (wegen pActivePopup, Timer, ...) waere nett,
659 // aber dann musste eine 'Container'-Klasse gemacht werden, da von
660 // unterschiedlichen Windows abgeleitet...
661 // In den meisten Funktionen muessen dann sowieso Sonderbehandlungen fuer
662 // MenuBar, PopupMenu gemacht werden, also doch zwei verschiedene Klassen.
663 
664 class MenuBarWindow : public Window
665 {
666     friend class MenuBar;
667     friend class Menu;
668 
669 private:
670     struct AddButtonEntry
671     {
672         sal_uInt16      m_nId;
673         Link        m_aSelectLink;
674         Link        m_aHighlightLink;
675 
AddButtonEntryMenuBarWindow::AddButtonEntry676         AddButtonEntry() : m_nId( 0 ) {}
677     };
678 
679     Menu*           pMenu;
680     PopupMenu*      pActivePopup;
681     sal_uInt16          nHighlightedItem;
682     sal_uLong           nSaveFocusId;
683     sal_Bool            mbAutoPopup;
684     sal_Bool            bIgnoreFirstMove;
685 	sal_Bool			bStayActive;
686 
687     DecoToolBox     aCloser;
688     PushButton      aFloatBtn;
689     PushButton      aHideBtn;
690 
691     std::map< sal_uInt16, AddButtonEntry > m_aAddButtons;
692 
693     void            HighlightItem( sal_uInt16 nPos, sal_Bool bHighlight );
694     void            ChangeHighlightItem( sal_uInt16 n, sal_Bool bSelectPopupEntry, sal_Bool bAllowRestoreFocus = sal_True, sal_Bool bDefaultToDocument = sal_True );
695 
696     sal_uInt16          ImplFindEntry( const Point& rMousePos ) const;
697     void            ImplCreatePopup( sal_Bool bPreSelectFirst );
698     sal_Bool            ImplHandleKeyEvent( const KeyEvent& rKEvent, sal_Bool bFromMenu = sal_True );
699 	Rectangle		ImplGetItemRect( sal_uInt16 nPos );
700 
701     void            ImplInitStyleSettings();
702 
703                     DECL_LINK( CloserHdl, PushButton* );
704                     DECL_LINK( FloatHdl, PushButton* );
705                     DECL_LINK( HideHdl, PushButton* );
706                     DECL_LINK( ToolboxEventHdl, VclWindowEvent* );
707                     DECL_LINK( ShowHideListener, VclWindowEvent* );
708 
709     void            StateChanged( StateChangedType nType );
710     void            DataChanged( const DataChangedEvent& rDCEvt );
711     void            LoseFocus();
712     void            GetFocus();
713 
714 public:
715                     MenuBarWindow( Window* pParent );
716                     ~MenuBarWindow();
717 
718     void            ShowButtons( sal_Bool bClose, sal_Bool bFloat, sal_Bool bHide );
719 
720     virtual void    MouseMove( const MouseEvent& rMEvt );
721     virtual void    MouseButtonDown( const MouseEvent& rMEvt );
722     virtual void    MouseButtonUp( const MouseEvent& rMEvt );
723     virtual void    KeyInput( const KeyEvent& rKEvent );
724     virtual void    Paint( const Rectangle& rRect );
725     virtual void    Resize();
726     virtual void    RequestHelp( const HelpEvent& rHEvt );
727 
SetFocusId(sal_uLong nId)728     void            SetFocusId( sal_uLong nId ) { nSaveFocusId = nId; }
GetFocusId() const729     sal_uLong           GetFocusId() const { return nSaveFocusId; }
730 
731     void            SetMenu( MenuBar* pMenu );
732     void            KillActivePopup();
GetActivePopup() const733     PopupMenu*      GetActivePopup() const  { return pActivePopup; }
734     void            PopupClosed( Menu* pMenu );
GetHighlightedItem() const735     sal_uInt16          GetHighlightedItem() const { return nHighlightedItem; }
736     virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
737 
SetAutoPopup(sal_Bool bAuto)738     void SetAutoPopup( sal_Bool bAuto ) { mbAutoPopup = bAuto; }
739     void            ImplLayoutChanged();
740     Size            MinCloseButtonSize();
741 
742     // add an arbitrary button to the menubar (will appear next to closer)
743     sal_uInt16              AddMenuBarButton( const Image&, const Link&, const String&, sal_uInt16 nPos );
744     void                SetMenuBarButtonHighlightHdl( sal_uInt16 nId, const Link& );
745     Rectangle           GetMenuBarButtonRectPixel( sal_uInt16 nId );
746     void                RemoveMenuBarButton( sal_uInt16 nId );
747     bool                HandleMenuButtonEvent( sal_uInt16 i_nButtonId );
748 };
749 
ImplAddNWFSeparator(Window * pThis,const MenubarValue & rMenubarValue)750 static void ImplAddNWFSeparator( Window *pThis, const MenubarValue& rMenubarValue )
751 {
752     // add a separator if
753     // - we have an adjacent docking area
754     // - and if toolbars would draw them as well (mbDockingAreaSeparateTB must not be set, see dockingarea.cxx)
755     if( rMenubarValue.maTopDockingAreaHeight && !ImplGetSVData()->maNWFData.mbDockingAreaSeparateTB )
756     {
757         // note: the menubar only provides the upper (dark) half of it, the rest (bright part) is drawn by the docking area
758 
759         pThis->SetLineColor( pThis->GetSettings().GetStyleSettings().GetSeparatorColor() );
760         Point aPt;
761         Rectangle aRect( aPt, pThis->GetOutputSizePixel() );
762         pThis->DrawLine( aRect.BottomLeft(), aRect.BottomRight() );
763     }
764 }
765 
ImplSetMenuItemData(MenuItemData * pData)766 static void ImplSetMenuItemData( MenuItemData* pData )
767 {
768     // Daten umsetzen
769     if ( !pData->aImage )
770         pData->eType = MENUITEM_STRING;
771     else if ( !pData->aText.Len() )
772         pData->eType = MENUITEM_IMAGE;
773     else
774         pData->eType = MENUITEM_STRINGIMAGE;
775 }
776 
ImplChangeTipTimeout(sal_uLong nTimeout,Window * pWindow)777 static sal_uLong ImplChangeTipTimeout( sal_uLong nTimeout, Window *pWindow )
778 {
779        AllSettings aAllSettings( pWindow->GetSettings() );
780        HelpSettings aHelpSettings( aAllSettings.GetHelpSettings() );
781        sal_uLong nRet = aHelpSettings.GetTipTimeout();
782        aHelpSettings.SetTipTimeout( nTimeout );
783        aAllSettings.SetHelpSettings( aHelpSettings );
784        pWindow->SetSettings( aAllSettings );
785        return nRet;
786 }
787 
ImplHandleHelpEvent(Window * pMenuWindow,Menu * pMenu,sal_uInt16 nHighlightedItem,const HelpEvent & rHEvt,const Rectangle & rHighlightRect)788 static sal_Bool ImplHandleHelpEvent( Window* pMenuWindow, Menu* pMenu, sal_uInt16 nHighlightedItem, const HelpEvent& rHEvt, const Rectangle &rHighlightRect )
789 {
790     if( ! pMenu )
791         return sal_False;
792 
793     sal_Bool bDone = sal_False;
794     sal_uInt16 nId = 0;
795 
796     if ( nHighlightedItem != ITEMPOS_INVALID )
797     {
798         MenuItemData* pItemData = pMenu->GetItemList()->GetDataFromPos( nHighlightedItem );
799         if ( pItemData )
800             nId = pItemData->nId;
801     }
802 
803     if ( ( rHEvt.GetMode() & HELPMODE_BALLOON ) && pMenuWindow )
804     {
805         Point aPos;
806 		if( rHEvt.KeyboardActivated() )
807 			aPos = rHighlightRect.Center();
808 		else
809 			aPos = rHEvt.GetMousePosPixel();
810 
811         Rectangle aRect( aPos, Size() );
812         if( pMenu->GetHelpText( nId ).Len() )
813             Help::ShowBalloon( pMenuWindow, aPos, pMenu->GetHelpText( nId ) );
814         else
815 		{
816 			// give user a chance to read the full filename
817 			sal_uLong oldTimeout=ImplChangeTipTimeout( 60000, pMenuWindow );
818 			// call always, even when strlen==0 to correctly remove tip
819 			Help::ShowQuickHelp( pMenuWindow, aRect, pMenu->GetTipHelpText( nId ) );
820 			ImplChangeTipTimeout( oldTimeout, pMenuWindow );
821 		}
822         bDone = sal_True;
823     }
824     else if ( ( rHEvt.GetMode() & HELPMODE_QUICK ) && pMenuWindow )
825     {
826         Point aPos = rHEvt.GetMousePosPixel();
827         Rectangle aRect( aPos, Size() );
828 		// give user a chance to read the full filename
829 		sal_uLong oldTimeout=ImplChangeTipTimeout( 60000, pMenuWindow );
830 		// call always, even when strlen==0 to correctly remove tip
831 		Help::ShowQuickHelp( pMenuWindow, aRect, pMenu->GetTipHelpText( nId ) );
832 		ImplChangeTipTimeout( oldTimeout, pMenuWindow );
833         bDone = sal_True;
834     }
835     else if ( rHEvt.GetMode() & (HELPMODE_CONTEXT | HELPMODE_EXTENDED) )
836     {
837         // Ist eine Hilfe in die Applikation selektiert
838         Help* pHelp = Application::GetHelp();
839         if ( pHelp )
840         {
841             // Ist eine ID vorhanden, dann Hilfe mit der ID aufrufen, sonst
842             // den Hilfe-Index
843             String aCommand = pMenu->GetItemCommand( nId );
844             rtl::OString aHelpId(  pMenu->GetHelpId( nId ) );
845             if( ! aHelpId.getLength() )
846                 aHelpId = OOO_HELP_INDEX;
847 
848             if ( aCommand.Len() )
849                 pHelp->Start( aCommand, NULL );
850             else
851                 pHelp->Start( rtl::OStringToOUString( aHelpId, RTL_TEXTENCODING_UTF8 ), NULL );
852         }
853         bDone = sal_True;
854     }
855     return bDone;
856 }
857 
ImplGetTopDockingAreaHeight(Window * pWindow)858 static int ImplGetTopDockingAreaHeight( Window *pWindow )
859 {
860     // find docking area that is top aligned and return its height
861     // note: dockingareas are direct children of the SystemWindow
862     int height=0;
863     sal_Bool bDone = sal_False;
864     if( pWindow->ImplGetFrameWindow() )
865     {
866         Window *pWin = pWindow->ImplGetFrameWindow()->GetWindow( WINDOW_FIRSTCHILD); //mpWindowImpl->mpFirstChild;
867         while( pWin && !bDone )
868         {
869             if( pWin->IsSystemWindow() )
870             {
871                 pWin = pWin->GetWindow( WINDOW_FIRSTCHILD); //mpWindowImpl->mpFirstChild;
872                 while( pWin && !bDone )
873                 {
874                     DockingAreaWindow *pDockingArea = dynamic_cast< DockingAreaWindow* >( pWin );
875                     if( pDockingArea && pDockingArea->GetAlign() == WINDOWALIGN_TOP )
876                     {
877                         bDone = sal_True;
878                         if( pDockingArea->IsVisible() )
879                             height = pDockingArea->GetOutputSizePixel().Height();
880                     }
881                     else
882                         pWin = pWin->GetWindow( WINDOW_NEXT ); //mpWindowImpl->mpNext;
883                 }
884 
885             }
886             else
887                 pWin = pWin->GetWindow( WINDOW_NEXT ); //mpWindowImpl->mpNext;
888         }
889     }
890     return height;
891 }
892 
Menu()893 Menu::Menu()
894 {
895     DBG_CTOR( Menu, NULL );
896     bIsMenuBar = sal_False;
897     ImplInit();
898 }
899 
900 // this constructor makes sure we're creating the native menu
901 // with the correct type (ie, MenuBar vs. PopupMenu)
Menu(sal_Bool bMenubar)902 Menu::Menu( sal_Bool bMenubar )
903 {
904     DBG_CTOR( Menu, NULL );
905     bIsMenuBar = bMenubar;
906     ImplInit();
907 }
908 
~Menu()909 Menu::~Menu()
910 {
911     DBG_DTOR( Menu, NULL );
912 
913     vcl::LazyDeletor<Menu>::Undelete( this );
914 
915     ImplCallEventListeners( VCLEVENT_OBJECT_DYING, ITEMPOS_INVALID );
916 
917 	// at the window free the reference to the accessible component
918     // and make sure the MenuFloatingWindow knows about our destruction
919 	if ( pWindow )
920     {
921         MenuFloatingWindow* pFloat = (MenuFloatingWindow*)pWindow;
922         if( pFloat->pMenu == this )
923             pFloat->pMenu = NULL;
924 		pWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
925     }
926 
927 	// dispose accessible components
928     if ( mxAccessible.is() )
929     {
930         ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent> xComponent( mxAccessible, ::com::sun::star::uno::UNO_QUERY );
931         if ( xComponent.is() )
932             xComponent->dispose();
933     }
934 
935     if ( nEventId )
936         Application::RemoveUserEvent( nEventId );
937 
938     // Notify deletion of this menu
939     ImplMenuDelData* pDelData = mpFirstDel;
940     while ( pDelData )
941     {
942         pDelData->mpMenu = NULL;
943         pDelData = pDelData->mpNext;
944     }
945 
946     bKilled = sal_True;
947 
948     delete pItemList;
949     delete pLogo;
950     delete mpLayoutData;
951 
952     // Native-support: destroy SalMenu
953     ImplSetSalMenu( NULL );
954 }
955 
doLazyDelete()956 void Menu::doLazyDelete()
957 {
958     vcl::LazyDeletor<Menu>::Delete( this );
959 }
960 
ImplInit()961 void Menu::ImplInit()
962 {
963     mnHighlightedItemPos = ITEMPOS_INVALID;
964     mpSalMenu       = NULL;
965     nMenuFlags      = MENU_FLAG_SHOWCHECKIMAGES;
966     nDefaultItem    = 0;
967     //bIsMenuBar      = sal_False;  // this is now set in the ctor, must not be changed here!!!
968     nSelectedId     = 0;
969     pItemList       = new MenuItemList;
970     pLogo           = NULL;
971     pStartedFrom    = NULL;
972     pWindow         = NULL;
973     nEventId        = 0;
974     bCanceled       = sal_False;
975     bInCallback     = sal_False;
976     bKilled         = sal_False;
977     mpLayoutData	= NULL;
978 	mpFirstDel      = NULL;         // Dtor notification list
979     // Native-support: returns NULL if not supported
980     mpSalMenu = ImplGetSVData()->mpDefInst->CreateMenu( bIsMenuBar, this );
981 }
982 
ImplGetStartedFrom() const983 Menu* Menu::ImplGetStartedFrom() const
984 {
985     return pStartedFrom;
986 }
987 
ImplLoadRes(const ResId & rResId)988 void Menu::ImplLoadRes( const ResId& rResId )
989 {
990     ResMgr* pMgr = rResId.GetResMgr();
991     if( ! pMgr )
992         return;
993 
994     rResId.SetRT( RSC_MENU );
995     GetRes( rResId );
996 
997     sal_uLong nObjMask = ReadLongRes();
998 
999     if( nObjMask & RSC_MENU_ITEMS )
1000     {
1001         sal_uLong nObjFollows = ReadLongRes();
1002         // MenuItems einfuegen
1003         for( sal_uLong i = 0; i < nObjFollows; i++ )
1004         {
1005             InsertItem( ResId( (RSHEADER_TYPE*)GetClassRes(), *pMgr ) );
1006             IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1007         }
1008     }
1009 
1010     if( nObjMask & RSC_MENU_TEXT )
1011     {
1012         if( bIsMenuBar ) // Kein Titel im Menubar
1013             ReadStringRes();
1014         else
1015             aTitleText = ReadStringRes();
1016     }
1017     if( nObjMask & RSC_MENU_DEFAULTITEMID )
1018         SetDefaultItem( sal::static_int_cast<sal_uInt16>(ReadLongRes()) );
1019 }
1020 
CreateAutoMnemonics()1021 void Menu::CreateAutoMnemonics()
1022 {
1023     MnemonicGenerator aMnemonicGenerator;
1024     sal_uLong n;
1025     for ( n = 0; n < pItemList->Count(); n++ )
1026     {
1027         MenuItemData* pData = pItemList->GetDataFromPos(n);
1028         if ( ! (pData->nBits & MIB_NOSELECT ) )
1029             aMnemonicGenerator.RegisterMnemonic( pData->aText );
1030     }
1031     for ( n = 0; n < pItemList->Count(); n++ )
1032     {
1033         MenuItemData* pData = pItemList->GetDataFromPos(n);
1034         if ( ! (pData->nBits & MIB_NOSELECT ) )
1035             aMnemonicGenerator.CreateMnemonic( pData->aText );
1036     }
1037 }
1038 
Activate()1039 void Menu::Activate()
1040 {
1041     bInCallback = sal_True;
1042 
1043 	ImplMenuDelData aDelData( this );
1044 
1045     ImplCallEventListeners( VCLEVENT_MENU_ACTIVATE, ITEMPOS_INVALID );
1046 
1047 	if( !aDelData.isDeleted() )
1048 	{
1049 		if ( !aActivateHdl.Call( this ) )
1050 		{
1051 			if( !aDelData.isDeleted() )
1052 			{
1053 				Menu* pStartMenu = ImplGetStartMenu();
1054 				if ( pStartMenu && ( pStartMenu != this ) )
1055 				{
1056 					pStartMenu->bInCallback = sal_True;
1057 					// MT 11/01: Call EventListener here? I don't know...
1058 					pStartMenu->aActivateHdl.Call( this );
1059 					pStartMenu->bInCallback = sal_False;
1060 				}
1061 			}
1062 		}
1063 		bInCallback = sal_False;
1064 	}
1065 }
1066 
Deactivate()1067 void Menu::Deactivate()
1068 {
1069     for ( sal_uInt16 n = (sal_uInt16)pItemList->Count(); n; )
1070     {
1071         MenuItemData* pData = pItemList->GetDataFromPos( --n );
1072         if ( pData->bIsTemporary )
1073             pItemList->Remove( n );
1074     }
1075 
1076     bInCallback = sal_True;
1077 
1078 	ImplMenuDelData aDelData( this );
1079 
1080     Menu* pStartMenu = ImplGetStartMenu();
1081     ImplCallEventListeners( VCLEVENT_MENU_DEACTIVATE, ITEMPOS_INVALID );
1082 
1083 	if( !aDelData.isDeleted() )
1084 	{
1085 		if ( !aDeactivateHdl.Call( this ) )
1086 		{
1087 			if( !aDelData.isDeleted() )
1088 			{
1089 				if ( pStartMenu && ( pStartMenu != this ) )
1090 				{
1091 					pStartMenu->bInCallback = sal_True;
1092 					pStartMenu->aDeactivateHdl.Call( this );
1093 					pStartMenu->bInCallback = sal_False;
1094 				}
1095 			}
1096 		}
1097 	}
1098 
1099 	if( !aDelData.isDeleted() )
1100 	{
1101 		bInCallback = sal_False;
1102 
1103 		if ( this == pStartMenu )
1104 			GetpApp()->HideHelpStatusText();
1105 	}
1106 }
1107 
Highlight()1108 void Menu::Highlight()
1109 {
1110 	ImplMenuDelData aDelData( this );
1111 
1112     Menu* pStartMenu = ImplGetStartMenu();
1113     if ( !aHighlightHdl.Call( this ) && !aDelData.isDeleted() )
1114     {
1115         if ( pStartMenu && ( pStartMenu != this ) )
1116             pStartMenu->aHighlightHdl.Call( this );
1117     }
1118 
1119     if ( !aDelData.isDeleted() && GetCurItemId() )
1120         GetpApp()->ShowHelpStatusText( GetHelpText( GetCurItemId() ) );
1121 }
1122 
ImplSelect()1123 void Menu::ImplSelect()
1124 {
1125     MenuItemData* pData = GetItemList()->GetData( nSelectedId );
1126     if ( pData && (pData->nBits & MIB_AUTOCHECK) )
1127     {
1128         sal_Bool bChecked = IsItemChecked( nSelectedId );
1129         if ( pData->nBits & MIB_RADIOCHECK )
1130         {
1131             if ( !bChecked )
1132                 CheckItem( nSelectedId, sal_True );
1133         }
1134         else
1135             CheckItem( nSelectedId, !bChecked );
1136     }
1137 
1138     // Select rufen
1139     ImplSVData* pSVData = ImplGetSVData();
1140     pSVData->maAppData.mpActivePopupMenu = NULL;        // Falls neues Execute im Select()
1141     Application::PostUserEvent( nEventId, LINK( this, Menu, ImplCallSelect ) );
1142 }
1143 
Select()1144 void Menu::Select()
1145 {
1146 	ImplMenuDelData aDelData( this );
1147 
1148     ImplCallEventListeners( VCLEVENT_MENU_SELECT, GetItemPos( GetCurItemId() ) );
1149     if ( !aDelData.isDeleted() && !aSelectHdl.Call( this ) )
1150     {
1151 		if( !aDelData.isDeleted() )
1152 		{
1153 			Menu* pStartMenu = ImplGetStartMenu();
1154 			if ( pStartMenu && ( pStartMenu != this ) )
1155 			{
1156 				pStartMenu->nSelectedId = nSelectedId;
1157 				pStartMenu->aSelectHdl.Call( this );
1158 			}
1159 		}
1160     }
1161 }
1162 
ImplSelectWithStart(Menu * pSMenu)1163 void Menu::ImplSelectWithStart( Menu* pSMenu )
1164 {
1165     Menu* pOldStartedFrom = pStartedFrom;
1166     pStartedFrom = pSMenu;
1167     Menu* pOldStartedStarted = pOldStartedFrom ? pOldStartedFrom->pStartedFrom : NULL;
1168     Select();
1169     if( pOldStartedFrom )
1170         pOldStartedFrom->pStartedFrom = pOldStartedStarted;
1171     pStartedFrom = pOldStartedFrom;
1172 }
1173 
RequestHelp(const HelpEvent &)1174 void Menu::RequestHelp( const HelpEvent& )
1175 {
1176 }
1177 
ImplCallEventListeners(sal_uLong nEvent,sal_uInt16 nPos)1178 void Menu::ImplCallEventListeners( sal_uLong nEvent, sal_uInt16 nPos )
1179 {
1180 	ImplMenuDelData aDelData( this );
1181 
1182     VclMenuEvent aEvent( this, nEvent, nPos );
1183 
1184     // This is needed by atk accessibility bridge
1185     if ( nEvent == VCLEVENT_MENU_HIGHLIGHT )
1186     {
1187         ImplGetSVData()->mpApp->ImplCallEventListeners( &aEvent );
1188     }
1189 
1190     if ( !aDelData.isDeleted() && !maEventListeners.empty() )
1191         maEventListeners.Call( &aEvent );
1192 
1193 	if( !aDelData.isDeleted() )
1194 	{
1195 		Menu* pMenu = this;
1196 		while ( pMenu )
1197 		{
1198 			if ( !maChildEventListeners.empty() )
1199 				maChildEventListeners.Call( &aEvent );
1200 
1201 			if( aDelData.isDeleted() )
1202 				break;
1203 
1204 			pMenu = ( pMenu->pStartedFrom != pMenu ) ? pMenu->pStartedFrom : NULL;
1205 		}
1206 	}
1207 }
1208 
AddEventListener(const Link & rEventListener)1209 void Menu::AddEventListener( const Link& rEventListener )
1210 {
1211     maEventListeners.push_back( rEventListener );
1212 }
1213 
RemoveEventListener(const Link & rEventListener)1214 void Menu::RemoveEventListener( const Link& rEventListener )
1215 {
1216     maEventListeners.remove( rEventListener );
1217 }
1218 
1219 // -----------------------------------------------------------------------
1220 
1221 //void Menu::AddChildEventListener( const Link& rEventListener )
1222 //{
1223 //    mpDummy4_WindowChildEventListeners->push_back( rEventListener );
1224 //}
1225 
1226 // -----------------------------------------------------------------------
1227 
1228 //void Menu::RemoveChildEventListener( const Link& rEventListener )
1229 //{
1230 //    mpDummy4_WindowChildEventListeners->remove( rEventListener );
1231 //}
1232 
InsertItem(sal_uInt16 nItemId,const XubString & rStr,MenuItemBits nItemBits,sal_uInt16 nPos)1233 void Menu::InsertItem( sal_uInt16 nItemId, const XubString& rStr, MenuItemBits nItemBits, sal_uInt16 nPos )
1234 {
1235     DBG_ASSERT( nItemId, "Menu::InsertItem(): ItemId == 0" );
1236     DBG_ASSERT( GetItemPos( nItemId ) == MENU_ITEM_NOTFOUND,
1237                 "Menu::InsertItem(): ItemId already exists" );
1238 
1239     // if Position > ItemCount, append
1240     if ( nPos >= (sal_uInt16)pItemList->Count() )
1241         nPos = MENU_APPEND;
1242 
1243     // put Item in MenuItemList
1244     MenuItemData* pData = pItemList->Insert( nItemId, MENUITEM_STRING,
1245                              nItemBits, rStr, Image(), this, nPos );
1246 
1247     // update native menu
1248     if( ImplGetSalMenu() && pData->pSalMenuItem )
1249         ImplGetSalMenu()->InsertItem( pData->pSalMenuItem, nPos );
1250 
1251     Window* pWin = ImplGetWindow();
1252     delete mpLayoutData, mpLayoutData = NULL;
1253     if ( pWin )
1254     {
1255         ImplCalcSize( pWin );
1256         if ( pWin->IsVisible() )
1257             pWin->Invalidate();
1258     }
1259     ImplCallEventListeners( VCLEVENT_MENU_INSERTITEM, nPos );
1260 }
1261 
InsertItem(sal_uInt16 nItemId,const Image & rImage,MenuItemBits nItemBits,sal_uInt16 nPos)1262 void Menu::InsertItem( sal_uInt16 nItemId, const Image& rImage,
1263                        MenuItemBits nItemBits, sal_uInt16 nPos )
1264 {
1265     InsertItem( nItemId, ImplGetSVEmptyStr(), nItemBits, nPos );
1266     SetItemImage( nItemId, rImage );
1267 }
1268 
InsertItem(sal_uInt16 nItemId,const XubString & rStr,const Image & rImage,MenuItemBits nItemBits,sal_uInt16 nPos)1269 void Menu::InsertItem( sal_uInt16 nItemId,
1270                        const XubString& rStr, const Image& rImage,
1271                        MenuItemBits nItemBits, sal_uInt16 nPos )
1272 {
1273     InsertItem( nItemId, rStr, nItemBits, nPos );
1274     SetItemImage( nItemId, rImage );
1275 }
1276 
InsertItem(const ResId & rResId,sal_uInt16 nPos)1277 void Menu::InsertItem( const ResId& rResId, sal_uInt16 nPos )
1278 {
1279     ResMgr* pMgr = rResId.GetResMgr();
1280     if( ! pMgr )
1281         return;
1282 
1283     sal_uLong              nObjMask;
1284 
1285     GetRes( rResId.SetRT( RSC_MENUITEM ) );
1286     nObjMask    = ReadLongRes();
1287 
1288     sal_Bool bSep = sal_False;
1289     if ( nObjMask & RSC_MENUITEM_SEPARATOR )
1290         bSep = (sal_Bool)ReadShortRes();
1291 
1292     sal_uInt16 nItemId = 1;
1293     if ( nObjMask & RSC_MENUITEM_ID )
1294         nItemId = sal::static_int_cast<sal_uInt16>(ReadLongRes());
1295 
1296     MenuItemBits nStatus = 0;
1297     if ( nObjMask & RSC_MENUITEM_STATUS )
1298         nStatus = sal::static_int_cast<MenuItemBits>(ReadLongRes());
1299 
1300     String aText;
1301     if ( nObjMask & RSC_MENUITEM_TEXT )
1302         aText = ReadStringRes();
1303 
1304     // Item erzeugen
1305     if ( nObjMask & RSC_MENUITEM_BITMAP )
1306     {
1307         if ( !bSep )
1308         {
1309             Bitmap aBmp( ResId( (RSHEADER_TYPE*)GetClassRes(), *pMgr ) );
1310             if ( aText.Len() )
1311                 InsertItem( nItemId, aText, aBmp, nStatus, nPos );
1312             else
1313                 InsertItem( nItemId, aBmp, nStatus, nPos );
1314         }
1315         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1316     }
1317     else if ( !bSep )
1318         InsertItem( nItemId, aText, nStatus, nPos );
1319     if ( bSep )
1320         InsertSeparator( nPos );
1321 
1322     String aHelpText;
1323     if ( nObjMask & RSC_MENUITEM_HELPTEXT )
1324     {
1325         aHelpText = ReadStringRes();
1326         if( !bSep )
1327             SetHelpText( nItemId, aHelpText );
1328     }
1329 
1330     if ( nObjMask & RSC_MENUITEM_HELPID )
1331     {
1332         rtl::OString aHelpId( ReadByteStringRes() );
1333         if ( !bSep )
1334             SetHelpId( nItemId, aHelpId );
1335     }
1336 
1337     if( !bSep )
1338         SetHelpText( nItemId, aHelpText );
1339 
1340     if ( nObjMask & RSC_MENUITEM_KEYCODE )
1341     {
1342         if ( !bSep )
1343             SetAccelKey( nItemId, KeyCode( ResId( (RSHEADER_TYPE*)GetClassRes(), *pMgr ) ) );
1344         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1345     }
1346     if( nObjMask & RSC_MENUITEM_CHECKED )
1347     {
1348         if ( !bSep )
1349             CheckItem( nItemId, (sal_Bool)ReadShortRes() );
1350     }
1351     if ( nObjMask & RSC_MENUITEM_DISABLE )
1352     {
1353         if ( !bSep )
1354             EnableItem( nItemId, !(sal_Bool)ReadShortRes() );
1355     }
1356     if ( nObjMask & RSC_MENUITEM_COMMAND )
1357     {
1358         String aCommandStr = ReadStringRes();
1359         if ( !bSep )
1360             SetItemCommand( nItemId, aCommandStr );
1361     }
1362     if ( nObjMask & RSC_MENUITEM_MENU )
1363     {
1364         if ( !bSep )
1365         {
1366             MenuItemData* pData = GetItemList()->GetData( nItemId );
1367             if ( pData )
1368             {
1369                 PopupMenu* pSubMenu = new PopupMenu( ResId( (RSHEADER_TYPE*)GetClassRes(), *pMgr ) );
1370                 pData->pAutoSubMenu = pSubMenu;
1371                 // #111060# keep track of this pointer, may be it will be deleted from outside
1372                 pSubMenu->pRefAutoSubMenu = &pData->pAutoSubMenu;
1373                 SetPopupMenu( nItemId, pSubMenu );
1374             }
1375         }
1376         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1377     }
1378     delete mpLayoutData, mpLayoutData = NULL;
1379 }
1380 
InsertSeparator(sal_uInt16 nPos)1381 void Menu::InsertSeparator( sal_uInt16 nPos )
1382 {
1383     // do nothing if its a menu bar
1384     if ( bIsMenuBar )
1385         return;
1386 
1387     // if position > ItemCount, append
1388     if ( nPos >= (sal_uInt16)pItemList->Count() )
1389         nPos = MENU_APPEND;
1390 
1391     // put separator in item list
1392     pItemList->InsertSeparator( nPos );
1393 
1394     // update native menu
1395     sal_uInt16 itemPos = nPos != MENU_APPEND ? nPos : (sal_uInt16)pItemList->Count() - 1;
1396     MenuItemData *pData = pItemList->GetDataFromPos( itemPos );
1397     if( ImplGetSalMenu() && pData && pData->pSalMenuItem )
1398         ImplGetSalMenu()->InsertItem( pData->pSalMenuItem, nPos );
1399 
1400     delete mpLayoutData, mpLayoutData = NULL;
1401 
1402     ImplCallEventListeners( VCLEVENT_MENU_INSERTITEM, nPos );
1403 }
1404 
RemoveItem(sal_uInt16 nPos)1405 void Menu::RemoveItem( sal_uInt16 nPos )
1406 {
1407 	sal_Bool bRemove = sal_False;
1408 
1409     if ( nPos < GetItemCount() )
1410 	{
1411         // update native menu
1412         if( ImplGetSalMenu() )
1413             ImplGetSalMenu()->RemoveItem( nPos );
1414 
1415         pItemList->Remove( nPos );
1416 		bRemove = sal_True;
1417 	}
1418 
1419     Window* pWin = ImplGetWindow();
1420     if ( pWin )
1421     {
1422         ImplCalcSize( pWin );
1423         if ( pWin->IsVisible() )
1424             pWin->Invalidate();
1425     }
1426     delete mpLayoutData, mpLayoutData = NULL;
1427 
1428 	if ( bRemove )
1429 		ImplCallEventListeners( VCLEVENT_MENU_REMOVEITEM, nPos );
1430 }
1431 
ImplCopyItem(Menu * pThis,const Menu & rMenu,sal_uInt16 nPos,sal_uInt16 nNewPos,sal_uInt16 nMode=0)1432 void ImplCopyItem( Menu* pThis, const Menu& rMenu, sal_uInt16 nPos, sal_uInt16 nNewPos,
1433                   sal_uInt16 nMode = 0 )
1434 {
1435     MenuItemType eType = rMenu.GetItemType( nPos );
1436 
1437     if ( eType == MENUITEM_DONTKNOW )
1438         return;
1439 
1440     if ( eType == MENUITEM_SEPARATOR )
1441         pThis->InsertSeparator( nNewPos );
1442     else
1443     {
1444         sal_uInt16 nId = rMenu.GetItemId( nPos );
1445 
1446         DBG_ASSERT( pThis->GetItemPos( nId ) == MENU_ITEM_NOTFOUND,
1447                     "Menu::CopyItem(): ItemId already exists" );
1448 
1449         MenuItemData* pData = rMenu.GetItemList()->GetData( nId );
1450 
1451         if ( eType == MENUITEM_STRINGIMAGE )
1452             pThis->InsertItem( nId, pData->aText, pData->aImage, pData->nBits, nNewPos );
1453         else if ( eType == MENUITEM_STRING )
1454             pThis->InsertItem( nId, pData->aText, pData->nBits, nNewPos );
1455         else
1456             pThis->InsertItem( nId, pData->aImage, pData->nBits, nNewPos );
1457 
1458         if ( rMenu.IsItemChecked( nId ) )
1459             pThis->CheckItem( nId, sal_True );
1460         if ( !rMenu.IsItemEnabled( nId ) )
1461             pThis->EnableItem( nId, sal_False );
1462         pThis->SetHelpId( nId, pData->aHelpId );
1463         pThis->SetHelpText( nId, pData->aHelpText );
1464         pThis->SetAccelKey( nId, pData->aAccelKey );
1465         pThis->SetItemCommand( nId, pData->aCommandStr );
1466         pThis->SetHelpCommand( nId, pData->aHelpCommandStr );
1467 
1468         PopupMenu* pSubMenu = rMenu.GetPopupMenu( nId );
1469         if ( pSubMenu )
1470         {
1471             // AutoKopie anlegen
1472             if ( nMode == 1 )
1473             {
1474                 PopupMenu* pNewMenu = new PopupMenu( *pSubMenu );
1475                 pThis->SetPopupMenu( nId, pNewMenu );
1476 //                SetAutoMenu( pThis, nId, pNewMenu );
1477             }
1478             else
1479                 pThis->SetPopupMenu( nId, pSubMenu );
1480         }
1481     }
1482 }
1483 
CopyItem(const Menu & rMenu,sal_uInt16 nPos,sal_uInt16 nNewPos)1484 void Menu::CopyItem( const Menu& rMenu, sal_uInt16 nPos, sal_uInt16 nNewPos )
1485 {
1486     ImplCopyItem( this, rMenu, nPos, nNewPos );
1487 }
1488 
Clear()1489 void Menu::Clear()
1490 {
1491     for ( sal_uInt16 i = GetItemCount(); i; i-- )
1492         RemoveItem( 0 );
1493 }
1494 
GetItemCount() const1495 sal_uInt16 Menu::GetItemCount() const
1496 {
1497     return (sal_uInt16)pItemList->Count();
1498 }
1499 
ImplGetVisibleItemCount() const1500 sal_uInt16 Menu::ImplGetVisibleItemCount() const
1501 {
1502     sal_uInt16 nItems = 0;
1503     for ( sal_uInt16 n = (sal_uInt16)pItemList->Count(); n; )
1504     {
1505         if ( ImplIsVisible( --n ) )
1506             nItems++;
1507     }
1508     return nItems;
1509 }
1510 
ImplGetFirstVisible() const1511 sal_uInt16 Menu::ImplGetFirstVisible() const
1512 {
1513     for ( sal_uInt16 n = 0; n < pItemList->Count(); n++ )
1514     {
1515         if ( ImplIsVisible( n ) )
1516             return n;
1517     }
1518     return ITEMPOS_INVALID;
1519 }
1520 
ImplGetPrevVisible(sal_uInt16 nPos) const1521 sal_uInt16 Menu::ImplGetPrevVisible( sal_uInt16 nPos ) const
1522 {
1523     for ( sal_uInt16 n = nPos; n; )
1524     {
1525         if ( n && ImplIsVisible( --n ) )
1526             return n;
1527     }
1528     return ITEMPOS_INVALID;
1529 }
1530 
ImplGetNextVisible(sal_uInt16 nPos) const1531 sal_uInt16 Menu::ImplGetNextVisible( sal_uInt16 nPos ) const
1532 {
1533     for ( sal_uInt16 n = nPos+1; n < pItemList->Count(); n++ )
1534     {
1535         if ( ImplIsVisible( n ) )
1536             return n;
1537     }
1538     return ITEMPOS_INVALID;
1539 }
1540 
GetItemId(sal_uInt16 nPos) const1541 sal_uInt16 Menu::GetItemId( sal_uInt16 nPos ) const
1542 {
1543     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
1544 
1545     if ( pData )
1546         return pData->nId;
1547     else
1548         return 0;
1549 }
1550 
GetItemPos(sal_uInt16 nItemId) const1551 sal_uInt16 Menu::GetItemPos( sal_uInt16 nItemId ) const
1552 {
1553     sal_uInt16          nPos;
1554     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1555 
1556     if ( pData )
1557         return nPos;
1558     else
1559         return MENU_ITEM_NOTFOUND;
1560 }
1561 
GetItemType(sal_uInt16 nPos) const1562 MenuItemType Menu::GetItemType( sal_uInt16 nPos ) const
1563 {
1564     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
1565 
1566     if ( pData )
1567         return pData->eType;
1568     else
1569         return MENUITEM_DONTKNOW;
1570 }
1571 
GetCurItemId() const1572 sal_uInt16 Menu::GetCurItemId() const
1573 {
1574     return nSelectedId;
1575 }
SetHightlightItem(sal_uInt16 nHighlightedItem)1576 void Menu::SetHightlightItem( sal_uInt16 nHighlightedItem )
1577 {
1578 	this->nHighlightedItem = nHighlightedItem;
1579 }
GetHighlightItem() const1580 sal_uInt16 Menu::GetHighlightItem() const
1581 {
1582 	return nHighlightedItem;
1583 }
1584 
1585 
GetItemAccKeyStrFromPos(sal_uInt16 nPos) const1586 XubString Menu::GetItemAccKeyStrFromPos(sal_uInt16 nPos) const
1587 {
1588     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
1589 	if (pData)
1590 	{
1591 		return pData->aAccelKey.GetName();
1592 	}
1593 	return XubString();
1594 }
1595 
IsTemporaryItemFromPos(sal_uInt16 nPos) const1596 sal_Bool Menu::IsTemporaryItemFromPos(sal_uInt16 nPos ) const
1597 {
1598     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
1599 	if (pData)
1600 	{
1601 		return pData->bIsTemporary;
1602 	}
1603 	return sal_False;
1604 }
1605 
SetItemBits(sal_uInt16 nItemId,MenuItemBits nBits)1606 void Menu::SetItemBits( sal_uInt16 nItemId, MenuItemBits nBits )
1607 {
1608     MenuItemData* pData = pItemList->GetData( nItemId );
1609     if ( pData )
1610         pData->nBits = nBits;
1611 }
1612 
GetItemBits(sal_uInt16 nItemId) const1613 MenuItemBits Menu::GetItemBits( sal_uInt16 nItemId ) const
1614 {
1615     MenuItemBits nBits = 0;
1616     MenuItemData* pData = pItemList->GetData( nItemId );
1617     if ( pData )
1618         nBits = pData->nBits;
1619     return nBits;
1620 }
1621 
SetUserValue(sal_uInt16 nItemId,sal_uLong nValue)1622 void Menu::SetUserValue( sal_uInt16 nItemId, sal_uLong nValue )
1623 {
1624     MenuItemData* pData = pItemList->GetData( nItemId );
1625     if ( pData )
1626         pData->nUserValue = nValue;
1627 }
1628 
GetUserValue(sal_uInt16 nItemId) const1629 sal_uLong Menu::GetUserValue( sal_uInt16 nItemId ) const
1630 {
1631     MenuItemData* pData = pItemList->GetData( nItemId );
1632     return pData ? pData->nUserValue : 0;
1633 }
1634 
SetPopupMenu(sal_uInt16 nItemId,PopupMenu * pMenu)1635 void Menu::SetPopupMenu( sal_uInt16 nItemId, PopupMenu* pMenu )
1636 {
1637     sal_uInt16          nPos;
1638     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1639 
1640     // Item does not exist -> return NULL
1641     if ( !pData )
1642         return;
1643 
1644     // same menu, nothing to do
1645     if ( (PopupMenu*)pData->pSubMenu == pMenu )
1646         return;
1647 
1648     // data exchange
1649     pData->pSubMenu = pMenu;
1650 
1651     // #112023# Make sure pStartedFrom does not point to invalid (old) data
1652     if ( pData->pSubMenu )
1653         pData->pSubMenu->pStartedFrom = 0;
1654 
1655     // set native submenu
1656     if( ImplGetSalMenu() && pData->pSalMenuItem )
1657     {
1658         if( pMenu )
1659             ImplGetSalMenu()->SetSubMenu( pData->pSalMenuItem, pMenu->ImplGetSalMenu(), nPos );
1660         else
1661             ImplGetSalMenu()->SetSubMenu( pData->pSalMenuItem, NULL, nPos );
1662     }
1663 
1664     ImplCallEventListeners( VCLEVENT_MENU_SUBMENUCHANGED, nPos );
1665 }
1666 
GetPopupMenu(sal_uInt16 nItemId) const1667 PopupMenu* Menu::GetPopupMenu( sal_uInt16 nItemId ) const
1668 {
1669     MenuItemData* pData = pItemList->GetData( nItemId );
1670 
1671     if ( pData )
1672         return (PopupMenu*)(pData->pSubMenu);
1673     else
1674         return NULL;
1675 }
1676 
SetAccelKey(sal_uInt16 nItemId,const KeyCode & rKeyCode)1677 void Menu::SetAccelKey( sal_uInt16 nItemId, const KeyCode& rKeyCode )
1678 {
1679     sal_uInt16          nPos;
1680     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1681 
1682     if ( !pData )
1683         return;
1684 
1685     if ( pData->aAccelKey == rKeyCode )
1686         return;
1687 
1688     pData->aAccelKey = rKeyCode;
1689 
1690     // update native menu
1691     if( ImplGetSalMenu() && pData->pSalMenuItem )
1692         ImplGetSalMenu()->SetAccelerator( nPos, pData->pSalMenuItem, rKeyCode, rKeyCode.GetName() );
1693 }
1694 
GetAccelKey(sal_uInt16 nItemId) const1695 KeyCode Menu::GetAccelKey( sal_uInt16 nItemId ) const
1696 {
1697     MenuItemData* pData = pItemList->GetData( nItemId );
1698 
1699     if ( pData )
1700         return pData->aAccelKey;
1701     else
1702         return KeyCode();
1703 }
1704 
GetActivationKey(sal_uInt16 nItemId) const1705 KeyEvent Menu::GetActivationKey( sal_uInt16 nItemId ) const
1706 {
1707     KeyEvent aRet;
1708     MenuItemData* pData = pItemList->GetData( nItemId );
1709     if( pData )
1710     {
1711         sal_uInt16 nPos = pData->aText.Search( '~' );
1712         if( nPos != STRING_NOTFOUND && nPos < pData->aText.Len()-1 )
1713         {
1714             sal_uInt16 nCode = 0;
1715             sal_Unicode cAccel = pData->aText.GetChar( nPos+1 );
1716             if( cAccel >= 'a' && cAccel <= 'z' )
1717                 nCode = KEY_A + (cAccel-'a');
1718             else if( cAccel >= 'A' && cAccel <= 'Z' )
1719                 nCode = KEY_A + (cAccel-'A');
1720             else if( cAccel >= '0' && cAccel <= '9' )
1721                 nCode = KEY_0 + (cAccel-'0');
1722             if(nCode )
1723                 aRet = KeyEvent( cAccel, KeyCode( nCode, KEY_MOD2 ) );
1724         }
1725 
1726     }
1727     return aRet;
1728 }
1729 
CheckItem(sal_uInt16 nItemId,sal_Bool bCheck)1730 void Menu::CheckItem( sal_uInt16 nItemId, sal_Bool bCheck )
1731 {
1732     sal_uInt16 nPos;
1733     MenuItemData* pData = pItemList->GetData( nItemId, nPos );
1734 
1735     if ( !pData || pData->bChecked == bCheck )
1736         return;
1737 
1738     // Wenn RadioCheck, dann vorherigen unchecken
1739     if ( bCheck && (pData->nBits & MIB_AUTOCHECK) &&
1740          (pData->nBits & MIB_RADIOCHECK) )
1741     {
1742         MenuItemData*   pGroupData;
1743         sal_uInt16          nGroupPos;
1744         sal_uInt16          nItemCount = GetItemCount();
1745         sal_Bool            bFound = sal_False;
1746 
1747         nGroupPos = nPos;
1748         while ( nGroupPos )
1749         {
1750             pGroupData = pItemList->GetDataFromPos( nGroupPos-1 );
1751             if ( pGroupData->nBits & MIB_RADIOCHECK )
1752             {
1753                 if ( IsItemChecked( pGroupData->nId ) )
1754                 {
1755                     CheckItem( pGroupData->nId, sal_False );
1756                     bFound = sal_True;
1757                     break;
1758                 }
1759             }
1760             else
1761                 break;
1762             nGroupPos--;
1763         }
1764 
1765         if ( !bFound )
1766         {
1767             nGroupPos = nPos+1;
1768             while ( nGroupPos < nItemCount )
1769             {
1770                 pGroupData = pItemList->GetDataFromPos( nGroupPos );
1771                 if ( pGroupData->nBits & MIB_RADIOCHECK )
1772                 {
1773                     if ( IsItemChecked( pGroupData->nId ) )
1774                     {
1775                         CheckItem( pGroupData->nId, sal_False );
1776                         break;
1777                     }
1778                 }
1779                 else
1780                     break;
1781                 nGroupPos++;
1782             }
1783         }
1784     }
1785 
1786     pData->bChecked = bCheck;
1787 
1788     // update native menu
1789     if( ImplGetSalMenu() )
1790         ImplGetSalMenu()->CheckItem( nPos, bCheck );
1791 
1792 	ImplCallEventListeners( bCheck ? VCLEVENT_MENU_ITEMCHECKED : VCLEVENT_MENU_ITEMUNCHECKED, nPos );
1793 }
1794 
IsItemChecked(sal_uInt16 nItemId) const1795 sal_Bool Menu::IsItemChecked( sal_uInt16 nItemId ) const
1796 {
1797     sal_uInt16          nPos;
1798     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1799 
1800     if ( !pData )
1801         return sal_False;
1802 
1803     return pData->bChecked;
1804 }
1805 
EnableItem(sal_uInt16 nItemId,sal_Bool bEnable)1806 void Menu::EnableItem( sal_uInt16 nItemId, sal_Bool bEnable )
1807 {
1808     sal_uInt16          nPos;
1809     MenuItemData*   pItemData = pItemList->GetData( nItemId, nPos );
1810 
1811     if ( pItemData && ( pItemData->bEnabled != bEnable ) )
1812     {
1813         pItemData->bEnabled = bEnable;
1814 
1815         Window* pWin = ImplGetWindow();
1816         if ( pWin && pWin->IsVisible() )
1817         {
1818             DBG_ASSERT( bIsMenuBar, "Menu::EnableItem - Popup visible!" );
1819             long nX = 0;
1820             sal_uLong nCount = pItemList->Count();
1821             for ( sal_uLong n = 0; n < nCount; n++ )
1822             {
1823                 MenuItemData* pData = pItemList->GetDataFromPos( n );
1824                 if ( n == nPos )
1825                 {
1826                     pWin->Invalidate( Rectangle( Point( nX, 0 ), Size( pData->aSz.Width(), pData->aSz.Height() ) ) );
1827                     break;
1828                 }
1829                 nX += pData->aSz.Width();
1830             }
1831         }
1832         // update native menu
1833         if( ImplGetSalMenu() )
1834             ImplGetSalMenu()->EnableItem( nPos, bEnable );
1835 
1836         ImplCallEventListeners( bEnable ? VCLEVENT_MENU_ENABLE : VCLEVENT_MENU_DISABLE, nPos );
1837     }
1838 }
1839 
IsItemEnabled(sal_uInt16 nItemId) const1840 sal_Bool Menu::IsItemEnabled( sal_uInt16 nItemId ) const
1841 {
1842     sal_uInt16          nPos;
1843     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1844 
1845     if ( !pData )
1846         return sal_False;
1847 
1848     return pData->bEnabled;
1849 }
1850 
ShowItem(sal_uInt16 nItemId,sal_Bool bVisible)1851 void Menu::ShowItem( sal_uInt16 nItemId, sal_Bool bVisible )
1852 {
1853     sal_uInt16          nPos;
1854     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1855 
1856     DBG_ASSERT( !bIsMenuBar, "Menu::ShowItem - ignored for menu bar entries!" );
1857     if ( !bIsMenuBar && pData && ( pData->bVisible != bVisible ) )
1858     {
1859         Window* pWin = ImplGetWindow();
1860         if ( pWin && pWin->IsVisible() )
1861         {
1862             DBG_ASSERT( 0, "Menu::ShowItem - ignored for visible popups!" );
1863             return;
1864         }
1865         pData->bVisible = bVisible;
1866 
1867         // update native menu
1868         // as long as there is no support to hide native menu entries, we just disable them
1869         // TODO: add support to show/hide native menu entries
1870         if( ImplGetSalMenu() )
1871             ImplGetSalMenu()->EnableItem( nPos, bVisible );
1872     }
1873 }
1874 
SetItemText(sal_uInt16 nItemId,const XubString & rStr)1875 void Menu::SetItemText( sal_uInt16 nItemId, const XubString& rStr )
1876 {
1877     sal_uInt16          nPos;
1878     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1879 
1880     if ( !pData )
1881         return;
1882 
1883 	if ( !rStr.Equals( pData->aText ) )
1884 	{
1885 		pData->aText = rStr;
1886 		ImplSetMenuItemData( pData );
1887         // update native menu
1888         if( ImplGetSalMenu() && pData->pSalMenuItem )
1889             ImplGetSalMenu()->SetItemText( nPos, pData->pSalMenuItem, rStr );
1890 
1891         Window* pWin = ImplGetWindow();
1892         delete mpLayoutData, mpLayoutData = NULL;
1893         if ( pWin && IsMenuBar() )
1894         {
1895             ImplCalcSize( pWin );
1896             if ( pWin->IsVisible() )
1897                 pWin->Invalidate();
1898         }
1899 
1900         ImplCallEventListeners( VCLEVENT_MENU_ITEMTEXTCHANGED, nPos );
1901 	}
1902 }
1903 
GetItemText(sal_uInt16 nItemId) const1904 XubString Menu::GetItemText( sal_uInt16 nItemId ) const
1905 {
1906     sal_uInt16          nPos;
1907     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1908 
1909     if ( pData )
1910         return pData->aText;
1911     else
1912         return ImplGetSVEmptyStr();
1913 }
1914 
SetItemImage(sal_uInt16 nItemId,const Image & rImage)1915 void Menu::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
1916 {
1917     sal_uInt16          nPos;
1918     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1919 
1920     if ( !pData )
1921         return;
1922 
1923     pData->aImage = rImage;
1924     ImplSetMenuItemData( pData );
1925 
1926     // update native menu
1927     if( ImplGetSalMenu() && pData->pSalMenuItem )
1928         ImplGetSalMenu()->SetItemImage( nPos, pData->pSalMenuItem, rImage );
1929 }
1930 
ImplRotImage(const Image & rImage,long nAngle10)1931 static inline Image ImplRotImage( const Image& rImage, long nAngle10 )
1932 {
1933     Image 		aRet;
1934 	BitmapEx	aBmpEx( rImage.GetBitmapEx() );
1935 
1936 	aBmpEx.Rotate( nAngle10, COL_WHITE );
1937 
1938     return Image( aBmpEx );
1939 }
1940 
SetItemImageAngle(sal_uInt16 nItemId,long nAngle10)1941 void Menu::SetItemImageAngle( sal_uInt16 nItemId, long nAngle10 )
1942 {
1943     sal_uInt16          nPos;
1944     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1945 
1946 	if ( pData )
1947 	{
1948         long nDeltaAngle = (nAngle10 - pData->nItemImageAngle) % 3600;
1949         while( nDeltaAngle < 0 )
1950             nDeltaAngle += 3600;
1951 
1952         pData->nItemImageAngle = nAngle10;
1953         if( nDeltaAngle && !!pData->aImage )
1954             pData->aImage = ImplRotImage( pData->aImage, nDeltaAngle );
1955 	}
1956 }
1957 
ImplMirrorImage(const Image & rImage)1958 static inline Image ImplMirrorImage( const Image& rImage )
1959 {
1960     Image 		aRet;
1961 	BitmapEx	aBmpEx( rImage.GetBitmapEx() );
1962 
1963 	aBmpEx.Mirror( BMP_MIRROR_HORZ );
1964 
1965     return Image( aBmpEx );
1966 }
1967 
SetItemImageMirrorMode(sal_uInt16 nItemId,sal_Bool bMirror)1968 void Menu::SetItemImageMirrorMode( sal_uInt16 nItemId, sal_Bool bMirror )
1969 {
1970     sal_uInt16          nPos;
1971     MenuItemData*   pData = pItemList->GetData( nItemId, nPos );
1972 
1973 	if ( pData )
1974 	{
1975         if( ( pData->bMirrorMode && ! bMirror ) ||
1976             ( ! pData->bMirrorMode && bMirror )
1977             )
1978         {
1979             pData->bMirrorMode = bMirror ? true : false;
1980             if( !!pData->aImage )
1981                 pData->aImage = ImplMirrorImage( pData->aImage );
1982         }
1983     }
1984 }
1985 
GetItemImage(sal_uInt16 nItemId) const1986 Image Menu::GetItemImage( sal_uInt16 nItemId ) const
1987 {
1988     MenuItemData* pData = pItemList->GetData( nItemId );
1989 
1990     if ( pData )
1991         return pData->aImage;
1992     else
1993         return Image();
1994 }
1995 
GetItemImageAngle(sal_uInt16 nItemId) const1996 long Menu::GetItemImageAngle( sal_uInt16 nItemId ) const
1997 {
1998     MenuItemData* pData = pItemList->GetData( nItemId );
1999 
2000 	if ( pData )
2001 		return pData->nItemImageAngle;
2002 	else
2003 		return 0;
2004 }
2005 
GetItemImageMirrorMode(sal_uInt16 nItemId) const2006 sal_Bool Menu::GetItemImageMirrorMode( sal_uInt16 nItemId ) const
2007 {
2008     MenuItemData* pData = pItemList->GetData( nItemId );
2009 
2010 	if ( pData )
2011 		return pData->bMirrorMode;
2012 	else
2013 		return sal_False;
2014 }
2015 
SetItemCommand(sal_uInt16 nItemId,const String & rCommand)2016 void Menu::SetItemCommand( sal_uInt16 nItemId, const String& rCommand )
2017 {
2018     MenuItemData* pData = pItemList->GetData( nItemId );
2019 
2020     if ( pData )
2021         pData->aCommandStr = rCommand;
2022 }
2023 
GetItemCommand(sal_uInt16 nItemId) const2024 const XubString& Menu::GetItemCommand( sal_uInt16 nItemId ) const
2025 {
2026     MenuItemData* pData = pItemList->GetData( nItemId );
2027 
2028     if ( pData )
2029         return pData->aCommandStr;
2030     else
2031         return ImplGetSVEmptyStr();
2032 }
2033 
SetHelpCommand(sal_uInt16 nItemId,const XubString & rStr)2034 void Menu::SetHelpCommand( sal_uInt16 nItemId, const XubString& rStr )
2035 {
2036     MenuItemData* pData = pItemList->GetData( nItemId );
2037 
2038     if ( pData )
2039         pData->aHelpCommandStr = rStr;
2040 }
2041 
GetHelpCommand(sal_uInt16 nItemId) const2042 const XubString& Menu::GetHelpCommand( sal_uInt16 nItemId ) const
2043 {
2044     MenuItemData* pData = pItemList->GetData( nItemId );
2045 
2046     if ( pData )
2047         return pData->aHelpCommandStr;
2048     else
2049         return ImplGetSVEmptyStr();
2050 }
2051 
SetHelpText(sal_uInt16 nItemId,const XubString & rStr)2052 void Menu::SetHelpText( sal_uInt16 nItemId, const XubString& rStr )
2053 {
2054     MenuItemData* pData = pItemList->GetData( nItemId );
2055 
2056     if ( pData )
2057         pData->aHelpText = rStr;
2058 }
2059 
ImplGetHelpText(sal_uInt16 nItemId) const2060 const XubString& Menu::ImplGetHelpText( sal_uInt16 nItemId ) const
2061 {
2062     MenuItemData* pData = pItemList->GetData( nItemId );
2063 
2064     if ( pData )
2065     {
2066         if ( !pData->aHelpText.Len() &&
2067              (( pData->aHelpId.getLength()  ) || ( pData->aCommandStr.Len() )))
2068         {
2069             Help* pHelp = Application::GetHelp();
2070             if ( pHelp )
2071             {
2072                 if ( pData->aCommandStr.Len() )
2073                     pData->aHelpText = pHelp->GetHelpText( pData->aCommandStr, NULL );
2074 
2075                 if( !pData->aHelpText.Len() && pData->aHelpId.getLength() )
2076                     pData->aHelpText = pHelp->GetHelpText( rtl::OStringToOUString( pData->aHelpId, RTL_TEXTENCODING_UTF8 ), NULL );
2077             }
2078         }
2079 
2080         return pData->aHelpText;
2081     }
2082     else
2083         return ImplGetSVEmptyStr();
2084 }
2085 
GetHelpText(sal_uInt16 nItemId) const2086 const XubString& Menu::GetHelpText( sal_uInt16 nItemId ) const
2087 {
2088     return ImplGetHelpText( nItemId );
2089 }
2090 
SetTipHelpText(sal_uInt16 nItemId,const XubString & rStr)2091 void Menu::SetTipHelpText( sal_uInt16 nItemId, const XubString& rStr )
2092 {
2093     MenuItemData* pData = pItemList->GetData( nItemId );
2094 
2095     if ( pData )
2096         pData->aTipHelpText = rStr;
2097 }
2098 
GetTipHelpText(sal_uInt16 nItemId) const2099 const XubString& Menu::GetTipHelpText( sal_uInt16 nItemId ) const
2100 {
2101     MenuItemData* pData = pItemList->GetData( nItemId );
2102 
2103     if ( pData )
2104         return pData->aTipHelpText;
2105     else
2106         return ImplGetSVEmptyStr();
2107 }
2108 
SetHelpId(sal_uInt16 nItemId,const rtl::OString & rHelpId)2109 void Menu::SetHelpId( sal_uInt16 nItemId, const rtl::OString& rHelpId )
2110 {
2111     MenuItemData* pData = pItemList->GetData( nItemId );
2112 
2113     if ( pData )
2114         pData->aHelpId = rHelpId;
2115 }
2116 
GetHelpId(sal_uInt16 nItemId) const2117 rtl::OString Menu::GetHelpId( sal_uInt16 nItemId ) const
2118 {
2119     rtl::OString aRet;
2120 
2121     MenuItemData* pData = pItemList->GetData( nItemId );
2122 
2123     if ( pData )
2124     {
2125         if ( pData->aHelpId.getLength() )
2126             aRet = pData->aHelpId;
2127         else
2128             aRet = ::rtl::OUStringToOString( pData->aCommandStr, RTL_TEXTENCODING_UTF8 );
2129     }
2130 
2131     return aRet;
2132 }
2133 
operator =(const Menu & rMenu)2134 Menu& Menu::operator=( const Menu& rMenu )
2135 {
2136     // Aufraeumen
2137     Clear();
2138 
2139     // Items kopieren
2140     sal_uInt16 nCount = rMenu.GetItemCount();
2141     for ( sal_uInt16 i = 0; i < nCount; i++ )
2142         ImplCopyItem( this, rMenu, i, MENU_APPEND, 1 );
2143 
2144     nDefaultItem = rMenu.nDefaultItem;
2145     aActivateHdl = rMenu.aActivateHdl;
2146     aDeactivateHdl = rMenu.aDeactivateHdl;
2147     aHighlightHdl = rMenu.aHighlightHdl;
2148     aSelectHdl = rMenu.aSelectHdl;
2149     aTitleText = rMenu.aTitleText;
2150     bIsMenuBar = rMenu.bIsMenuBar;
2151 
2152     return *this;
2153 }
2154 
ImplIsVisible(sal_uInt16 nPos) const2155 sal_Bool Menu::ImplIsVisible( sal_uInt16 nPos ) const
2156 {
2157     sal_Bool bVisible = sal_True;
2158 
2159     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
2160     // check general visibility first
2161     if( pData && !pData->bVisible )
2162         bVisible = sal_False;
2163 
2164     if ( bVisible && pData && pData->eType == MENUITEM_SEPARATOR )
2165     {
2166         if( nPos == 0 ) // no separator should be shown at the very beginning
2167             bVisible = sal_False;
2168         else
2169         {
2170             // always avoid adjacent separators
2171             sal_uInt16 nCount = (sal_uInt16) pItemList->Count();
2172             sal_uInt16 n;
2173             MenuItemData* pNextData = NULL;
2174             // search next visible item
2175             for( n = nPos + 1; n < nCount; n++ )
2176             {
2177                 pNextData = pItemList->GetDataFromPos( n );
2178                 if( pNextData && pNextData->bVisible )
2179                 {
2180                     if( pNextData->eType == MENUITEM_SEPARATOR || ImplIsVisible(n) )
2181                         break;
2182                 }
2183             }
2184             if( n == nCount ) // no next visible item
2185                 bVisible = sal_False;
2186             // check for separator
2187             if( pNextData && pNextData->bVisible && pNextData->eType == MENUITEM_SEPARATOR )
2188                 bVisible = sal_False;
2189 
2190             if( bVisible )
2191             {
2192                 for( n = nPos; n > 0; n-- )
2193                 {
2194                     pNextData = pItemList->GetDataFromPos( n-1 );
2195                     if( pNextData && pNextData->bVisible )
2196                     {
2197                         if( pNextData->eType != MENUITEM_SEPARATOR && ImplIsVisible(n-1) )
2198                             break;
2199                     }
2200                 }
2201                 if( n == 0 ) // no previous visible item
2202                     bVisible = sal_False;
2203             }
2204         }
2205     }
2206 
2207     // Fuer den Menubar nicht erlaubt, weil ich nicht mitbekomme
2208     // ob dadurch ein Eintrag verschwindet oder wieder da ist.
2209     if ( bVisible && !bIsMenuBar && ( nMenuFlags & MENU_FLAG_HIDEDISABLEDENTRIES ) &&
2210         !( nMenuFlags & MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ) )
2211     {
2212 		if( !pData ) // e.g. nPos == ITEMPOS_INVALID
2213 			bVisible = sal_False;
2214         else if ( pData->eType != MENUITEM_SEPARATOR ) // separators handled above
2215         {
2216             // bVisible = pData->bEnabled && ( !pData->pSubMenu || pData->pSubMenu->HasValidEntries( sal_True ) );
2217             bVisible = pData->bEnabled; // SubMenus nicht pruefen, weil sie ggf. erst im Activate() gefuellt werden.
2218         }
2219     }
2220 
2221     return bVisible;
2222 }
2223 
IsItemVisible(sal_uInt16 nItemId) const2224 sal_Bool Menu::IsItemVisible( sal_uInt16 nItemId ) const
2225 {
2226     return IsMenuVisible() && ImplIsVisible( GetItemPos( nItemId ) );
2227 }
2228 
IsItemPosVisible(sal_uInt16 nItemPos) const2229 sal_Bool Menu::IsItemPosVisible( sal_uInt16 nItemPos ) const
2230 {
2231     return IsMenuVisible() && ImplIsVisible( nItemPos );
2232 }
2233 
IsMenuVisible() const2234 sal_Bool Menu::IsMenuVisible() const
2235 {
2236     return pWindow && pWindow->IsReallyVisible();
2237 }
2238 
ImplIsSelectable(sal_uInt16 nPos) const2239 sal_Bool Menu::ImplIsSelectable( sal_uInt16 nPos ) const
2240 {
2241     sal_Bool bSelectable = sal_True;
2242 
2243     MenuItemData* pData = pItemList->GetDataFromPos( nPos );
2244     // check general visibility first
2245     if ( pData && ( pData->nBits & MIB_NOSELECT ) )
2246         bSelectable = sal_False;
2247 
2248     return bSelectable;
2249 }
2250 
SelectItem(sal_uInt16 nItemId)2251 void Menu::SelectItem( sal_uInt16 nItemId )
2252 {
2253     if( bIsMenuBar )
2254         static_cast<MenuBar*>(this)->SelectEntry( nItemId );
2255     else
2256         static_cast<PopupMenu*>(this)->SelectEntry( nItemId );
2257 }
2258 
GetAccessible()2259 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > Menu::GetAccessible()
2260 {
2261 	// Since PopupMenu are sometimes shared by different instances of MenuBar, the mxAccessible member gets
2262 	// overwritten and may contain a disposed object when the initial menubar gets set again. So use the
2263 	// mxAccessible member only for sub menus.
2264 	if ( pStartedFrom )
2265 	{
2266 		for ( sal_uInt16 i = 0, nCount = pStartedFrom->GetItemCount(); i < nCount; ++i )
2267 		{
2268 			sal_uInt16 nItemId = pStartedFrom->GetItemId( i );
2269 			if ( static_cast< Menu* >( pStartedFrom->GetPopupMenu( nItemId ) ) == this )
2270 			{
2271 				::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xParent = pStartedFrom->GetAccessible();
2272 				if ( xParent.is() )
2273 				{
2274 					::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
2275 					if ( xParentContext.is() )
2276 						return xParentContext->getAccessibleChild( i );
2277 				}
2278 			}
2279 		}
2280 	}
2281 	else if ( !mxAccessible.is() )
2282 	{
2283 		UnoWrapperBase* pWrapper = Application::GetUnoWrapper();
2284 		if ( pWrapper )
2285 			mxAccessible = pWrapper->CreateAccessible( this, bIsMenuBar );
2286 	}
2287 
2288 	return mxAccessible;
2289 }
2290 
SetAccessible(const::com::sun::star::uno::Reference<::com::sun::star::accessibility::XAccessible> & rxAccessible)2291 void Menu::SetAccessible( const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& rxAccessible )
2292 {
2293 	mxAccessible = rxAccessible;
2294 }
2295 
ImplGetNativeCheckAndRadioSize(Window * pWin,long & rCheckHeight,long & rRadioHeight,long & rMaxWidth) const2296 long Menu::ImplGetNativeCheckAndRadioSize( Window* pWin, long& rCheckHeight, long& rRadioHeight, long &rMaxWidth ) const
2297 {
2298     rMaxWidth = rCheckHeight = rRadioHeight = 0;
2299 
2300     if( ! bIsMenuBar )
2301     {
2302         ImplControlValue aVal;
2303         Rectangle aNativeBounds;
2304         Rectangle aNativeContent;
2305         Point tmp( 0, 0 );
2306         Rectangle aCtrlRegion( Rectangle( tmp, Size( 100, 15 ) ) );
2307         if( pWin->IsNativeControlSupported( CTRL_MENU_POPUP, PART_MENU_ITEM_CHECK_MARK ) )
2308         {
2309             if( pWin->GetNativeControlRegion( ControlType(CTRL_MENU_POPUP),
2310                                               ControlPart(PART_MENU_ITEM_CHECK_MARK),
2311                                               aCtrlRegion,
2312                                               ControlState(CTRL_STATE_ENABLED),
2313                                               aVal,
2314                                               OUString(),
2315                                               aNativeBounds,
2316                                               aNativeContent )
2317             )
2318             {
2319                 rCheckHeight = aNativeBounds.GetHeight();
2320 				rMaxWidth = aNativeContent.GetWidth();
2321             }
2322         }
2323         if( pWin->IsNativeControlSupported( CTRL_MENU_POPUP, PART_MENU_ITEM_RADIO_MARK ) )
2324         {
2325             if( pWin->GetNativeControlRegion( ControlType(CTRL_MENU_POPUP),
2326                                               ControlPart(PART_MENU_ITEM_RADIO_MARK),
2327                                               aCtrlRegion,
2328                                               ControlState(CTRL_STATE_ENABLED),
2329                                               aVal,
2330                                               OUString(),
2331                                               aNativeBounds,
2332                                               aNativeContent )
2333             )
2334             {
2335                 rRadioHeight = aNativeBounds.GetHeight();
2336 				rMaxWidth = Max (rMaxWidth, aNativeContent.GetWidth());
2337             }
2338         }
2339     }
2340     return (rCheckHeight > rRadioHeight) ? rCheckHeight : rRadioHeight;
2341 }
2342 
2343 // -----------------------------------------------------------------------
2344 
ImplAddDel(ImplMenuDelData & rDel)2345 void Menu::ImplAddDel( ImplMenuDelData& rDel )
2346 {
2347     DBG_ASSERT( !rDel.mpMenu, "Menu::ImplAddDel(): cannot add ImplMenuDelData twice !" );
2348     if( !rDel.mpMenu )
2349     {
2350         rDel.mpMenu = this;
2351         rDel.mpNext = mpFirstDel;
2352         mpFirstDel = &rDel;
2353     }
2354 }
2355 
2356 // -----------------------------------------------------------------------
2357 
ImplRemoveDel(ImplMenuDelData & rDel)2358 void Menu::ImplRemoveDel( ImplMenuDelData& rDel )
2359 {
2360     rDel.mpMenu = NULL;
2361     if ( mpFirstDel == &rDel )
2362 	{
2363         mpFirstDel = rDel.mpNext;
2364 	}
2365     else
2366     {
2367         ImplMenuDelData* pData = mpFirstDel;
2368         while ( pData && (pData->mpNext != &rDel) )
2369             pData = pData->mpNext;
2370 
2371 		DBG_ASSERT( pData, "Menu::ImplRemoveDel(): ImplMenuDelData not registered !" );
2372 		if( pData )
2373 			pData->mpNext = rDel.mpNext;
2374     }
2375 }
2376 
2377 // -----------------------------------------------------------------------
2378 
ImplCalcSize(Window * pWin)2379 Size Menu::ImplCalcSize( Window* pWin )
2380 {
2381     // | Checked| Image| Text| Accel/Popup|
2382 
2383     // Fuer Symbole: nFontHeight x nFontHeight
2384     long nFontHeight = pWin->GetTextHeight();
2385     long nExtra = nFontHeight/4;
2386 
2387 
2388     Size aSz;
2389     Size aMaxImgSz;
2390     long nMaxWidth = 0;
2391     long nMinMenuItemHeight = nFontHeight;
2392     long nCheckHeight = 0, nRadioHeight = 0;
2393 	long nCheckWidth = 0, nMaxCheckWidth = 0;
2394     long nMax = ImplGetNativeCheckAndRadioSize( pWin, nCheckHeight, nRadioHeight, nMaxCheckWidth );
2395     if( nMax > nMinMenuItemHeight )
2396         nMinMenuItemHeight = nMax;
2397 
2398 	const StyleSettings& rSettings = pWin->GetSettings().GetStyleSettings();
2399 	if ( rSettings.GetUseImagesInMenus() )
2400 	{
2401 		nMinMenuItemHeight = 16;
2402 		for ( sal_uInt16 i = (sal_uInt16)pItemList->Count(); i; )
2403 		{
2404 			MenuItemData* pData = pItemList->GetDataFromPos( --i );
2405 			if ( ImplIsVisible( i ) && (( pData->eType == MENUITEM_IMAGE ) || ( pData->eType == MENUITEM_STRINGIMAGE )))
2406 			{
2407 				Size aImgSz = pData->aImage.GetSizePixel();
2408 				if ( aImgSz.Height() > aMaxImgSz.Height() )
2409 					aMaxImgSz.Height() = aImgSz.Height();
2410 				if ( aImgSz.Height() > nMinMenuItemHeight )
2411 					nMinMenuItemHeight = aImgSz.Height();
2412 				break;
2413 			}
2414 		}
2415 	}
2416 
2417     for ( sal_uInt16 n = (sal_uInt16)pItemList->Count(); n; )
2418     {
2419         MenuItemData* pData = pItemList->GetDataFromPos( --n );
2420 
2421         pData->aSz.Height() = 0;
2422         pData->aSz.Width() = 0;
2423 
2424         if ( ImplIsVisible( n ) )
2425         {
2426             long nWidth = 0;
2427 
2428             // Separator
2429             if ( !bIsMenuBar && ( pData->eType == MENUITEM_SEPARATOR ) )
2430             {
2431                 DBG_ASSERT( !bIsMenuBar, "Separator in MenuBar ?! " );
2432                 pData->aSz.Height() = 4;
2433             }
2434 
2435             // Image:
2436             if ( !bIsMenuBar && ( ( pData->eType == MENUITEM_IMAGE ) || ( pData->eType == MENUITEM_STRINGIMAGE ) ) )
2437             {
2438                 Size aImgSz = pData->aImage.GetSizePixel();
2439                 aImgSz.Height() += 4; // add a border for native marks
2440                 aImgSz.Width() += 4; // add a border for native marks
2441                 if ( aImgSz.Width() > aMaxImgSz.Width() )
2442                     aMaxImgSz.Width() = aImgSz.Width();
2443                 if ( aImgSz.Height() > aMaxImgSz.Height() )
2444                     aMaxImgSz.Height() = aImgSz.Height();
2445                 if ( aImgSz.Height() > pData->aSz.Height() )
2446                     pData->aSz.Height() = aImgSz.Height();
2447             }
2448 
2449 			// Check Buttons:
2450 			if ( !bIsMenuBar && pData->HasCheck() )
2451 			{
2452 				nCheckWidth = nMaxCheckWidth;
2453 				if (nMenuFlags & MENU_FLAG_SHOWCHECKIMAGES)
2454                 {
2455                     // checks / images take the same place
2456                     if( ! ( ( pData->eType == MENUITEM_IMAGE ) || ( pData->eType == MENUITEM_STRINGIMAGE ) ) )
2457                         nWidth += nCheckWidth + nExtra * 2;
2458                 }
2459 			}
2460 
2461             // Text:
2462             if ( (pData->eType == MENUITEM_STRING) || (pData->eType == MENUITEM_STRINGIMAGE) )
2463             {
2464                 long nTextWidth = pWin->GetCtrlTextWidth( pData->aText );
2465                 long nTextHeight = pWin->GetTextHeight();
2466 
2467 //                if ( nTextHeight > pData->aSz.Height() )
2468 //                    pData->aSz.Height() = nTextHeight;
2469 
2470                 if ( bIsMenuBar )
2471                 {
2472 					if ( nTextHeight > pData->aSz.Height() )
2473 						pData->aSz.Height() = nTextHeight;
2474 
2475                     pData->aSz.Width() = nTextWidth + 4*nExtra;
2476                     aSz.Width() += pData->aSz.Width();
2477                 }
2478 				else
2479 					pData->aSz.Height() = Max( Max( nTextHeight, pData->aSz.Height() ), nMinMenuItemHeight );
2480 
2481                 nWidth += nTextWidth;
2482             }
2483 
2484             // Accel
2485             if ( !bIsMenuBar && pData->aAccelKey.GetCode() && !ImplAccelDisabled() )
2486             {
2487                 String aName = pData->aAccelKey.GetName();
2488                 long nAccWidth = pWin->GetTextWidth( aName );
2489                 nAccWidth += nExtra;
2490                 nWidth += nAccWidth;
2491             }
2492 
2493             // SubMenu?
2494             if ( !bIsMenuBar && pData->pSubMenu )
2495             {
2496                     if ( nFontHeight > nWidth )
2497                         nWidth += nFontHeight;
2498 
2499 				pData->aSz.Height() = Max( Max( nFontHeight, pData->aSz.Height() ), nMinMenuItemHeight );
2500             }
2501 
2502             pData->aSz.Height() += EXTRAITEMHEIGHT; // Etwas mehr Abstand:
2503 
2504             if ( !bIsMenuBar )
2505                 aSz.Height() += (long)pData->aSz.Height();
2506 
2507             if ( nWidth > nMaxWidth )
2508                 nMaxWidth = nWidth;
2509 
2510         }
2511     }
2512 
2513     if ( !bIsMenuBar )
2514     {
2515         // popup menus should not be wider than half the screen
2516         // except on rather small screens
2517         // TODO: move GetScreenNumber from SystemWindow to Window ?
2518         // currently we rely on internal privileges
2519         unsigned int nScreenNumber = pWin->ImplGetWindowImpl()->mpFrame->maGeometry.nScreenNumber;
2520         Rectangle aDispRect( Application::GetScreenPosSizePixel( nScreenNumber ) );
2521         long nScreenWidth = aDispRect.GetWidth() >= 800 ? aDispRect.GetWidth() : 800;
2522         if( nMaxWidth > nScreenWidth/2 )
2523             nMaxWidth = nScreenWidth/2;
2524 
2525         sal_uInt16 gfxExtra = (sal_uInt16) Max( nExtra, 7L ); // #107710# increase space between checkmarks/images/text
2526         nCheckPos = (sal_uInt16)nExtra;
2527 		if (nMenuFlags & MENU_FLAG_SHOWCHECKIMAGES)
2528 		{
2529             long nImgOrChkWidth = 0;
2530             nImagePos = nCheckPos;
2531             if( nMax > 0 ) // NWF case
2532                 nImgOrChkWidth = nMax + nExtra;
2533             else // non NWF case
2534                 nImgOrChkWidth = nFontHeight/2 + gfxExtra;
2535             nImgOrChkWidth = Max( nImgOrChkWidth, aMaxImgSz.Width() + gfxExtra );
2536             nTextPos = (sal_uInt16)(nImagePos + nImgOrChkWidth);
2537 		}
2538 		else
2539 		{
2540 			nImagePos = nCheckPos;
2541 			nTextPos = (sal_uInt16)(nImagePos + Max( aMaxImgSz.Width(), nCheckWidth ));
2542 		}
2543 		nTextPos = nTextPos + gfxExtra;
2544 
2545         aSz.Width() = nTextPos + nMaxWidth + nExtra;
2546         aSz.Width() += 4*nExtra;   // a _little_ more ...
2547 
2548         int nOuterSpace = ImplGetSVData()->maNWFData.mnMenuFormatExtraBorder;
2549         aSz.Width() += 2*nOuterSpace;
2550         aSz.Height() += 2*nOuterSpace;
2551     }
2552     else
2553     {
2554         nTextPos = (sal_uInt16)(2*nExtra);
2555         aSz.Height() = nFontHeight+6;
2556 
2557         // get menubar height from native methods if supported
2558         if( pWindow->IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL ) )
2559         {
2560             ImplControlValue aVal;
2561             Rectangle aNativeBounds;
2562             Rectangle aNativeContent;
2563             Point tmp( 0, 0 );
2564             Rectangle aCtrlRegion( tmp, Size( 100, 15 ) );
2565             if( pWindow->GetNativeControlRegion( ControlType(CTRL_MENUBAR),
2566                                                  ControlPart(PART_ENTIRE_CONTROL),
2567                                                  aCtrlRegion,
2568                                                  ControlState(CTRL_STATE_ENABLED),
2569                                                  aVal,
2570                                                  OUString(),
2571                                                  aNativeBounds,
2572                                                  aNativeContent )
2573             )
2574             {
2575                 int nNativeHeight = aNativeBounds.GetHeight();
2576                 if( nNativeHeight > aSz.Height() )
2577                     aSz.Height() = nNativeHeight;
2578             }
2579         }
2580 
2581         // account for the size of the close button, which actually is a toolbox
2582         // due to NWF this is variable
2583         long nCloserHeight = ((MenuBarWindow*) pWindow)->MinCloseButtonSize().Height();
2584         if( aSz.Height() < nCloserHeight )
2585             aSz.Height() = nCloserHeight;
2586     }
2587 
2588     if ( pLogo )
2589         aSz.Width() += pLogo->aBitmap.GetSizePixel().Width();
2590 
2591     return aSz;
2592 }
2593 
ImplPaintCheckBackground(Window * i_pWindow,const Rectangle & i_rRect,bool i_bHighlight)2594 static void ImplPaintCheckBackground( Window* i_pWindow, const Rectangle& i_rRect, bool i_bHighlight )
2595 {
2596     sal_Bool bNativeOk = sal_False;
2597     if( i_pWindow->IsNativeControlSupported( CTRL_TOOLBAR, PART_BUTTON ) )
2598     {
2599         ImplControlValue    aControlValue;
2600         Rectangle           aCtrlRegion( i_rRect );
2601         ControlState        nState = CTRL_STATE_PRESSED | CTRL_STATE_ENABLED;
2602 
2603         aControlValue.setTristateVal( BUTTONVALUE_ON );
2604 
2605         bNativeOk = i_pWindow->DrawNativeControl( CTRL_TOOLBAR, PART_BUTTON,
2606                                                   aCtrlRegion, nState, aControlValue,
2607                                                   rtl::OUString() );
2608     }
2609 
2610     if( ! bNativeOk )
2611     {
2612         const StyleSettings& rSettings = i_pWindow->GetSettings().GetStyleSettings();
2613         Color aColor( i_bHighlight ? rSettings.GetMenuHighlightTextColor() : rSettings.GetHighlightColor() );
2614         i_pWindow->DrawSelectionBackground( i_rRect, 0, i_bHighlight, sal_True, sal_False, 2, NULL, &aColor );
2615     }
2616 }
2617 
getShortenedString(const String & i_rLong,Window * i_pWin,long i_nMaxWidth)2618 static String getShortenedString( const String& i_rLong, Window* i_pWin, long i_nMaxWidth )
2619 {
2620     xub_StrLen nPos = STRING_NOTFOUND;
2621     String aNonMnem( OutputDevice::GetNonMnemonicString( i_rLong, nPos ) );
2622     aNonMnem = i_pWin->GetEllipsisString( aNonMnem, i_nMaxWidth, TEXT_DRAW_CENTERELLIPSIS );
2623     // re-insert mnemonic
2624     if( nPos != STRING_NOTFOUND )
2625     {
2626         if( nPos < aNonMnem.Len() && i_rLong.GetChar(nPos+1) == aNonMnem.GetChar(nPos) )
2627         {
2628             rtl::OUStringBuffer aBuf( i_rLong.Len() );
2629             aBuf.append( aNonMnem.GetBuffer(), nPos );
2630             aBuf.append( sal_Unicode('~') );
2631             aBuf.append( aNonMnem.GetBuffer()+nPos );
2632             aNonMnem = aBuf.makeStringAndClear();
2633         }
2634     }
2635     return aNonMnem;
2636 }
2637 
ImplPaint(Window * pWin,sal_uInt16 nBorder,long nStartY,MenuItemData * pThisItemOnly,sal_Bool bHighlighted,bool bLayout) const2638 void Menu::ImplPaint( Window* pWin, sal_uInt16 nBorder, long nStartY, MenuItemData* pThisItemOnly, sal_Bool bHighlighted, bool bLayout ) const
2639 {
2640     // Fuer Symbole: nFontHeight x nFontHeight
2641     long nFontHeight = pWin->GetTextHeight();
2642     long nExtra = nFontHeight/4;
2643 
2644     long nCheckHeight = 0, nRadioHeight = 0, nMaxCheckWidth = 0;
2645     ImplGetNativeCheckAndRadioSize( pWin, nCheckHeight, nRadioHeight, nMaxCheckWidth );
2646 
2647     DecorationView aDecoView( pWin );
2648     const StyleSettings& rSettings = pWin->GetSettings().GetStyleSettings();
2649 
2650     Point aTopLeft, aTmpPos;
2651 
2652     if ( pLogo )
2653         aTopLeft.X() = pLogo->aBitmap.GetSizePixel().Width();
2654 
2655     int nOuterSpace = 0;
2656     if( !bIsMenuBar )
2657     {
2658         nOuterSpace = ImplGetSVData()->maNWFData.mnMenuFormatExtraBorder;
2659         aTopLeft.X() += nOuterSpace;
2660         aTopLeft.Y() += nOuterSpace;
2661     }
2662 
2663     Size aOutSz = pWin->GetOutputSizePixel();
2664     sal_uInt16 nCount = (sal_uInt16)pItemList->Count();
2665     if( bLayout )
2666         mpLayoutData->m_aVisibleItemBoundRects.clear();
2667     for ( sal_uInt16 n = 0; n < nCount; n++ )
2668     {
2669         MenuItemData* pData = pItemList->GetDataFromPos( n );
2670         if ( ImplIsVisible( n ) && ( !pThisItemOnly || ( pData == pThisItemOnly ) ) )
2671         {
2672             if ( pThisItemOnly && bHighlighted )
2673                 pWin->SetTextColor( rSettings.GetMenuHighlightTextColor() );
2674 
2675             Point aPos( aTopLeft );
2676             aPos.Y() += nBorder;
2677             aPos.Y() += nStartY;
2678 
2679             if ( aPos.Y() >= 0 )
2680             {
2681                 long    nTextOffsetY = ((pData->aSz.Height()-nFontHeight)/2);
2682                 if( bIsMenuBar )
2683                     nTextOffsetY += (aOutSz.Height()-pData->aSz.Height()) / 2;
2684                 sal_uInt16  nTextStyle   = 0;
2685                 sal_uInt16  nSymbolStyle = 0;
2686                 sal_uInt16  nImageStyle  = 0;
2687                 // SubMenus ohne Items werden nicht mehr disablte dargestellt,
2688                 // wenn keine Items enthalten sind, da die Anwendung selber
2689                 // darauf achten muss. Ansonsten gibt es Faelle, wo beim
2690                 // asyncronen laden die Eintraege disablte dargestellt werden.
2691                 if ( !pData->bEnabled )
2692                 {
2693                     nTextStyle   |= TEXT_DRAW_DISABLE;
2694                     nSymbolStyle |= SYMBOL_DRAW_DISABLE;
2695                     nImageStyle  |= IMAGE_DRAW_DISABLE;
2696                 }
2697 
2698                 // Separator
2699                 if ( !bLayout && !bIsMenuBar && ( pData->eType == MENUITEM_SEPARATOR ) )
2700                 {
2701                     bool bNativeOk = false;
2702                     if( pWin->IsNativeControlSupported( CTRL_MENU_POPUP,
2703                                                         PART_MENU_SEPARATOR ) )
2704                     {
2705                         ControlState nState = 0;
2706                         if ( pData->bEnabled )
2707                             nState |= CTRL_STATE_ENABLED;
2708                         if ( bHighlighted )
2709                             nState |= CTRL_STATE_SELECTED;
2710 						Size aSz( pData->aSz );
2711 						aSz.Width() = aOutSz.Width() - 2*nOuterSpace;
2712                         Rectangle aItemRect( aPos, aSz );
2713                         MenupopupValue aVal( nTextPos-GUTTERBORDER, aItemRect );
2714                         bNativeOk = pWin->DrawNativeControl( CTRL_MENU_POPUP, PART_MENU_SEPARATOR,
2715                                                              aItemRect,
2716                                                              nState,
2717                                                              aVal,
2718                                                              OUString() );
2719                     }
2720                     if( ! bNativeOk )
2721                     {
2722                         aTmpPos.Y() = aPos.Y() + ((pData->aSz.Height()-2)/2);
2723                         aTmpPos.X() = aPos.X() + 2 + nOuterSpace;
2724                         pWin->SetLineColor( rSettings.GetShadowColor() );
2725                         pWin->DrawLine( aTmpPos, Point( aOutSz.Width() - 3 - 2*nOuterSpace, aTmpPos.Y() ) );
2726                         aTmpPos.Y()++;
2727                         pWin->SetLineColor( rSettings.GetLightColor() );
2728                         pWin->DrawLine( aTmpPos, Point( aOutSz.Width() - 3 - 2*nOuterSpace, aTmpPos.Y() ) );
2729                         pWin->SetLineColor();
2730                     }
2731                 }
2732 
2733                 Rectangle aOuterCheckRect( Point( aPos.X()+nCheckPos, aPos.Y() ), Size( pData->aSz.Height(), pData->aSz.Height() ) );
2734                 aOuterCheckRect.Left()      += 1;
2735                 aOuterCheckRect.Right()     -= 1;
2736                 aOuterCheckRect.Top()       += 1;
2737                 aOuterCheckRect.Bottom()    -= 1;
2738 
2739                 // CheckMark
2740                 if ( !bLayout && !bIsMenuBar && pData->HasCheck() )
2741                 {
2742                     // draw selection transparent marker if checked
2743                     // onto that either a checkmark or the item image
2744                     // will be painted
2745                     // however do not do this if native checks will be painted since
2746                     // the selection color too often does not fit the theme's check and/or radio
2747 
2748                     if( ! ( ( pData->eType == MENUITEM_IMAGE ) || ( pData->eType == MENUITEM_STRINGIMAGE ) ) )
2749                     {
2750                         if ( pWin->IsNativeControlSupported( CTRL_MENU_POPUP,
2751                                                              (pData->nBits & MIB_RADIOCHECK)
2752                                                              ? PART_MENU_ITEM_CHECK_MARK
2753                                                              : PART_MENU_ITEM_RADIO_MARK ) )
2754                         {
2755                             ControlPart nPart = ((pData->nBits & MIB_RADIOCHECK)
2756                                                  ? PART_MENU_ITEM_RADIO_MARK
2757                                                  : PART_MENU_ITEM_CHECK_MARK);
2758 
2759                             ControlState nState = 0;
2760 
2761                             if ( pData->bChecked )
2762                                 nState |= CTRL_STATE_PRESSED;
2763 
2764                             if ( pData->bEnabled )
2765                                 nState |= CTRL_STATE_ENABLED;
2766 
2767                             if ( bHighlighted )
2768                                 nState |= CTRL_STATE_SELECTED;
2769 
2770                             long nCtrlHeight = (pData->nBits & MIB_RADIOCHECK) ? nCheckHeight : nRadioHeight;
2771                             aTmpPos.X() = aOuterCheckRect.Left() + (aOuterCheckRect.GetWidth() - nCtrlHeight)/2;
2772                             aTmpPos.Y() = aOuterCheckRect.Top() + (aOuterCheckRect.GetHeight() - nCtrlHeight)/2;
2773 
2774                             Rectangle aCheckRect( aTmpPos, Size( nCtrlHeight, nCtrlHeight ) );
2775                             MenupopupValue aVal( nTextPos-GUTTERBORDER, Rectangle( aPos, pData->aSz ) );
2776                             pWin->DrawNativeControl( CTRL_MENU_POPUP, nPart,
2777                                                      aCheckRect,
2778                                                      nState,
2779                                                      aVal,
2780                                                      OUString() );
2781                         }
2782                         else if ( pData->bChecked ) // by default do nothing for unchecked items
2783                         {
2784                             ImplPaintCheckBackground( pWin, aOuterCheckRect, pThisItemOnly && bHighlighted );
2785 
2786                             SymbolType eSymbol;
2787                             Size aSymbolSize;
2788                             if ( pData->nBits & MIB_RADIOCHECK )
2789                             {
2790                                 eSymbol = SYMBOL_RADIOCHECKMARK;
2791                                 aSymbolSize = Size( nFontHeight/2, nFontHeight/2 );
2792                             }
2793                             else
2794                             {
2795                                 eSymbol = SYMBOL_CHECKMARK;
2796                                 aSymbolSize = Size( (nFontHeight*25)/40, nFontHeight/2 );
2797                             }
2798                             aTmpPos.X() = aOuterCheckRect.Left() + (aOuterCheckRect.GetWidth() - aSymbolSize.Width())/2;
2799                             aTmpPos.Y() = aOuterCheckRect.Top() + (aOuterCheckRect.GetHeight() - aSymbolSize.Height())/2;
2800                             Rectangle aRect( aTmpPos, aSymbolSize );
2801                             aDecoView.DrawSymbol( aRect, eSymbol, pWin->GetTextColor(), nSymbolStyle );
2802                         }
2803                     }
2804                 }
2805 
2806                 // Image:
2807                 if ( !bLayout && !bIsMenuBar && ( ( pData->eType == MENUITEM_IMAGE ) || ( pData->eType == MENUITEM_STRINGIMAGE ) ) )
2808                 {
2809 					// Don't render an image for a check thing
2810 					if ((nMenuFlags & MENU_FLAG_SHOWCHECKIMAGES) || !pData->HasCheck() )
2811 					{
2812                         if( pData->bChecked )
2813                             ImplPaintCheckBackground( pWin, aOuterCheckRect, pThisItemOnly && bHighlighted );
2814                         aTmpPos = aOuterCheckRect.TopLeft();
2815 	                    aTmpPos.X() += (aOuterCheckRect.GetWidth()-pData->aImage.GetSizePixel().Width())/2;
2816 	                    aTmpPos.Y() += (aOuterCheckRect.GetHeight()-pData->aImage.GetSizePixel().Height())/2;
2817 	                    pWin->DrawImage( aTmpPos, pData->aImage, nImageStyle );
2818 					}
2819                 }
2820 
2821                 // Text:
2822                 if ( ( pData->eType == MENUITEM_STRING ) || ( pData->eType == MENUITEM_STRINGIMAGE ) )
2823                 {
2824                     aTmpPos.X() = aPos.X() + nTextPos;
2825                     aTmpPos.Y() = aPos.Y();
2826                     aTmpPos.Y() += nTextOffsetY;
2827                     sal_uInt16 nStyle = nTextStyle|TEXT_DRAW_MNEMONIC;
2828                     if ( pData->bIsTemporary )
2829                         nStyle |= TEXT_DRAW_DISABLE;
2830                     MetricVector* pVector = bLayout ? &mpLayoutData->m_aUnicodeBoundRects : NULL;
2831                     String* pDisplayText = bLayout ? &mpLayoutData->m_aDisplayText : NULL;
2832                     if( bLayout )
2833                     {
2834                         mpLayoutData->m_aLineIndices.push_back( mpLayoutData->m_aDisplayText.Len() );
2835                         mpLayoutData->m_aLineItemIds.push_back( pData->nId );
2836                         mpLayoutData->m_aLineItemPositions.push_back( n );
2837                     }
2838                     // #i47946# with NWF painted menus the background is transparent
2839                     // since DrawCtrlText can depend on the background (e.g. for
2840                     // TEXT_DRAW_DISABLE), temporarily set a background which
2841                     // hopefully matches the NWF background since it is read
2842                     // from the system style settings
2843                     bool bSetTmpBackground = !pWin->IsBackground() && pWin->IsNativeControlSupported( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL );
2844                     if( bSetTmpBackground )
2845                     {
2846                         Color aBg = bIsMenuBar ?
2847                             pWin->GetSettings().GetStyleSettings().GetMenuBarColor() :
2848                             pWin->GetSettings().GetStyleSettings().GetMenuColor();
2849                         pWin->SetBackground( Wallpaper( aBg ) );
2850                     }
2851                     // how much space is there for the text ?
2852                     long nMaxItemTextWidth = aOutSz.Width() - aTmpPos.X() - nExtra - nOuterSpace;
2853                     if( !bIsMenuBar && pData->aAccelKey.GetCode() && !ImplAccelDisabled() )
2854                     {
2855                         XubString aAccText = pData->aAccelKey.GetName();
2856                         nMaxItemTextWidth -= pWin->GetTextWidth( aAccText ) + 3*nExtra;
2857                     }
2858                     if( !bIsMenuBar && pData->pSubMenu )
2859                     {
2860                         nMaxItemTextWidth -= nFontHeight - nExtra;
2861                     }
2862                     String aItemText( getShortenedString( pData->aText, pWin, nMaxItemTextWidth ) );
2863                     pWin->DrawCtrlText( aTmpPos, aItemText, 0, aItemText.Len(), nStyle, pVector, pDisplayText );
2864                     if( bSetTmpBackground )
2865                         pWin->SetBackground();
2866                 }
2867 
2868                 // Accel
2869                 if ( !bLayout && !bIsMenuBar && pData->aAccelKey.GetCode() && !ImplAccelDisabled() )
2870                 {
2871                     XubString aAccText = pData->aAccelKey.GetName();
2872                     aTmpPos.X() = aOutSz.Width() - pWin->GetTextWidth( aAccText );
2873                     aTmpPos.X() -= 4*nExtra;
2874 
2875                     aTmpPos.X() -= nOuterSpace;
2876                     aTmpPos.Y() = aPos.Y();
2877                     aTmpPos.Y() += nTextOffsetY;
2878                     pWin->DrawCtrlText( aTmpPos, aAccText, 0, aAccText.Len(), nTextStyle );
2879                 }
2880 
2881                 // SubMenu?
2882                 if ( !bLayout && !bIsMenuBar && pData->pSubMenu )
2883                 {
2884                     aTmpPos.X() = aOutSz.Width() - nFontHeight + nExtra - nOuterSpace;
2885                     aTmpPos.Y() = aPos.Y();
2886                     aTmpPos.Y() += nExtra/2;
2887                     aTmpPos.Y() += ( pData->aSz.Height() / 2 ) - ( nFontHeight/4 );
2888                     if ( pData->nBits & MIB_POPUPSELECT )
2889                     {
2890                         pWin->SetTextColor( rSettings.GetMenuTextColor() );
2891                         Point aTmpPos2( aPos );
2892                         aTmpPos2.X() = aOutSz.Width() - nFontHeight - nFontHeight/4;
2893                         aDecoView.DrawFrame(
2894                             Rectangle( aTmpPos2, Size( nFontHeight+nFontHeight/4, pData->aSz.Height() ) ), FRAME_DRAW_GROUP );
2895                     }
2896                     aDecoView.DrawSymbol(
2897                         Rectangle( aTmpPos, Size( nFontHeight/2, nFontHeight/2 ) ),
2898                         SYMBOL_SPIN_RIGHT, pWin->GetTextColor(), nSymbolStyle );
2899                 }
2900 
2901                 if ( pThisItemOnly && bHighlighted )
2902                 {
2903                     // This restores the normal menu or menu bar text
2904                     // color for when it is no longer highlighted.
2905 		    if ( bIsMenuBar )
2906 		        pWin->SetTextColor( rSettings.GetMenuBarTextColor() );
2907 		    else
2908 		        pWin->SetTextColor( rSettings.GetMenuTextColor() );
2909 		 }
2910             }
2911             if( bLayout )
2912             {
2913                 if ( !bIsMenuBar )
2914                     mpLayoutData->m_aVisibleItemBoundRects[ n ] = Rectangle( aTopLeft, Size( aOutSz.Width(), pData->aSz.Height() ) );
2915                 else
2916                     mpLayoutData->m_aVisibleItemBoundRects[ n ] = Rectangle( aTopLeft, pData->aSz );
2917             }
2918         }
2919 
2920         if ( !bIsMenuBar )
2921         {
2922             aTopLeft.Y() += pData->aSz.Height();
2923         }
2924         else
2925         {
2926             aTopLeft.X() += pData->aSz.Width();
2927         }
2928     }
2929 
2930     if ( !bLayout && !pThisItemOnly && pLogo )
2931     {
2932         Size aLogoSz = pLogo->aBitmap.GetSizePixel();
2933 
2934         Rectangle aRect( Point( 0, 0 ), Point( aLogoSz.Width()-1, aOutSz.Height() ) );
2935         if ( pWin->GetColorCount() >= 256 )
2936         {
2937             Gradient aGrad( GRADIENT_LINEAR, pLogo->aStartColor, pLogo->aEndColor );
2938             aGrad.SetAngle( 1800 );
2939             aGrad.SetBorder( 15 );
2940             pWin->DrawGradient( aRect, aGrad );
2941         }
2942         else
2943         {
2944             pWin->SetFillColor( pLogo->aStartColor );
2945             pWin->DrawRect( aRect );
2946         }
2947 
2948         Point aLogoPos( 0, aOutSz.Height() - aLogoSz.Height() );
2949         pLogo->aBitmap.Draw( pWin, aLogoPos );
2950     }
2951 }
2952 
ImplGetStartMenu()2953 Menu* Menu::ImplGetStartMenu()
2954 {
2955     Menu* pStart = this;
2956     while ( pStart && pStart->pStartedFrom && ( pStart->pStartedFrom != pStart ) )
2957         pStart = pStart->pStartedFrom;
2958     return pStart;
2959 }
2960 
ImplCallHighlight(sal_uInt16 nHighlightedItem)2961 void Menu::ImplCallHighlight( sal_uInt16 nHighlightedItem )
2962 {
2963 	ImplMenuDelData aDelData( this );
2964 
2965     nSelectedId = 0;
2966     MenuItemData* pData = pItemList->GetDataFromPos( nHighlightedItem );
2967     if ( pData )
2968         nSelectedId = pData->nId;
2969     ImplCallEventListeners( VCLEVENT_MENU_HIGHLIGHT, GetItemPos( GetCurItemId() ) );
2970 
2971 	if( !aDelData.isDeleted() )
2972 	{
2973 	    Highlight();
2974 		nSelectedId = 0;
2975 	}
2976 }
2977 
IMPL_LINK(Menu,ImplCallSelect,Menu *,EMPTYARG)2978 IMPL_LINK( Menu, ImplCallSelect, Menu*, EMPTYARG )
2979 {
2980     nEventId = 0;
2981     Select();
2982     return 0;
2983 }
2984 
ImplFindSelectMenu()2985 Menu* Menu::ImplFindSelectMenu()
2986 {
2987     Menu* pSelMenu = nEventId ? this : NULL;
2988 
2989     for ( sal_uLong n = GetItemList()->Count(); n && !pSelMenu; )
2990     {
2991         MenuItemData* pData = GetItemList()->GetDataFromPos( --n );
2992 
2993         if ( pData->pSubMenu )
2994             pSelMenu = pData->pSubMenu->ImplFindSelectMenu();
2995     }
2996 
2997     return pSelMenu;
2998 }
2999 
ImplFindMenu(sal_uInt16 nItemId)3000 Menu* Menu::ImplFindMenu( sal_uInt16 nItemId )
3001 {
3002     Menu* pSelMenu = NULL;
3003 
3004     for ( sal_uLong n = GetItemList()->Count(); n && !pSelMenu; )
3005     {
3006         MenuItemData* pData = GetItemList()->GetDataFromPos( --n );
3007 
3008         if( pData->nId == nItemId )
3009             pSelMenu = this;
3010         else if ( pData->pSubMenu )
3011             pSelMenu = pData->pSubMenu->ImplFindMenu( nItemId );
3012     }
3013 
3014     return pSelMenu;
3015 }
3016 
RemoveDisabledEntries(sal_Bool bCheckPopups,sal_Bool bRemoveEmptyPopups)3017 void Menu::RemoveDisabledEntries( sal_Bool bCheckPopups, sal_Bool bRemoveEmptyPopups )
3018 {
3019     for ( sal_uInt16 n = 0; n < GetItemCount(); n++ )
3020     {
3021         sal_Bool bRemove = sal_False;
3022         MenuItemData* pItem = pItemList->GetDataFromPos( n );
3023         if ( pItem->eType == MENUITEM_SEPARATOR )
3024         {
3025             if ( !n || ( GetItemType( n-1 ) == MENUITEM_SEPARATOR ) )
3026                 bRemove = sal_True;
3027         }
3028         else
3029             bRemove = !pItem->bEnabled;
3030 
3031         if ( bCheckPopups && pItem->pSubMenu )
3032         {
3033             pItem->pSubMenu->RemoveDisabledEntries( sal_True );
3034             if ( bRemoveEmptyPopups && !pItem->pSubMenu->GetItemCount() )
3035                 bRemove = sal_True;
3036         }
3037 
3038         if ( bRemove )
3039             RemoveItem( n-- );
3040     }
3041 
3042     if ( GetItemCount() )
3043     {
3044         sal_uInt16 nLast = GetItemCount() - 1;
3045         MenuItemData* pItem = pItemList->GetDataFromPos( nLast );
3046         if ( pItem->eType == MENUITEM_SEPARATOR )
3047             RemoveItem( nLast );
3048     }
3049     delete mpLayoutData, mpLayoutData = NULL;
3050 }
3051 
HasValidEntries(sal_Bool bCheckPopups)3052 sal_Bool Menu::HasValidEntries( sal_Bool bCheckPopups )
3053 {
3054     sal_Bool bValidEntries = sal_False;
3055     sal_uInt16 nCount = GetItemCount();
3056     for ( sal_uInt16 n = 0; !bValidEntries && ( n < nCount ); n++ )
3057     {
3058         MenuItemData* pItem = pItemList->GetDataFromPos( n );
3059         if ( pItem->bEnabled && ( pItem->eType != MENUITEM_SEPARATOR ) )
3060         {
3061             if ( bCheckPopups && pItem->pSubMenu )
3062                 bValidEntries = pItem->pSubMenu->HasValidEntries( sal_True );
3063             else
3064                 bValidEntries = sal_True;
3065         }
3066     }
3067     return bValidEntries;
3068 }
3069 
SetLogo(const MenuLogo & rLogo)3070 void Menu::SetLogo( const MenuLogo& rLogo )
3071 {
3072     delete pLogo;
3073     pLogo = new MenuLogo( rLogo );
3074 }
3075 
SetLogo()3076 void Menu::SetLogo()
3077 {
3078     delete pLogo;
3079     pLogo = NULL;
3080 }
3081 
GetLogo() const3082 MenuLogo Menu::GetLogo() const
3083 {
3084     MenuLogo aLogo;
3085     if ( pLogo )
3086         aLogo = *pLogo;
3087     return aLogo;
3088 }
3089 
ImplKillLayoutData() const3090 void Menu::ImplKillLayoutData() const
3091 {
3092     delete mpLayoutData, mpLayoutData = NULL;
3093 }
3094 
ImplFillLayoutData() const3095 void Menu::ImplFillLayoutData() const
3096 {
3097     if( pWindow && pWindow->IsReallyVisible() )
3098     {
3099         mpLayoutData = new MenuLayoutData();
3100         if( bIsMenuBar )
3101         {
3102             ImplPaint( pWindow, 0, 0, 0, sal_False, true );
3103         }
3104         else
3105         {
3106             MenuFloatingWindow* pFloat = (MenuFloatingWindow*)pWindow;
3107             ImplPaint( pWindow, pFloat->nScrollerHeight, pFloat->ImplGetStartY(), 0, sal_False, true );
3108         }
3109     }
3110 }
3111 
GetDisplayText() const3112 String Menu::GetDisplayText() const
3113 {
3114     if( ! mpLayoutData )
3115         ImplFillLayoutData();
3116     return mpLayoutData ? mpLayoutData->m_aDisplayText : String();
3117 }
3118 
GetCharacterBounds(sal_uInt16 nItemID,long nIndex) const3119 Rectangle Menu::GetCharacterBounds( sal_uInt16 nItemID, long nIndex ) const
3120 {
3121     long nItemIndex = -1;
3122     if( ! mpLayoutData )
3123         ImplFillLayoutData();
3124     if( mpLayoutData )
3125     {
3126         for( size_t i = 0; i < mpLayoutData->m_aLineItemIds.size(); i++ )
3127         {
3128             if( mpLayoutData->m_aLineItemIds[i] == nItemID )
3129             {
3130                 nItemIndex = mpLayoutData->m_aLineIndices[i];
3131                 break;
3132             }
3133         }
3134     }
3135     return (mpLayoutData && nItemIndex != -1) ? mpLayoutData->GetCharacterBounds( nItemIndex+nIndex ) : Rectangle();
3136 }
3137 
3138 
GetIndexForPoint(const Point & rPoint,sal_uInt16 & rItemID) const3139 long Menu::GetIndexForPoint( const Point& rPoint, sal_uInt16& rItemID ) const
3140 {
3141     long nIndex = -1;
3142     rItemID = 0;
3143     if( ! mpLayoutData )
3144         ImplFillLayoutData();
3145     if( mpLayoutData )
3146     {
3147         nIndex = mpLayoutData->GetIndexForPoint( rPoint );
3148         for( size_t i = 0; i < mpLayoutData->m_aLineIndices.size(); i++ )
3149         {
3150             if( mpLayoutData->m_aLineIndices[i] <= nIndex &&
3151                 (i == mpLayoutData->m_aLineIndices.size()-1 || mpLayoutData->m_aLineIndices[i+1] > nIndex) )
3152             {
3153                 // make index relative to item
3154                 nIndex -= mpLayoutData->m_aLineIndices[i];
3155                 rItemID = mpLayoutData->m_aLineItemIds[i];
3156                 break;
3157             }
3158         }
3159     }
3160     return nIndex;
3161 }
3162 
GetLineCount() const3163 long Menu::GetLineCount() const
3164 {
3165     if( ! mpLayoutData )
3166         ImplFillLayoutData();
3167     return mpLayoutData ? mpLayoutData->GetLineCount() : 0;
3168 }
3169 
GetLineStartEnd(long nLine) const3170 Pair Menu::GetLineStartEnd( long nLine ) const
3171 {
3172     if( ! mpLayoutData )
3173         ImplFillLayoutData();
3174     return mpLayoutData ? mpLayoutData->GetLineStartEnd( nLine ) : Pair( -1, -1 );
3175 }
3176 
GetItemStartEnd(sal_uInt16 nItem) const3177 Pair Menu::GetItemStartEnd( sal_uInt16 nItem ) const
3178 {
3179     if( ! mpLayoutData )
3180         ImplFillLayoutData();
3181 
3182     for( size_t i = 0; i < mpLayoutData->m_aLineItemIds.size(); i++ )
3183         if( mpLayoutData->m_aLineItemIds[i] == nItem )
3184             return GetLineStartEnd( i );
3185 
3186     return Pair( -1, -1 );
3187 }
3188 
GetDisplayItemId(long nLine) const3189 sal_uInt16 Menu::GetDisplayItemId( long nLine ) const
3190 {
3191     sal_uInt16 nItemId = 0;
3192     if( ! mpLayoutData )
3193         ImplFillLayoutData();
3194     if( mpLayoutData && ( nLine >= 0 ) && ( nLine < (long)mpLayoutData->m_aLineItemIds.size() ) )
3195         nItemId = mpLayoutData->m_aLineItemIds[nLine];
3196     return nItemId;
3197 }
3198 
ConvertPoint(Point & rPoint,Window * pReferenceWindow) const3199 sal_Bool Menu::ConvertPoint( Point& rPoint, Window* pReferenceWindow ) const
3200 {
3201     sal_Bool bRet = sal_False;
3202     if( pWindow && pReferenceWindow )
3203     {
3204         rPoint = pReferenceWindow->OutputToAbsoluteScreenPixel( rPoint );
3205         rPoint = pWindow->AbsoluteScreenToOutputPixel( rPoint );
3206         bRet = sal_True;
3207     }
3208     return bRet;
3209 }
3210 
GetBoundingRectangle(sal_uInt16 nPos) const3211 Rectangle Menu::GetBoundingRectangle( sal_uInt16 nPos ) const
3212 {
3213     Rectangle aRet;
3214 
3215     if( ! mpLayoutData )
3216         ImplFillLayoutData();
3217     if( mpLayoutData )
3218     {
3219         std::map< sal_uInt16, Rectangle >::const_iterator it = mpLayoutData->m_aVisibleItemBoundRects.find( nPos );
3220         if( it != mpLayoutData->m_aVisibleItemBoundRects.end() )
3221             aRet = it->second;
3222     }
3223     return aRet;
3224 }
3225 
SetAccessibleName(sal_uInt16 nItemId,const XubString & rStr)3226 void Menu::SetAccessibleName( sal_uInt16 nItemId, const XubString& rStr )
3227 {
3228     sal_uInt16        nPos;
3229     MenuItemData* pData = pItemList->GetData( nItemId, nPos );
3230 
3231 	if ( pData && !rStr.Equals( pData->aAccessibleName ) )
3232 	{
3233 		pData->aAccessibleName = rStr;
3234 		ImplCallEventListeners( VCLEVENT_MENU_ACCESSIBLENAMECHANGED, nPos );
3235 	}
3236 }
3237 
GetAccessibleName(sal_uInt16 nItemId) const3238 XubString Menu::GetAccessibleName( sal_uInt16 nItemId ) const
3239 {
3240     MenuItemData* pData = pItemList->GetData( nItemId );
3241 
3242     if ( pData )
3243         return pData->aAccessibleName;
3244     else
3245         return ImplGetSVEmptyStr();
3246 }
3247 
SetAccessibleDescription(sal_uInt16 nItemId,const XubString & rStr)3248 void Menu::SetAccessibleDescription( sal_uInt16 nItemId, const XubString& rStr )
3249 {
3250     MenuItemData* pData = pItemList->GetData( nItemId );
3251 
3252 	if ( pData )
3253 		pData->aAccessibleDescription = rStr;
3254 }
3255 
GetAccessibleDescription(sal_uInt16 nItemId) const3256 XubString Menu::GetAccessibleDescription( sal_uInt16 nItemId ) const
3257 {
3258     MenuItemData* pData = pItemList->GetData( nItemId );
3259 
3260     if ( pData )
3261         return pData->aAccessibleDescription;
3262     else
3263         return ImplGetSVEmptyStr();
3264 }
3265 
ImplSetSalMenu(SalMenu * pSalMenu)3266 void Menu::ImplSetSalMenu( SalMenu *pSalMenu )
3267 {
3268     if( mpSalMenu )
3269         ImplGetSVData()->mpDefInst->DestroyMenu( mpSalMenu );
3270     mpSalMenu = pSalMenu;
3271 }
3272 
GetSystemMenuData(SystemMenuData * pData) const3273 sal_Bool Menu::GetSystemMenuData( SystemMenuData* pData ) const
3274 {
3275     Menu* pMenu = (Menu*)this;
3276     if( pData && pMenu->ImplGetSalMenu() )
3277     {
3278         pMenu->ImplGetSalMenu()->GetSystemMenuData( pData );
3279         return sal_True;
3280     }
3281     else
3282         return sal_False;
3283 }
3284 
IsHighlighted(sal_uInt16 nItemPos) const3285 bool Menu::IsHighlighted( sal_uInt16 nItemPos ) const
3286 {
3287     bool bRet = false;
3288 
3289     if( pWindow )
3290     {
3291         if( bIsMenuBar )
3292             bRet = ( nItemPos == static_cast< MenuBarWindow * > (pWindow)->GetHighlightedItem() );
3293         else
3294             bRet = ( nItemPos == static_cast< MenuFloatingWindow * > (pWindow)->GetHighlightedItem() );
3295     }
3296 
3297     return bRet;
3298 }
3299 
HighlightItem(sal_uInt16 nItemPos)3300 void Menu::HighlightItem( sal_uInt16 nItemPos )
3301 {
3302     if ( pWindow )
3303     {
3304         if ( bIsMenuBar )
3305         {
3306             MenuBarWindow* pMenuWin = static_cast< MenuBarWindow* >( pWindow );
3307             pMenuWin->SetAutoPopup( sal_False );
3308             pMenuWin->ChangeHighlightItem( nItemPos, sal_False );
3309         }
3310         else
3311         {
3312             static_cast< MenuFloatingWindow* >( pWindow )->ChangeHighlightItem( nItemPos, sal_False );
3313         }
3314     }
3315 }
3316 
3317 // -----------
3318 // - MenuBar -
3319 // -----------
3320 
MenuBar()3321 MenuBar::MenuBar() : Menu( sal_True )
3322 {
3323     mbDisplayable       = sal_True;
3324     mbCloserVisible     = sal_False;
3325     mbFloatBtnVisible   = sal_False;
3326     mbHideBtnVisible    = sal_False;
3327 }
3328 
MenuBar(const MenuBar & rMenu)3329 MenuBar::MenuBar( const MenuBar& rMenu ) : Menu( sal_True )
3330 {
3331     mbDisplayable       = sal_True;
3332     mbCloserVisible     = sal_False;
3333     mbFloatBtnVisible   = sal_False;
3334     mbHideBtnVisible    = sal_False;
3335     *this               = rMenu;
3336     bIsMenuBar          = sal_True;
3337 }
3338 
MenuBar(const ResId & rResId)3339 MenuBar::MenuBar( const ResId& rResId ) : Menu ( sal_True )
3340 {
3341     mbDisplayable       = sal_True;
3342     mbCloserVisible     = sal_False;
3343     mbFloatBtnVisible   = sal_False;
3344     mbHideBtnVisible    = sal_False;
3345     ImplLoadRes( rResId );
3346 }
3347 
~MenuBar()3348 MenuBar::~MenuBar()
3349 {
3350     ImplDestroy( this, sal_True );
3351 }
3352 
ShowCloser(sal_Bool bShow)3353 void MenuBar::ShowCloser( sal_Bool bShow )
3354 {
3355     ShowButtons( bShow, mbFloatBtnVisible, mbHideBtnVisible );
3356 }
3357 
ShowFloatButton(sal_Bool bShow)3358 void MenuBar::ShowFloatButton( sal_Bool bShow )
3359 {
3360     ShowButtons( mbCloserVisible, bShow, mbHideBtnVisible );
3361 }
3362 
ShowHideButton(sal_Bool bShow)3363 void MenuBar::ShowHideButton( sal_Bool bShow )
3364 {
3365     ShowButtons( mbCloserVisible, mbFloatBtnVisible, bShow );
3366 }
3367 
ShowButtons(sal_Bool bClose,sal_Bool bFloat,sal_Bool bHide)3368 void MenuBar::ShowButtons( sal_Bool bClose, sal_Bool bFloat, sal_Bool bHide )
3369 {
3370     if ( (bClose != mbCloserVisible)    ||
3371          (bFloat != mbFloatBtnVisible)  ||
3372          (bHide  != mbHideBtnVisible) )
3373     {
3374         mbCloserVisible     = bClose;
3375         mbFloatBtnVisible   = bFloat;
3376         mbHideBtnVisible    = bHide;
3377         if ( ImplGetWindow() )
3378             ((MenuBarWindow*)ImplGetWindow())->ShowButtons( bClose, bFloat, bHide );
3379     }
3380 }
3381 
SetDisplayable(sal_Bool bDisplayable)3382 void MenuBar::SetDisplayable( sal_Bool bDisplayable )
3383 {
3384     if( bDisplayable != mbDisplayable )
3385     {
3386         mbDisplayable = bDisplayable;
3387         MenuBarWindow* pMenuWin = (MenuBarWindow*) ImplGetWindow();
3388         if( pMenuWin )
3389             pMenuWin->ImplLayoutChanged();
3390     }
3391 }
3392 
ImplCreate(Window * pParent,Window * pWindow,MenuBar * pMenu)3393 Window* MenuBar::ImplCreate( Window* pParent, Window* pWindow, MenuBar* pMenu )
3394 {
3395     if ( !pWindow )
3396         pWindow = new MenuBarWindow( pParent );
3397 
3398     pMenu->pStartedFrom = 0;
3399     pMenu->pWindow = pWindow;
3400     ((MenuBarWindow*)pWindow)->SetMenu( pMenu );
3401     long nHeight = pMenu->ImplCalcSize( pWindow ).Height();
3402 
3403     // depending on the native implementation or the displayable flag
3404     // the menubar windows is supressed (ie, height=0)
3405     if( !((MenuBar*) pMenu)->IsDisplayable() ||
3406         ( pMenu->ImplGetSalMenu() && pMenu->ImplGetSalMenu()->VisibleMenuBar() ) )
3407         nHeight = 0;
3408 
3409     pWindow->SetPosSizePixel( 0, 0, 0, nHeight, WINDOW_POSSIZE_HEIGHT );
3410     return pWindow;
3411 }
3412 
ImplDestroy(MenuBar * pMenu,sal_Bool bDelete)3413 void MenuBar::ImplDestroy( MenuBar* pMenu, sal_Bool bDelete )
3414 {
3415     MenuBarWindow* pWindow = (MenuBarWindow*) pMenu->ImplGetWindow();
3416     if ( pWindow && bDelete )
3417     {
3418         pWindow->KillActivePopup();
3419         delete pWindow;
3420     }
3421     pMenu->pWindow = NULL;
3422 }
3423 
ImplHandleKeyEvent(const KeyEvent & rKEvent,sal_Bool bFromMenu)3424 sal_Bool MenuBar::ImplHandleKeyEvent( const KeyEvent& rKEvent, sal_Bool bFromMenu )
3425 {
3426     sal_Bool bDone = sal_False;
3427 
3428     // No keyboard processing when system handles the menu or our menubar is invisible
3429     if( !IsDisplayable() ||
3430         ( ImplGetSalMenu() && ImplGetSalMenu()->VisibleMenuBar() ) )
3431         return bDone;
3432 
3433     // Enabled-Abfragen, falls diese Methode von einem anderen Fenster gerufen wurde...
3434     Window* pWin = ImplGetWindow();
3435     if ( pWin && pWin->IsEnabled() && pWin->IsInputEnabled()  && ! pWin->IsInModalMode() )
3436         bDone = ((MenuBarWindow*)pWin)->ImplHandleKeyEvent( rKEvent, bFromMenu );
3437     return bDone;
3438 }
3439 
3440 // -----------------------------------------------------------------------
3441 
SelectEntry(sal_uInt16 nId)3442 void MenuBar::SelectEntry( sal_uInt16 nId )
3443 {
3444     MenuBarWindow* pMenuWin = (MenuBarWindow*) ImplGetWindow();
3445 
3446     if( pMenuWin )
3447     {
3448         pMenuWin->GrabFocus();
3449         nId = GetItemPos( nId );
3450 
3451         // #99705# popup the selected menu
3452         pMenuWin->SetAutoPopup( sal_True );
3453         if( ITEMPOS_INVALID != pMenuWin->nHighlightedItem )
3454         {
3455             pMenuWin->KillActivePopup();
3456             pMenuWin->ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
3457         }
3458         if( nId != ITEMPOS_INVALID )
3459             pMenuWin->ChangeHighlightItem( nId, sal_False );
3460     }
3461 }
3462 
3463 // -----------------------------------------------------------------------
3464 
3465 // handler for native menu selection and command events
3466 
HandleMenuActivateEvent(Menu * pMenu) const3467 sal_Bool MenuBar::HandleMenuActivateEvent( Menu *pMenu ) const
3468 {
3469     if( pMenu )
3470     {
3471 		ImplMenuDelData aDelData( this );
3472 
3473         pMenu->pStartedFrom = (Menu*)this;
3474         pMenu->bInCallback = sal_True;
3475         pMenu->Activate();
3476 
3477 		if( !aDelData.isDeleted() )
3478 	        pMenu->bInCallback = sal_False;
3479     }
3480     return sal_True;
3481 }
3482 
HandleMenuDeActivateEvent(Menu * pMenu) const3483 sal_Bool MenuBar::HandleMenuDeActivateEvent( Menu *pMenu ) const
3484 {
3485     if( pMenu )
3486     {
3487 		ImplMenuDelData aDelData( this );
3488 
3489         pMenu->pStartedFrom = (Menu*)this;
3490         pMenu->bInCallback = sal_True;
3491         pMenu->Deactivate();
3492 		if( !aDelData.isDeleted() )
3493 			pMenu->bInCallback = sal_False;
3494     }
3495     return sal_True;
3496 }
3497 
HandleMenuHighlightEvent(Menu * pMenu,sal_uInt16 nHighlightEventId) const3498 sal_Bool MenuBar::HandleMenuHighlightEvent( Menu *pMenu, sal_uInt16 nHighlightEventId ) const
3499 {
3500     if( !pMenu )
3501         pMenu = ((Menu*) this)->ImplFindMenu( nHighlightEventId );
3502     if( pMenu )
3503     {
3504 		ImplMenuDelData aDelData( pMenu );
3505 
3506         if( mnHighlightedItemPos != ITEMPOS_INVALID )
3507             pMenu->ImplCallEventListeners( VCLEVENT_MENU_DEHIGHLIGHT, mnHighlightedItemPos );
3508 
3509 		if( !aDelData.isDeleted() )
3510 		{
3511 	        pMenu->mnHighlightedItemPos = pMenu->GetItemPos( nHighlightEventId );
3512 		    pMenu->nSelectedId = nHighlightEventId;
3513 			pMenu->pStartedFrom = (Menu*)this;
3514 			pMenu->ImplCallHighlight( pMenu->mnHighlightedItemPos );
3515 		}
3516         return sal_True;
3517     }
3518     else
3519         return sal_False;
3520 }
3521 
HandleMenuCommandEvent(Menu * pMenu,sal_uInt16 nCommandEventId) const3522 sal_Bool MenuBar::HandleMenuCommandEvent( Menu *pMenu, sal_uInt16 nCommandEventId ) const
3523 {
3524     if( !pMenu )
3525         pMenu = ((Menu*) this)->ImplFindMenu( nCommandEventId );
3526     if( pMenu )
3527     {
3528         pMenu->nSelectedId = nCommandEventId;
3529         pMenu->pStartedFrom = (Menu*)this;
3530         pMenu->ImplSelect();
3531         return sal_True;
3532     }
3533     else
3534         return sal_False;
3535 }
3536 
AddMenuBarButton(const Image & i_rImage,const Link & i_rLink,sal_uInt16 i_nPos)3537 sal_uInt16 MenuBar::AddMenuBarButton( const Image& i_rImage, const Link& i_rLink, sal_uInt16 i_nPos )
3538 {
3539     return AddMenuBarButton( i_rImage, i_rLink, String(), i_nPos );
3540 }
3541 
AddMenuBarButton(const Image & i_rImage,const Link & i_rLink,const String & i_rToolTip,sal_uInt16 i_nPos)3542 sal_uInt16 MenuBar::AddMenuBarButton( const Image& i_rImage, const Link& i_rLink, const String& i_rToolTip, sal_uInt16 i_nPos )
3543 {
3544     return pWindow ? static_cast<MenuBarWindow*>(pWindow)->AddMenuBarButton( i_rImage, i_rLink, i_rToolTip, i_nPos ) : 0;
3545 }
3546 
SetMenuBarButtonHighlightHdl(sal_uInt16 nId,const Link & rLink)3547 void MenuBar::SetMenuBarButtonHighlightHdl( sal_uInt16 nId, const Link& rLink )
3548 {
3549     if( pWindow )
3550         static_cast<MenuBarWindow*>(pWindow)->SetMenuBarButtonHighlightHdl( nId, rLink );
3551 }
3552 
GetMenuBarButtonRectPixel(sal_uInt16 nId)3553 Rectangle MenuBar::GetMenuBarButtonRectPixel( sal_uInt16 nId )
3554 {
3555     return pWindow ? static_cast<MenuBarWindow*>(pWindow)->GetMenuBarButtonRectPixel( nId ) : Rectangle();
3556 }
3557 
RemoveMenuBarButton(sal_uInt16 nId)3558 void MenuBar::RemoveMenuBarButton( sal_uInt16 nId )
3559 {
3560     if( pWindow )
3561         static_cast<MenuBarWindow*>(pWindow)->RemoveMenuBarButton( nId );
3562 }
3563 
HandleMenuButtonEvent(Menu *,sal_uInt16 i_nButtonId) const3564 sal_Bool MenuBar::HandleMenuButtonEvent( Menu *, sal_uInt16 i_nButtonId ) const
3565 {
3566     return static_cast<MenuBarWindow*>(pWindow)->HandleMenuButtonEvent( i_nButtonId );
3567 }
3568 
3569 // -----------------------------------------------------------------------
3570 
3571 // sal_Bool PopupMenu::bAnyPopupInExecute = sal_False;
3572 
PopupMenu()3573 PopupMenu::PopupMenu()
3574 {
3575     pRefAutoSubMenu = NULL;
3576 }
3577 
PopupMenu(const ResId & rResId)3578 PopupMenu::PopupMenu( const ResId& rResId )
3579 {
3580     pRefAutoSubMenu = NULL;
3581     ImplLoadRes( rResId );
3582 }
3583 
PopupMenu(const PopupMenu & rMenu)3584 PopupMenu::PopupMenu( const PopupMenu& rMenu ) : Menu()
3585 {
3586     pRefAutoSubMenu = NULL;
3587     *this = rMenu;
3588 }
3589 
~PopupMenu()3590 PopupMenu::~PopupMenu()
3591 {
3592     if( pRefAutoSubMenu && *pRefAutoSubMenu == this )
3593         *pRefAutoSubMenu = NULL;    // #111060# avoid second delete in ~MenuItemData
3594 }
3595 
IsInExecute()3596 sal_Bool PopupMenu::IsInExecute()
3597 {
3598     return GetActivePopupMenu() ? sal_True : sal_False;
3599 }
3600 
GetActivePopupMenu()3601 PopupMenu* PopupMenu::GetActivePopupMenu()
3602 {
3603     ImplSVData* pSVData = ImplGetSVData();
3604     return pSVData->maAppData.mpActivePopupMenu;
3605 }
3606 
EndExecute(sal_uInt16 nSelectId)3607 void PopupMenu::EndExecute( sal_uInt16 nSelectId )
3608 {
3609     if ( ImplGetWindow() )
3610         ImplGetFloatingWindow()->EndExecute( nSelectId );
3611 }
3612 
SelectEntry(sal_uInt16 nId)3613 void PopupMenu::SelectEntry( sal_uInt16 nId )
3614 {
3615     if ( ImplGetWindow() )
3616     {
3617         if( nId != ITEMPOS_INVALID )
3618         {
3619 	        sal_uInt16 nPos;
3620 		    MenuItemData* pData = GetItemList()->GetData( nId, nPos );
3621             if ( pData->pSubMenu )
3622                 ImplGetFloatingWindow()->ChangeHighlightItem( nPos, sal_True );
3623             else
3624                 ImplGetFloatingWindow()->EndExecute( nId );
3625         }
3626         else
3627         {
3628 			MenuFloatingWindow* pFloat = ImplGetFloatingWindow();
3629 	        pFloat->GrabFocus();
3630 			sal_uInt16 nPos;
3631 			for( nPos = 0; nPos < GetItemList()->Count(); nPos++ )
3632 			{
3633 				MenuItemData* pData = (MenuItemData*)GetItemList()->GetObject( nPos );
3634 				if( pData->pSubMenu )
3635 				{
3636 					pFloat->KillActivePopup();
3637 				}
3638 			}
3639             pFloat->ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
3640         }
3641     }
3642 }
3643 
SetSelectedEntry(sal_uInt16 nId)3644 void PopupMenu::SetSelectedEntry( sal_uInt16 nId )
3645 {
3646     nSelectedId = nId;
3647 }
3648 
Execute(Window * pExecWindow,const Point & rPopupPos)3649 sal_uInt16 PopupMenu::Execute( Window* pExecWindow, const Point& rPopupPos )
3650 {
3651     return Execute( pExecWindow, Rectangle( rPopupPos, rPopupPos ), POPUPMENU_EXECUTE_DOWN );
3652 }
3653 
Execute(Window * pExecWindow,const Rectangle & rRect,sal_uInt16 nFlags)3654 sal_uInt16 PopupMenu::Execute( Window* pExecWindow, const Rectangle& rRect, sal_uInt16 nFlags )
3655 {
3656     ENSURE_OR_RETURN( pExecWindow, "PopupMenu::Execute: need a non-NULL window!", 0 );
3657 
3658 
3659     sal_uLong nPopupModeFlags = 0;
3660     if ( nFlags & POPUPMENU_EXECUTE_DOWN )
3661         nPopupModeFlags = FLOATWIN_POPUPMODE_DOWN;
3662     else if ( nFlags & POPUPMENU_EXECUTE_UP )
3663         nPopupModeFlags = FLOATWIN_POPUPMODE_UP;
3664     else if ( nFlags & POPUPMENU_EXECUTE_LEFT )
3665         nPopupModeFlags = FLOATWIN_POPUPMODE_LEFT;
3666     else if ( nFlags & POPUPMENU_EXECUTE_RIGHT )
3667         nPopupModeFlags = FLOATWIN_POPUPMODE_RIGHT;
3668     else
3669         nPopupModeFlags = FLOATWIN_POPUPMODE_DOWN;
3670 
3671     if (nFlags & POPUPMENU_NOMOUSEUPCLOSE )                      // allow popup menus to stay open on mouse button up
3672         nPopupModeFlags |= FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE;    // useful if the menu was opened on mousebutton down (eg toolbox configuration)
3673 
3674     return ImplExecute( pExecWindow, rRect, nPopupModeFlags, 0, sal_False );
3675 }
3676 
ImplExecute(Window * pW,const Rectangle & rRect,sal_uLong nPopupModeFlags,Menu * pSFrom,sal_Bool bPreSelectFirst)3677 sal_uInt16 PopupMenu::ImplExecute( Window* pW, const Rectangle& rRect, sal_uLong nPopupModeFlags, Menu* pSFrom, sal_Bool bPreSelectFirst )
3678 {
3679     if ( !pSFrom && ( PopupMenu::IsInExecute() || !GetItemCount() ) )
3680         return 0;
3681 
3682     delete mpLayoutData, mpLayoutData = NULL;
3683 
3684     ImplSVData* pSVData = ImplGetSVData();
3685 
3686     pStartedFrom = pSFrom;
3687     nSelectedId = 0;
3688     bCanceled = sal_False;
3689 
3690     sal_uLong nFocusId = 0;
3691     sal_Bool bRealExecute = sal_False;
3692     if ( !pStartedFrom )
3693     {
3694         pSVData->maWinData.mbNoDeactivate = sal_True;
3695         nFocusId = Window::SaveFocus();
3696         bRealExecute = sal_True;
3697     }
3698     else
3699     {
3700         // assure that only one menu is open at a time
3701         if( pStartedFrom->bIsMenuBar && pSVData->maWinData.mpFirstFloat )
3702             pSVData->maWinData.mpFirstFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
3703     }
3704 
3705     DBG_ASSERT( !ImplGetWindow(), "Win?!" );
3706     Rectangle aRect( rRect );
3707     aRect.SetPos( pW->OutputToScreenPixel( aRect.TopLeft() ) );
3708 
3709     WinBits nStyle = WB_BORDER;
3710     if ( bRealExecute )
3711         nPopupModeFlags |= FLOATWIN_POPUPMODE_NEWLEVEL;
3712     if ( !pStartedFrom || !pStartedFrom->bIsMenuBar )
3713         nPopupModeFlags |= FLOATWIN_POPUPMODE_PATHMOUSECANCELCLICK | FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE;
3714 
3715     nPopupModeFlags |= FLOATWIN_POPUPMODE_NOKEYCLOSE;
3716 
3717     // Kann beim Debuggen hilfreich sein.
3718     // nPopupModeFlags |= FLOATWIN_POPUPMODE_NOFOCUSCLOSE;
3719 
3720     ImplDelData aDelData;
3721     pW->ImplAddDel( &aDelData );
3722 
3723     bInCallback = sal_True; // hier schon setzen, falls Activate ueberladen
3724     Activate();
3725     bInCallback = sal_False;
3726 
3727     if ( aDelData.IsDelete() )
3728         return 0;   // Error
3729 
3730     pW->ImplRemoveDel( &aDelData );
3731 
3732     if ( bCanceled || bKilled )
3733         return 0;
3734 
3735     if ( !GetItemCount() )
3736         return 0;
3737 
3738     // Das Flag MENU_FLAG_HIDEDISABLEDENTRIES wird vererbt.
3739     if ( pSFrom )
3740     {
3741         if ( pSFrom->nMenuFlags & MENU_FLAG_HIDEDISABLEDENTRIES )
3742             nMenuFlags |= MENU_FLAG_HIDEDISABLEDENTRIES;
3743         else
3744             nMenuFlags &= ~MENU_FLAG_HIDEDISABLEDENTRIES;
3745     }
3746     else
3747         // #102790# context menues shall never show disabled entries
3748         nMenuFlags |= MENU_FLAG_HIDEDISABLEDENTRIES;
3749 
3750 
3751     sal_uInt16 nVisibleEntries = ImplGetVisibleItemCount();
3752     if ( !nVisibleEntries )
3753     {
3754         ResMgr* pResMgr = ImplGetResMgr();
3755         if( pResMgr )
3756         {
3757             String aTmpEntryText( ResId( SV_RESID_STRING_NOSELECTIONPOSSIBLE, *pResMgr ) );
3758             MenuItemData* pData = pItemList->Insert(
3759                 0xFFFF, MENUITEM_STRING, 0, aTmpEntryText, Image(), NULL, 0xFFFF );
3760 		sal_uInt16          nmPos;
3761 		pData = pItemList->GetData( pData->nId, nmPos );
3762                 pData->bIsTemporary = sal_True;
3763 		ImplCallEventListeners(VCLEVENT_MENU_SUBMENUCHANGED,nmPos);
3764         }
3765     }
3766     else if ( Application::GetSettings().GetStyleSettings().GetAutoMnemonic() && !( nMenuFlags & MENU_FLAG_NOAUTOMNEMONICS ) )
3767     {
3768         CreateAutoMnemonics();
3769     }
3770 
3771     MenuFloatingWindow* pWin = new MenuFloatingWindow( this, pW, nStyle | WB_SYSTEMWINDOW );
3772     if( pSVData->maNWFData.mbFlatMenu )
3773         pWin->SetBorderStyle( WINDOW_BORDER_NOBORDER );
3774     else
3775         pWin->SetBorderStyle( pWin->GetBorderStyle() | WINDOW_BORDER_MENU );
3776     pWindow = pWin;
3777 
3778     Size aSz = ImplCalcSize( pWin );
3779 
3780     long nMaxHeight = pWin->GetDesktopRectPixel().GetHeight();
3781     if( Application::GetScreenCount() > 1 && ! Application::IsMultiDisplay() )
3782     {
3783         Window* pDeskW = pWindow->GetWindow( WINDOW_REALPARENT );
3784         if( ! pDeskW )
3785             pDeskW = pWindow;
3786         Point aDesktopTL( pDeskW->OutputToAbsoluteScreenPixel( aRect.TopLeft() ) );
3787         nMaxHeight = Application::GetWorkAreaPosSizePixel(
3788             Application::GetBestScreen( Rectangle( aDesktopTL, aRect.GetSize() ) )
3789             ).GetHeight();
3790     }
3791     if ( pStartedFrom && pStartedFrom->bIsMenuBar )
3792         nMaxHeight -= pW->GetSizePixel().Height();
3793     sal_Int32 nLeft, nTop, nRight, nBottom;
3794     pWindow->GetBorder( nLeft, nTop, nRight, nBottom );
3795     nMaxHeight -= nTop+nBottom;
3796     if ( aSz.Height() > nMaxHeight )
3797     {
3798         pWin->EnableScrollMenu( sal_True );
3799         sal_uInt16 nStart = ImplGetFirstVisible();
3800         sal_uInt16 nEntries = ImplCalcVisEntries( nMaxHeight, nStart );
3801         aSz.Height() = ImplCalcHeight( nEntries );
3802     }
3803 
3804     pWin->SetFocusId( nFocusId );
3805     pWin->SetOutputSizePixel( aSz );
3806     // #102158# menus must never grab the focus, otherwise
3807     // they will be closed immediately
3808     // from now on focus grabbing is only prohibited automatically if
3809     // FLOATWIN_POPUPMODE_GRABFOCUS was set (which is done below), because some
3810     // floaters (like floating toolboxes) may grab the focus
3811     // pWin->GrabFocus();
3812     if ( GetItemCount() )
3813     {
3814         SalMenu* pMenu = ImplGetSalMenu();
3815         if( pMenu && bRealExecute && pMenu->ShowNativePopupMenu( pWin, aRect, nPopupModeFlags | FLOATWIN_POPUPMODE_GRABFOCUS ) )
3816         {
3817             pWin->StopExecute(0);
3818             pWin->doShutdown();
3819             pWindow->doLazyDelete();
3820             pWindow = NULL;
3821             return nSelectedId;
3822         }
3823         else
3824         {
3825             pWin->StartPopupMode( aRect, nPopupModeFlags | FLOATWIN_POPUPMODE_GRABFOCUS );
3826         }
3827         if( pSFrom )
3828         {
3829             sal_uInt16 aPos;
3830             if( pSFrom->bIsMenuBar )
3831                 aPos = ((MenuBarWindow *) pSFrom->pWindow)->GetHighlightedItem();
3832             else
3833                 aPos = ((MenuFloatingWindow *) pSFrom->pWindow)->GetHighlightedItem();
3834 
3835             pWin->SetPosInParent( aPos );  // store position to be sent in SUBMENUDEACTIVATE
3836             pSFrom->ImplCallEventListeners( VCLEVENT_MENU_SUBMENUACTIVATE, aPos );
3837         }
3838     }
3839     if ( bPreSelectFirst )
3840     {
3841         sal_uInt16 nCount = (sal_uInt16)pItemList->Count();
3842         for ( sal_uInt16 n = 0; n < nCount; n++ )
3843         {
3844             MenuItemData* pData = pItemList->GetDataFromPos( n );
3845             if (   ( pData->bEnabled || !Application::GetSettings().GetStyleSettings().GetSkipDisabledInMenus() )
3846                 && ( pData->eType != MENUITEM_SEPARATOR ) && ImplIsVisible( n ) && ImplIsSelectable( n ) )
3847             {
3848                 pWin->ChangeHighlightItem( n, sal_False );
3849                 break;
3850             }
3851         }
3852     }
3853     if ( bRealExecute )
3854     {
3855         pWin->ImplAddDel( &aDelData );
3856 
3857         ImplDelData aModalWinDel;
3858         pW->ImplAddDel( &aModalWinDel );
3859         pW->ImplIncModalCount();
3860 
3861         pWin->Execute();
3862 
3863         DBG_ASSERT( ! aModalWinDel.IsDead(), "window for popup died, modal count incorrect !" );
3864         if( ! aModalWinDel.IsDead() )
3865             pW->ImplDecModalCount();
3866 
3867         if ( !aDelData.IsDelete() )
3868             pWin->ImplRemoveDel( &aDelData );
3869         else
3870             return 0;
3871 
3872         // Focus wieder herstellen (kann schon im Select wieder
3873         // hergestellt wurden sein
3874         nFocusId = pWin->GetFocusId();
3875         if ( nFocusId )
3876         {
3877             pWin->SetFocusId( 0 );
3878             pSVData->maWinData.mbNoDeactivate = sal_False;
3879         }
3880         pWin->ImplEndPopupMode( 0, nFocusId );
3881 
3882         if ( nSelectedId )  // Dann abraeumen... ( sonst macht TH das )
3883         {
3884             PopupMenu* pSub = pWin->GetActivePopup();
3885             while ( pSub )
3886             {
3887                 pSub->ImplGetFloatingWindow()->EndPopupMode();
3888                 pSub = pSub->ImplGetFloatingWindow()->GetActivePopup();
3889             }
3890         }
3891         pWin->doShutdown();
3892         pWindow->doLazyDelete();
3893         pWindow = NULL;
3894 
3895         // Steht noch ein Select aus?
3896         Menu* pSelect = ImplFindSelectMenu();
3897         if ( pSelect )
3898         {
3899             // Beim Popup-Menu muss das Select vor dem Verlassen von Execute gerufen werden!
3900             Application::RemoveUserEvent( pSelect->nEventId );
3901             pSelect->nEventId = 0;
3902             pSelect->Select();
3903         }
3904     }
3905 
3906     return bRealExecute ? nSelectedId : 0;
3907 }
3908 
ImplCalcVisEntries(long nMaxHeight,sal_uInt16 nStartEntry,sal_uInt16 * pLastVisible) const3909 sal_uInt16 PopupMenu::ImplCalcVisEntries( long nMaxHeight, sal_uInt16 nStartEntry, sal_uInt16* pLastVisible ) const
3910 {
3911     nMaxHeight -= 2 * ImplGetFloatingWindow()->GetScrollerHeight();
3912 
3913     long nHeight = 0;
3914     sal_uInt16 nEntries = (sal_uInt16) pItemList->Count();
3915     sal_uInt16 nVisEntries = 0;
3916 
3917     if ( pLastVisible )
3918         *pLastVisible = 0;
3919 
3920     for ( sal_uInt16 n = nStartEntry; n < nEntries; n++ )
3921     {
3922         if ( ImplIsVisible( n ) )
3923         {
3924             MenuItemData* pData = pItemList->GetDataFromPos( n );
3925             nHeight += pData->aSz.Height();
3926             if ( nHeight > nMaxHeight )
3927                 break;
3928 
3929             if ( pLastVisible )
3930                 *pLastVisible = n;
3931             nVisEntries++;
3932         }
3933     }
3934     return nVisEntries;
3935 }
3936 
ImplCalcHeight(sal_uInt16 nEntries) const3937 long PopupMenu::ImplCalcHeight( sal_uInt16 nEntries ) const
3938 {
3939     long nHeight = 0;
3940 
3941     sal_uInt16 nFound = 0;
3942     for ( sal_uInt16 n = 0; ( nFound < nEntries ) && ( n < pItemList->Count() ); n++ )
3943     {
3944         if ( ImplIsVisible( (sal_uInt16) n ) )
3945         {
3946             MenuItemData* pData = pItemList->GetDataFromPos( n );
3947             nHeight += pData->aSz.Height();
3948             nFound++;
3949         }
3950     }
3951 
3952     nHeight += 2*ImplGetFloatingWindow()->GetScrollerHeight();
3953 
3954     return nHeight;
3955 }
3956 
3957 
ImplInitMenuWindow(Window * pWin,sal_Bool bFont,sal_Bool bMenuBar)3958 static void ImplInitMenuWindow( Window* pWin, sal_Bool bFont, sal_Bool bMenuBar )
3959 {
3960     const StyleSettings& rStyleSettings = pWin->GetSettings().GetStyleSettings();
3961 
3962     if ( bFont )
3963         pWin->SetPointFont( rStyleSettings.GetMenuFont() );
3964     if( bMenuBar )
3965     {
3966         if( pWin->IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL ) )
3967         {
3968             pWin->SetBackground();  // background will be drawn by NWF
3969         }
3970         else
3971         {
3972             Wallpaper aWallpaper;
3973             aWallpaper.SetStyle( WALLPAPER_APPLICATIONGRADIENT );
3974             pWin->SetBackground( aWallpaper );
3975             pWin->SetPaintTransparent( sal_False );
3976             pWin->SetParentClipMode( 0 );
3977         }
3978     }
3979     else
3980     {
3981         if( pWin->IsNativeControlSupported( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL ) )
3982         {
3983             pWin->SetBackground();  // background will be drawn by NWF
3984         }
3985         else
3986             pWin->SetBackground( Wallpaper( rStyleSettings.GetMenuColor() ) );
3987     }
3988 
3989     if ( bMenuBar )
3990         pWin->SetTextColor( rStyleSettings.GetMenuBarTextColor() );
3991     else
3992         pWin->SetTextColor( rStyleSettings.GetMenuTextColor() );
3993     pWin->SetTextFillColor();
3994     pWin->SetLineColor();
3995 }
3996 
MenuFloatingWindow(Menu * pMen,Window * pParent,WinBits nStyle)3997 MenuFloatingWindow::MenuFloatingWindow( Menu* pMen, Window* pParent, WinBits nStyle ) :
3998     FloatingWindow( pParent, nStyle )
3999 {
4000     mpWindowImpl->mbMenuFloatingWindow= sal_True;
4001     pMenu               = pMen;
4002     pActivePopup        = 0;
4003     nSaveFocusId        = 0;
4004     bInExecute          = sal_False;
4005     bScrollMenu         = sal_False;
4006     nHighlightedItem    = ITEMPOS_INVALID;
4007     nMBDownPos          = ITEMPOS_INVALID;
4008     nPosInParent        = ITEMPOS_INVALID;
4009     nScrollerHeight     = 0;
4010 //    nStartY             = 0;
4011     nBorder             = EXTRASPACEY;
4012     nFirstEntry         = 0;
4013     bScrollUp           = sal_False;
4014     bScrollDown         = sal_False;
4015     bIgnoreFirstMove    = sal_True;
4016     bKeyInput           = sal_False;
4017 
4018     EnableSaveBackground();
4019     ImplInitMenuWindow( this, sal_True, sal_False );
4020 
4021     SetPopupModeEndHdl( LINK( this, MenuFloatingWindow, PopupEnd ) );
4022 
4023     aHighlightChangedTimer.SetTimeoutHdl( LINK( this, MenuFloatingWindow, HighlightChanged ) );
4024 	aHighlightChangedTimer.SetTimeout( GetSettings().GetMouseSettings().GetMenuDelay() );
4025 	aSubmenuCloseTimer.SetTimeout( GetSettings().GetMouseSettings().GetMenuDelay() );
4026     aSubmenuCloseTimer.SetTimeoutHdl( LINK( this, MenuFloatingWindow, SubmenuClose ) );
4027     aScrollTimer.SetTimeoutHdl( LINK( this, MenuFloatingWindow, AutoScroll ) );
4028 
4029     AddEventListener( LINK( this, MenuFloatingWindow, ShowHideListener ) );
4030 }
4031 
doShutdown()4032 void MenuFloatingWindow::doShutdown()
4033 {
4034     if( pMenu )
4035     {
4036         // #105373# notify toolkit that highlight was removed
4037         // otherwise the entry will not be read when the menu is opened again
4038         if( nHighlightedItem != ITEMPOS_INVALID )
4039             pMenu->ImplCallEventListeners( VCLEVENT_MENU_DEHIGHLIGHT, nHighlightedItem );
4040 	pMenu->SetHightlightItem(ITEMPOS_INVALID);
4041         if( !bKeyInput && pMenu && pMenu->pStartedFrom && !pMenu->pStartedFrom->bIsMenuBar )
4042         {
4043             // #102461# remove highlight in parent
4044             MenuItemData* pData;
4045             sal_uInt16 i, nCount = (sal_uInt16)pMenu->pStartedFrom->pItemList->Count();
4046             for(i = 0; i < nCount; i++)
4047             {
4048                 pData = pMenu->pStartedFrom->pItemList->GetDataFromPos( i );
4049                 if( pData && ( pData->pSubMenu == pMenu ) )
4050                     break;
4051             }
4052             if( i < nCount )
4053             {
4054                 MenuFloatingWindow* pPWin = (MenuFloatingWindow*)pMenu->pStartedFrom->ImplGetWindow();
4055                 if( pPWin )
4056                     pPWin->HighlightItem( i, sal_False );
4057             }
4058         }
4059 
4060         // free the reference to the accessible component
4061         SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
4062 
4063         aHighlightChangedTimer.Stop();
4064 
4065         // #95056# invalidate screen area covered by system window
4066         // so this can be taken into account if the commandhandler performs a scroll operation
4067         if( GetParent() )
4068         {
4069             Rectangle aInvRect( GetWindowExtentsRelative( GetParent() ) );
4070             GetParent()->Invalidate( aInvRect );
4071         }
4072         pMenu = NULL;
4073         RemoveEventListener( LINK( this, MenuFloatingWindow, ShowHideListener ) );
4074     }
4075 }
4076 
~MenuFloatingWindow()4077 MenuFloatingWindow::~MenuFloatingWindow()
4078 {
4079     doShutdown();
4080 }
4081 
Resize()4082 void MenuFloatingWindow::Resize()
4083 {
4084     ImplInitClipRegion();
4085 }
4086 
ImplGetStartY() const4087 long MenuFloatingWindow::ImplGetStartY() const
4088 {
4089     long nY = 0;
4090     if( pMenu )
4091     {
4092         for ( sal_uInt16 n = 0; n < nFirstEntry; n++ )
4093             nY += pMenu->GetItemList()->GetDataFromPos( n )->aSz.Height();
4094     }
4095     return -nY;
4096 }
4097 
ImplCalcClipRegion(sal_Bool bIncludeLogo) const4098 Region MenuFloatingWindow::ImplCalcClipRegion( sal_Bool bIncludeLogo ) const
4099 {
4100     Size aOutSz = GetOutputSizePixel();
4101     Point aPos;
4102     Rectangle aRect( aPos, aOutSz );
4103     aRect.Top() += nScrollerHeight;
4104     aRect.Bottom() -= nScrollerHeight;
4105 
4106     if ( pMenu && pMenu->pLogo && !bIncludeLogo )
4107         aRect.Left() += pMenu->pLogo->aBitmap.GetSizePixel().Width();
4108 
4109     Region aRegion = aRect;
4110     if ( pMenu && pMenu->pLogo && bIncludeLogo && nScrollerHeight )
4111         aRegion.Union( Rectangle( Point(), Size( pMenu->pLogo->aBitmap.GetSizePixel().Width(), aOutSz.Height() ) ) );
4112 
4113     return aRegion;
4114 }
4115 
ImplInitClipRegion()4116 void MenuFloatingWindow::ImplInitClipRegion()
4117 {
4118     if ( IsScrollMenu() )
4119     {
4120         SetClipRegion( ImplCalcClipRegion() );
4121     }
4122     else
4123     {
4124         SetClipRegion();
4125     }
4126 }
4127 
ImplHighlightItem(const MouseEvent & rMEvt,sal_Bool bMBDown)4128 void MenuFloatingWindow::ImplHighlightItem( const MouseEvent& rMEvt, sal_Bool bMBDown )
4129 {
4130     if( ! pMenu )
4131         return;
4132 
4133     long nY = nScrollerHeight;
4134     long nMouseY = rMEvt.GetPosPixel().Y();
4135     Size aOutSz = GetOutputSizePixel();
4136     if ( ( nMouseY >= nY ) && ( nMouseY < ( aOutSz.Height() - nY ) ) )
4137     {
4138         sal_Bool bHighlighted = sal_False;
4139         sal_uInt16 nCount = (sal_uInt16)pMenu->pItemList->Count();
4140         nY += ImplGetStartY();  // ggf. gescrollt.
4141         for ( sal_uInt16 n = 0; !bHighlighted && ( n < nCount ); n++ )
4142         {
4143             if ( pMenu->ImplIsVisible( n ) )
4144             {
4145                 MenuItemData* pItemData = pMenu->pItemList->GetDataFromPos( n );
4146                 long nOldY = nY;
4147                 nY += pItemData->aSz.Height();
4148                 if ( ( nOldY <= nMouseY ) && ( nY > nMouseY ) && pMenu->ImplIsSelectable( n ) )
4149                 {
4150                     sal_Bool bPopupArea = sal_True;
4151                     if ( pItemData->nBits & MIB_POPUPSELECT )
4152                     {
4153                         // Nur wenn ueber dem Pfeil geklickt wurde...
4154                         Size aSz = GetOutputSizePixel();
4155                         long nFontHeight = GetTextHeight();
4156                         bPopupArea = ( rMEvt.GetPosPixel().X() >= ( aSz.Width() - nFontHeight - nFontHeight/4 ) );
4157                     }
4158 
4159                     if ( bMBDown )
4160                     {
4161                         if ( n != nHighlightedItem )
4162                         {
4163                             ChangeHighlightItem( (sal_uInt16)n, sal_False );
4164                         }
4165 
4166                         sal_Bool bAllowNewPopup = sal_True;
4167                         if ( pActivePopup )
4168                         {
4169                             MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
4170                             bAllowNewPopup = pData && ( pData->pSubMenu != pActivePopup );
4171                             if ( bAllowNewPopup )
4172                                 KillActivePopup();
4173                         }
4174 
4175                         if ( bPopupArea && bAllowNewPopup )
4176                         {
4177                             HighlightChanged( NULL );
4178                         }
4179                     }
4180                     else
4181                     {
4182                         if ( n != nHighlightedItem )
4183                         {
4184                             ChangeHighlightItem( (sal_uInt16)n, sal_True );
4185                         }
4186                         else if ( pItemData->nBits & MIB_POPUPSELECT )
4187                         {
4188                             if ( bPopupArea && ( pActivePopup != pItemData->pSubMenu ) )
4189                                 HighlightChanged( NULL );
4190                         }
4191                     }
4192                     bHighlighted = sal_True;
4193                 }
4194             }
4195         }
4196         if ( !bHighlighted )
4197             ChangeHighlightItem( ITEMPOS_INVALID, sal_True );
4198     }
4199     else
4200     {
4201         ImplScroll( rMEvt.GetPosPixel() );
4202         ChangeHighlightItem( ITEMPOS_INVALID, sal_True );
4203     }
4204 }
4205 
IMPL_LINK(MenuFloatingWindow,PopupEnd,FloatingWindow *,EMPTYARG)4206 IMPL_LINK( MenuFloatingWindow, PopupEnd, FloatingWindow*, EMPTYARG )
4207 {
4208     // "this" will be deleted before the end of this method!
4209     Menu* pM = pMenu;
4210     if ( bInExecute )
4211     {
4212         if ( pActivePopup )
4213         {
4214             //DBG_ASSERT( !pActivePopup->ImplGetWindow(), "PopupEnd, obwohl pActivePopup MIT Window!" );
4215             KillActivePopup(); // should be ok to just remove it
4216             //pActivePopup->bCanceled = sal_True;
4217         }
4218         bInExecute = sal_False;
4219         pMenu->bInCallback = sal_True;
4220         pMenu->Deactivate();
4221         pMenu->bInCallback = sal_False;
4222     }
4223     else
4224     {
4225         if( pMenu )
4226         {
4227             // Wenn dies Fenster von TH geschlossen wurde, hat noch ein anderes
4228             // Menu dieses Fenster als pActivePopup.
4229             if ( pMenu->pStartedFrom )
4230             {
4231                 // Das pWin am 'Parent' kann aber schon 0 sein, falls die Kette von
4232                 // vorne abgeraeumt wurde und jetzt die EndPopup-Events eintrudeln
4233                 if ( pMenu->pStartedFrom->bIsMenuBar )
4234                 {
4235                     MenuBarWindow* p = (MenuBarWindow*) pMenu->pStartedFrom->ImplGetWindow();
4236                     if ( p )
4237                         p->PopupClosed( pMenu );
4238                 }
4239                 else
4240                 {
4241                     MenuFloatingWindow* p = (MenuFloatingWindow*) pMenu->pStartedFrom->ImplGetWindow();
4242                     if ( p )
4243                         p->KillActivePopup( (PopupMenu*)pMenu );
4244                 }
4245             }
4246         }
4247     }
4248 
4249     if ( pM )
4250         pM->pStartedFrom = 0;
4251 
4252     return 0;
4253 }
4254 
IMPL_LINK(MenuFloatingWindow,AutoScroll,Timer *,EMPTYARG)4255 IMPL_LINK( MenuFloatingWindow, AutoScroll, Timer*, EMPTYARG )
4256 {
4257     ImplScroll( GetPointerPosPixel() );
4258     return 1;
4259 }
4260 
IMPL_LINK(MenuFloatingWindow,HighlightChanged,Timer *,pTimer)4261 IMPL_LINK( MenuFloatingWindow, HighlightChanged, Timer*, pTimer )
4262 {
4263     if( ! pMenu )
4264         return 0;
4265 
4266     MenuItemData* pItemData = pMenu->pItemList->GetDataFromPos( nHighlightedItem );
4267     if ( pItemData )
4268     {
4269         if ( pActivePopup && ( pActivePopup != pItemData->pSubMenu ) )
4270         {
4271             sal_uLong nOldFlags = GetPopupModeFlags();
4272             SetPopupModeFlags( GetPopupModeFlags() | FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE );
4273             KillActivePopup();
4274             SetPopupModeFlags( nOldFlags );
4275         }
4276         if ( pItemData->bEnabled && pItemData->pSubMenu && pItemData->pSubMenu->GetItemCount() && ( pItemData->pSubMenu != pActivePopup ) )
4277         {
4278             pActivePopup = (PopupMenu*)pItemData->pSubMenu;
4279             long nY = nScrollerHeight+ImplGetStartY();
4280             MenuItemData* pData = 0;
4281             for ( sal_uLong n = 0; n < nHighlightedItem; n++ )
4282             {
4283                 pData = pMenu->pItemList->GetDataFromPos( n );
4284                 nY += pData->aSz.Height();
4285             }
4286             pData = pMenu->pItemList->GetDataFromPos( nHighlightedItem );
4287             Size MySize = GetOutputSizePixel();
4288 //          Point MyPos = GetPosPixel();
4289 //          Point aItemTopLeft( MyPos.X(), MyPos.Y()+nY );
4290             Point aItemTopLeft( 0, nY );
4291             Point aItemBottomRight( aItemTopLeft );
4292             aItemBottomRight.X() += MySize.Width();
4293             aItemBottomRight.Y() += pData->aSz.Height();
4294 
4295             // Popups leicht versetzen:
4296             aItemTopLeft.X() += 2;
4297             aItemBottomRight.X() -= 2;
4298             if ( nHighlightedItem )
4299                 aItemTopLeft.Y() -= 2;
4300             else
4301             {
4302                 sal_Int32 nL, nT, nR, nB;
4303                 GetBorder( nL, nT, nR, nB );
4304                 aItemTopLeft.Y() -= nT;
4305             }
4306 
4307             // pTest: Wegen Abstuerzen durch Reschedule() im Aufruf von Activate()
4308             // Ausserdem wird damit auch verhindert, dass SubMenus angezeigt werden,
4309             // die lange im Activate Rescheduled haben und jetzt schon nicht mehr
4310             // angezeigt werden sollen.
4311             Menu* pTest = pActivePopup;
4312             sal_uLong nOldFlags = GetPopupModeFlags();
4313             SetPopupModeFlags( GetPopupModeFlags() | FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE );
4314             sal_uInt16 nRet = pActivePopup->ImplExecute( this, Rectangle( aItemTopLeft, aItemBottomRight ), FLOATWIN_POPUPMODE_RIGHT, pMenu, pTimer ? sal_False : sal_True  );
4315             SetPopupModeFlags( nOldFlags );
4316 
4317             // nRet != 0, wenn es waerend Activate() abgeschossen wurde...
4318             if ( !nRet && ( pActivePopup == pTest ) && pActivePopup->ImplGetWindow() )
4319                 pActivePopup->ImplGetFloatingWindow()->AddPopupModeWindow( this );
4320         }
4321     }
4322 
4323     return 0;
4324 }
4325 
IMPL_LINK(MenuFloatingWindow,SubmenuClose,Timer *,EMPTYARG)4326 IMPL_LINK( MenuFloatingWindow, SubmenuClose, Timer*, EMPTYARG )
4327 {
4328     if( pMenu && pMenu->pStartedFrom )
4329     {
4330         MenuFloatingWindow* pWin = (MenuFloatingWindow*) pMenu->pStartedFrom->GetWindow();
4331         if( pWin )
4332             pWin->KillActivePopup();
4333     }
4334     return 0;
4335 }
4336 
IMPL_LINK(MenuFloatingWindow,ShowHideListener,VclWindowEvent *,pEvent)4337 IMPL_LINK( MenuFloatingWindow, ShowHideListener, VclWindowEvent*, pEvent )
4338 {
4339     if( ! pMenu )
4340         return 0;
4341 
4342     if( pEvent->GetId() == VCLEVENT_WINDOW_SHOW )
4343         pMenu->ImplCallEventListeners( VCLEVENT_MENU_SHOW, ITEMPOS_INVALID );
4344     else if( pEvent->GetId() == VCLEVENT_WINDOW_HIDE )
4345         pMenu->ImplCallEventListeners( VCLEVENT_MENU_HIDE, ITEMPOS_INVALID );
4346     return 0;
4347 }
4348 
EnableScrollMenu(sal_Bool b)4349 void MenuFloatingWindow::EnableScrollMenu( sal_Bool b )
4350 {
4351     bScrollMenu = b;
4352     nScrollerHeight = b ? (sal_uInt16) GetSettings().GetStyleSettings().GetScrollBarSize() /2 : 0;
4353     bScrollDown = sal_True;
4354     ImplInitClipRegion();
4355 }
4356 
Execute()4357 void MenuFloatingWindow::Execute()
4358 {
4359     ImplSVData* pSVData = ImplGetSVData();
4360 
4361     pSVData->maAppData.mpActivePopupMenu = (PopupMenu*)pMenu;
4362 
4363     bInExecute = sal_True;
4364 //  bCallingSelect = sal_False;
4365 
4366     while ( bInExecute )
4367         Application::Yield();
4368 
4369     pSVData->maAppData.mpActivePopupMenu = NULL;
4370 
4371 //  while ( bCallingSelect )
4372 //      Application::Yield();
4373 }
4374 
StopExecute(sal_uLong nFocusId)4375 void MenuFloatingWindow::StopExecute( sal_uLong nFocusId )
4376 {
4377     // Focus wieder herstellen
4378     // (kann schon im Select wieder hergestellt wurden sein)
4379     if ( nSaveFocusId )
4380     {
4381         Window::EndSaveFocus( nFocusId, sal_False );
4382         nFocusId = nSaveFocusId;
4383         if ( nFocusId )
4384         {
4385             nSaveFocusId = 0;
4386             ImplGetSVData()->maWinData.mbNoDeactivate = sal_False;
4387         }
4388     }
4389     ImplEndPopupMode( 0, nFocusId );
4390 
4391     aHighlightChangedTimer.Stop();
4392     bInExecute = sal_False;
4393     if ( pActivePopup )
4394     {
4395         KillActivePopup();
4396     }
4397     // notify parent, needed for accessibility
4398     if( pMenu && pMenu->pStartedFrom )
4399         pMenu->pStartedFrom->ImplCallEventListeners( VCLEVENT_MENU_SUBMENUDEACTIVATE, nPosInParent );
4400 }
4401 
KillActivePopup(PopupMenu * pThisOnly)4402 void MenuFloatingWindow::KillActivePopup( PopupMenu* pThisOnly )
4403 {
4404     if ( pActivePopup && ( !pThisOnly || ( pThisOnly == pActivePopup ) ) )
4405     {
4406         if( pActivePopup->pWindow != NULL )
4407             if( ((FloatingWindow *) pActivePopup->pWindow)->IsInCleanUp() )
4408                 return; // kill it later
4409         if ( pActivePopup->bInCallback )
4410             pActivePopup->bCanceled = sal_True;
4411 
4412         // Vor allen Aktionen schon pActivePopup = 0, falls z.B.
4413         // PopupModeEndHdl des zu zerstoerenden Popups mal synchron gerufen wird.
4414         PopupMenu* pPopup = pActivePopup;
4415         pActivePopup = NULL;
4416         pPopup->bInCallback = sal_True;
4417         pPopup->Deactivate();
4418         pPopup->bInCallback = sal_False;
4419         if ( pPopup->ImplGetWindow() )
4420         {
4421             pPopup->ImplGetFloatingWindow()->StopExecute();
4422             pPopup->ImplGetFloatingWindow()->doShutdown();
4423             pPopup->pWindow->doLazyDelete();
4424             pPopup->pWindow = NULL;
4425 
4426             Update();
4427         }
4428     }
4429 }
4430 
EndExecute()4431 void MenuFloatingWindow::EndExecute()
4432 {
4433     Menu* pStart = pMenu ? pMenu->ImplGetStartMenu() : NULL;
4434     sal_uLong nFocusId = 0;
4435     if ( pStart && pStart->bIsMenuBar )
4436     {
4437         nFocusId = ((MenuBarWindow*)((MenuBar*)pStart)->ImplGetWindow())->GetFocusId();
4438         if ( nFocusId )
4439         {
4440             ((MenuBarWindow*)((MenuBar*)pStart)->ImplGetWindow())->SetFocusId( 0 );
4441             ImplGetSVData()->maWinData.mbNoDeactivate = sal_False;
4442         }
4443     }
4444 
4445     // Wenn von woanders gestartet, dann ab dort aufraumen:
4446     MenuFloatingWindow* pCleanUpFrom = this;
4447     MenuFloatingWindow* pWin = this;
4448     while ( pWin && !pWin->bInExecute &&
4449         pWin->pMenu->pStartedFrom && !pWin->pMenu->pStartedFrom->bIsMenuBar )
4450     {
4451         pWin = ((PopupMenu*)pWin->pMenu->pStartedFrom)->ImplGetFloatingWindow();
4452     }
4453     if ( pWin )
4454         pCleanUpFrom = pWin;
4455 
4456     // Dies Fenster wird gleich zerstoert => Daten lokal merken...
4457     Menu* pM = pMenu;
4458     sal_uInt16 nItem = nHighlightedItem;
4459 
4460     pCleanUpFrom->StopExecute( nFocusId );
4461 
4462     if ( nItem != ITEMPOS_INVALID && pM )
4463     {
4464         MenuItemData* pItemData = pM->GetItemList()->GetDataFromPos( nItem );
4465         if ( pItemData && !pItemData->bIsTemporary )
4466         {
4467             pM->nSelectedId = pItemData->nId;
4468             if ( pStart )
4469                 pStart->nSelectedId = pItemData->nId;
4470 
4471             pM->ImplSelect();
4472         }
4473     }
4474 }
4475 
EndExecute(sal_uInt16 nId)4476 void MenuFloatingWindow::EndExecute( sal_uInt16 nId )
4477 {
4478     sal_uInt16 nPos;
4479     if ( pMenu && pMenu->GetItemList()->GetData( nId, nPos ) )
4480         nHighlightedItem = nPos;
4481     else
4482         nHighlightedItem = ITEMPOS_INVALID;
4483 
4484     EndExecute();
4485 }
4486 
MouseButtonDown(const MouseEvent & rMEvt)4487 void MenuFloatingWindow::MouseButtonDown( const MouseEvent& rMEvt )
4488 {
4489     // TH macht ein ToTop auf dieses Fenster, aber das aktive Popup
4490     // soll oben bleiben...
4491     // due to focus chage this would close all menues -> don't do it (#94123)
4492     //if ( pActivePopup && pActivePopup->ImplGetWindow() && !pActivePopup->ImplGetFloatingWindow()->pActivePopup )
4493     //    pActivePopup->ImplGetFloatingWindow()->ToTop( TOTOP_NOGRABFOCUS );
4494 
4495     ImplHighlightItem( rMEvt, sal_True );
4496 
4497     nMBDownPos = nHighlightedItem;
4498 }
4499 
MouseButtonUp(const MouseEvent & rMEvt)4500 void MenuFloatingWindow::MouseButtonUp( const MouseEvent& rMEvt )
4501 {
4502     MenuItemData* pData = pMenu ? pMenu->GetItemList()->GetDataFromPos( nHighlightedItem ) : NULL;
4503     // nMBDownPos in lokaler Variable merken und gleich zuruecksetzen,
4504     // weil nach EndExecute zu spaet
4505     sal_uInt16 _nMBDownPos = nMBDownPos;
4506     nMBDownPos = ITEMPOS_INVALID;
4507     if ( pData && pData->bEnabled && ( pData->eType != MENUITEM_SEPARATOR ) )
4508     {
4509         if ( !pData->pSubMenu )
4510         {
4511             EndExecute();
4512         }
4513         else if ( ( pData->nBits & MIB_POPUPSELECT ) && ( nHighlightedItem == _nMBDownPos ) && ( rMEvt.GetClicks() == 2 ) )
4514         {
4515             // Nicht wenn ueber dem Pfeil geklickt wurde...
4516             Size aSz = GetOutputSizePixel();
4517             long nFontHeight = GetTextHeight();
4518             if ( rMEvt.GetPosPixel().X() < ( aSz.Width() - nFontHeight - nFontHeight/4 ) )
4519                 EndExecute();
4520         }
4521     }
4522 
4523 }
4524 
MouseMove(const MouseEvent & rMEvt)4525 void MenuFloatingWindow::MouseMove( const MouseEvent& rMEvt )
4526 {
4527     if ( !IsVisible() || rMEvt.IsSynthetic() || rMEvt.IsEnterWindow() )
4528         return;
4529 
4530     if ( rMEvt.IsLeaveWindow() )
4531     {
4532 #ifdef OS2
4533         if ( ImplHilite(rMEvt) )
4534         {
4535 #endif
4536         // #102461# do not remove highlight if a popup menu is open at this position
4537         MenuItemData* pData = pMenu ? pMenu->pItemList->GetDataFromPos( nHighlightedItem ) : NULL;
4538         // close popup with some delayed if we leave somewhere else
4539         if( pActivePopup && pData && pData->pSubMenu != pActivePopup )
4540             pActivePopup->ImplGetFloatingWindow()->aSubmenuCloseTimer.Start();
4541 
4542         if( !pActivePopup || (pData && pData->pSubMenu != pActivePopup ) )
4543             ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
4544 #ifdef OS2
4545         }
4546 #endif
4547 
4548         if ( IsScrollMenu() )
4549             ImplScroll( rMEvt.GetPosPixel() );
4550     }
4551     else
4552 #ifdef OS2
4553         if ( ImplHilite(rMEvt) )
4554 #endif
4555     {
4556         aSubmenuCloseTimer.Stop();
4557 		if( bIgnoreFirstMove )
4558 			bIgnoreFirstMove = sal_False;
4559 		else
4560 			ImplHighlightItem( rMEvt, sal_False );
4561     }
4562 }
4563 
ImplScroll(sal_Bool bUp)4564 void MenuFloatingWindow::ImplScroll( sal_Bool bUp )
4565 {
4566     KillActivePopup();
4567     Update();
4568 
4569     if( ! pMenu )
4570         return;
4571 
4572     HighlightItem( nHighlightedItem, sal_False );
4573 
4574     pMenu->ImplKillLayoutData();
4575 
4576     if ( bScrollUp && bUp )
4577     {
4578         nFirstEntry = pMenu->ImplGetPrevVisible( nFirstEntry );
4579         DBG_ASSERT( nFirstEntry != ITEMPOS_INVALID, "Scroll?!" );
4580 
4581         long nScrollEntryHeight = pMenu->GetItemList()->GetDataFromPos( nFirstEntry )->aSz.Height();
4582 
4583 //        nStartY += nEntryHeight;
4584 
4585         if ( !bScrollDown )
4586         {
4587             bScrollDown = sal_True;
4588             ImplDrawScroller( sal_False );
4589         }
4590 
4591         if ( pMenu->ImplGetPrevVisible( nFirstEntry ) == ITEMPOS_INVALID )
4592         {
4593             bScrollUp = sal_False;
4594             ImplDrawScroller( sal_True );
4595         }
4596 
4597         Scroll( 0, nScrollEntryHeight, ImplCalcClipRegion( sal_False ).GetBoundRect(), SCROLL_CLIP );
4598     }
4599     else if ( bScrollDown && !bUp )
4600     {
4601         long nScrollEntryHeight = pMenu->GetItemList()->GetDataFromPos( nFirstEntry )->aSz.Height();
4602 
4603         nFirstEntry = pMenu->ImplGetNextVisible( nFirstEntry );
4604         DBG_ASSERT( nFirstEntry != ITEMPOS_INVALID, "Scroll?!" );
4605 
4606 
4607         if ( !bScrollUp )
4608         {
4609             bScrollUp = sal_True;
4610             ImplDrawScroller( sal_True );
4611         }
4612 
4613         long nHeight = GetOutputSizePixel().Height();
4614         sal_uInt16 nLastVisible;
4615         ((PopupMenu*)pMenu)->ImplCalcVisEntries( nHeight, nFirstEntry, &nLastVisible );
4616         if ( pMenu->ImplGetNextVisible( nLastVisible ) == ITEMPOS_INVALID )
4617         {
4618             bScrollDown = sal_False;
4619             ImplDrawScroller( sal_False );
4620         }
4621 
4622 //        nStartY -= nEntryHeight;
4623         Scroll( 0, -nScrollEntryHeight, ImplCalcClipRegion( sal_False ).GetBoundRect(), SCROLL_CLIP );
4624     }
4625 
4626     HighlightItem( nHighlightedItem, sal_True );
4627 }
4628 
ImplScroll(const Point & rMousePos)4629 void MenuFloatingWindow::ImplScroll( const Point& rMousePos )
4630 {
4631     Size aOutSz = GetOutputSizePixel();
4632 
4633     long nY = nScrollerHeight;
4634     long nMouseY = rMousePos.Y();
4635     long nDelta = 0;
4636 
4637     if ( bScrollUp && ( nMouseY < nY ) )
4638     {
4639         ImplScroll( sal_True );
4640         nDelta = nY - nMouseY;
4641     }
4642     else if ( bScrollDown && ( nMouseY > ( aOutSz.Height() - nY ) ) )
4643     {
4644         ImplScroll( sal_False );
4645         nDelta = nMouseY - ( aOutSz.Height() - nY );
4646     }
4647 
4648     if ( nDelta )
4649     {
4650         aScrollTimer.Stop();    // Falls durch MouseMove gescrollt.
4651         long nTimeout;
4652         if ( nDelta < 3 )
4653             nTimeout = 200;
4654         else if ( nDelta < 5 )
4655             nTimeout = 100;
4656         else if ( nDelta < 8 )
4657             nTimeout = 70;
4658         else if ( nDelta < 12 )
4659             nTimeout = 40;
4660         else
4661             nTimeout = 20;
4662         aScrollTimer.SetTimeout( nTimeout );
4663         aScrollTimer.Start();
4664     }
4665 }
ChangeHighlightItem(sal_uInt16 n,sal_Bool bStartPopupTimer)4666 void MenuFloatingWindow::ChangeHighlightItem( sal_uInt16 n, sal_Bool bStartPopupTimer )
4667 {
4668     // #57934# ggf. das aktive Popup sofort schliessen, damit TH's Hintergrundsicherung funktioniert.
4669     // #65750# Dann verzichten wir lieber auf den schmalen Streifen Hintergrundsicherung.
4670     //         Sonst lassen sich die Menus schlecht bedienen.
4671 //  MenuItemData* pNextData = pMenu->pItemList->GetDataFromPos( n );
4672 //  if ( pActivePopup && pNextData && ( pActivePopup != pNextData->pSubMenu ) )
4673 //      KillActivePopup();
4674 
4675     aSubmenuCloseTimer.Stop();
4676     if( ! pMenu )
4677         return;
4678 
4679     if ( nHighlightedItem != ITEMPOS_INVALID )
4680     {
4681         HighlightItem( nHighlightedItem, sal_False );
4682         pMenu->ImplCallEventListeners( VCLEVENT_MENU_DEHIGHLIGHT, nHighlightedItem );
4683     }
4684 
4685     nHighlightedItem = (sal_uInt16)n;
4686     DBG_ASSERT( pMenu->ImplIsVisible( nHighlightedItem ) || nHighlightedItem == ITEMPOS_INVALID, "ChangeHighlightItem: Not visible!" );
4687     if( nHighlightedItem != ITEMPOS_INVALID )
4688     {
4689         if( pMenu->pStartedFrom && !pMenu->pStartedFrom->bIsMenuBar )
4690         {
4691             // #102461# make sure parent entry is highlighted as well
4692             MenuItemData* pData;
4693             sal_uInt16 i, nCount = (sal_uInt16)pMenu->pStartedFrom->pItemList->Count();
4694             for(i = 0; i < nCount; i++)
4695             {
4696                 pData = pMenu->pStartedFrom->pItemList->GetDataFromPos( i );
4697                 if( pData && ( pData->pSubMenu == pMenu ) )
4698                     break;
4699             }
4700             if( i < nCount )
4701             {
4702                 MenuFloatingWindow* pPWin = (MenuFloatingWindow*)pMenu->pStartedFrom->ImplGetWindow();
4703                 if( pPWin && pPWin->nHighlightedItem != i )
4704                 {
4705                     pPWin->HighlightItem( i, sal_True );
4706                     pPWin->nHighlightedItem = i;
4707                 }
4708             }
4709         }
4710         HighlightItem( nHighlightedItem, sal_True );
4711 	pMenu->SetHightlightItem(nHighlightedItem);
4712         pMenu->ImplCallHighlight( nHighlightedItem );
4713     }
4714     else
4715         pMenu->nSelectedId = 0;
4716 
4717     if ( bStartPopupTimer )
4718 	{
4719 		// #102438# Menu items are not selectable
4720 		// If a menu item is selected by an AT-tool via the XAccessibleAction, XAccessibleValue
4721 		// or XAccessibleSelection interface, and the parent popup menus are not executed yet,
4722 		// the parent popup menus must be executed SYNCHRONOUSLY, before the menu item is selected.
4723 		if ( GetSettings().GetMouseSettings().GetMenuDelay() )
4724 			aHighlightChangedTimer.Start();
4725 		else
4726             HighlightChanged( &aHighlightChangedTimer );
4727 	}
4728 }
4729 
HighlightItem(sal_uInt16 nPos,sal_Bool bHighlight)4730 void MenuFloatingWindow::HighlightItem( sal_uInt16 nPos, sal_Bool bHighlight )
4731 {
4732     if( ! pMenu )
4733         return;
4734 
4735     Size    aSz = GetOutputSizePixel();
4736     long    nStartY = ImplGetStartY();
4737     long    nY = nScrollerHeight+nStartY;
4738     long    nX = 0;
4739 
4740     if ( pMenu->pLogo )
4741         nX = pMenu->pLogo->aBitmap.GetSizePixel().Width();
4742 
4743     int nOuterSpace = ImplGetSVData()->maNWFData.mnMenuFormatExtraBorder;
4744     nY += nOuterSpace;
4745 
4746     sal_uInt16 nCount = (sal_uInt16)pMenu->pItemList->Count();
4747     for ( sal_uInt16 n = 0; n < nCount; n++ )
4748     {
4749         MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
4750         if ( n == nPos )
4751         {
4752             DBG_ASSERT( pMenu->ImplIsVisible( n ), "Highlight: Item not visible!" );
4753             if ( pData->eType != MENUITEM_SEPARATOR )
4754             {
4755                 sal_Bool bRestoreLineColor = sal_False;
4756                 Color oldLineColor;
4757                 bool bDrawItemRect = true;
4758 
4759                 Rectangle aItemRect( Point( nX+nOuterSpace, nY ), Size( aSz.Width()-2*nOuterSpace, pData->aSz.Height() ) );
4760                 if ( pData->nBits & MIB_POPUPSELECT )
4761                 {
4762                     long nFontHeight = GetTextHeight();
4763                     aItemRect.Right() -= nFontHeight + nFontHeight/4;
4764                 }
4765 
4766                 if( IsNativeControlSupported( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL ) )
4767                 {
4768                     Size aPxSize( GetOutputSizePixel() );
4769                     Push( PUSH_CLIPREGION );
4770                     IntersectClipRegion( Rectangle( Point( nX, nY ), Size( aSz.Width(), pData->aSz.Height() ) ) );
4771                     Rectangle aCtrlRect( Point( nX, 0 ), Size( aPxSize.Width()-nX, aPxSize.Height() ) );
4772                     MenupopupValue aVal( pMenu->nTextPos-GUTTERBORDER, aItemRect );
4773                     DrawNativeControl( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL,
4774                                        aCtrlRect,
4775                                        CTRL_STATE_ENABLED,
4776                                        aVal,
4777                                        OUString() );
4778                     if( bHighlight &&
4779                         IsNativeControlSupported( CTRL_MENU_POPUP, PART_MENU_ITEM ) )
4780                     {
4781                         bDrawItemRect = false;
4782                         if( sal_False == DrawNativeControl( CTRL_MENU_POPUP, PART_MENU_ITEM,
4783                                                         aItemRect,
4784                                                         CTRL_STATE_SELECTED | ( pData->bEnabled? CTRL_STATE_ENABLED: 0 ),
4785                                                         aVal,
4786                                                         OUString() ) )
4787                         {
4788                             bDrawItemRect = bHighlight;
4789                         }
4790                     }
4791                     else
4792                         bDrawItemRect = bHighlight;
4793                     Pop();
4794                 }
4795                 if( bDrawItemRect )
4796                 {
4797                     if ( bHighlight )
4798                     {
4799                         if( pData->bEnabled )
4800                             SetFillColor( GetSettings().GetStyleSettings().GetMenuHighlightColor() );
4801                         else
4802                         {
4803                             SetFillColor();
4804                             oldLineColor = GetLineColor();
4805                             SetLineColor( GetSettings().GetStyleSettings().GetMenuHighlightColor() );
4806                             bRestoreLineColor = sal_True;
4807                         }
4808                     }
4809                     else
4810                         SetFillColor( GetSettings().GetStyleSettings().GetMenuColor() );
4811 
4812                     DrawRect( aItemRect );
4813                 }
4814                 pMenu->ImplPaint( this, nScrollerHeight, nStartY, pData, bHighlight );
4815                 if( bRestoreLineColor )
4816                     SetLineColor( oldLineColor );
4817             }
4818             return;
4819         }
4820 
4821         nY += pData->aSz.Height();
4822     }
4823 }
4824 
ImplGetItemRect(sal_uInt16 nPos)4825 Rectangle MenuFloatingWindow::ImplGetItemRect( sal_uInt16 nPos )
4826 {
4827     if( ! pMenu )
4828         return Rectangle();
4829 
4830 	Rectangle aRect;
4831     Size    aSz = GetOutputSizePixel();
4832     long    nStartY = ImplGetStartY();
4833     long    nY = nScrollerHeight+nStartY;
4834     long    nX = 0;
4835 
4836     if ( pMenu->pLogo )
4837         nX = pMenu->pLogo->aBitmap.GetSizePixel().Width();
4838 
4839     sal_uInt16 nCount = (sal_uInt16)pMenu->pItemList->Count();
4840     for ( sal_uInt16 n = 0; n < nCount; n++ )
4841     {
4842         MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
4843         if ( n == nPos )
4844         {
4845             DBG_ASSERT( pMenu->ImplIsVisible( n ), "ImplGetItemRect: Item not visible!" );
4846             if ( pData->eType != MENUITEM_SEPARATOR )
4847             {
4848                 aRect = Rectangle( Point( nX, nY ), Size( aSz.Width(), pData->aSz.Height() ) );
4849                 if ( pData->nBits & MIB_POPUPSELECT )
4850                 {
4851                     long nFontHeight = GetTextHeight();
4852                     aRect.Right() -= nFontHeight + nFontHeight/4;
4853                 }
4854             }
4855             break;
4856         }
4857         nY += pData->aSz.Height();
4858     }
4859 	return aRect;
4860 }
4861 
4862 
ImplCursorUpDown(sal_Bool bUp,sal_Bool bHomeEnd)4863 void MenuFloatingWindow::ImplCursorUpDown( sal_Bool bUp, sal_Bool bHomeEnd )
4864 {
4865     if( ! pMenu )
4866         return;
4867 
4868 	const StyleSettings& rSettings = GetSettings().GetStyleSettings();
4869 
4870     sal_uInt16 n = nHighlightedItem;
4871     if ( n == ITEMPOS_INVALID )
4872     {
4873         if ( bUp )
4874             n = 0;
4875         else
4876             n = pMenu->GetItemCount()-1;
4877     }
4878 
4879     sal_uInt16 nLoop = n;
4880 
4881 	if( bHomeEnd )
4882 	{
4883 		// absolute positioning
4884 		if( bUp )
4885 		{
4886             n = pMenu->GetItemCount();
4887 			nLoop = n-1;
4888 		}
4889 		else
4890 		{
4891 			n = (sal_uInt16)-1;
4892 			nLoop = n+1;
4893 		}
4894 	}
4895 
4896     do
4897     {
4898         if ( bUp )
4899         {
4900             if ( n )
4901                 n--;
4902             else
4903                 if ( !IsScrollMenu() || ( nHighlightedItem == ITEMPOS_INVALID ) )
4904                     n = pMenu->GetItemCount()-1;
4905                 else
4906                     break;
4907         }
4908         else
4909         {
4910             n++;
4911             if ( n >= pMenu->GetItemCount() )
4912             {
4913                 if ( !IsScrollMenu() || ( nHighlightedItem == ITEMPOS_INVALID ) )
4914                     n = 0;
4915                 else
4916                     break;
4917             }
4918         }
4919 
4920         MenuItemData* pData = (MenuItemData*)pMenu->GetItemList()->GetDataFromPos( n );
4921         if ( ( pData->bEnabled || !rSettings.GetSkipDisabledInMenus() )
4922 			  && ( pData->eType != MENUITEM_SEPARATOR ) && pMenu->ImplIsVisible( n ) && pMenu->ImplIsSelectable( n ) )
4923         {
4924             // Selektion noch im sichtbaren Bereich?
4925             if ( IsScrollMenu() )
4926             {
4927                 ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
4928 
4929                 while ( n < nFirstEntry )
4930                     ImplScroll( sal_True );
4931 
4932                 Size aOutSz = GetOutputSizePixel();
4933 				sal_uInt16 nLastVisible;
4934 				((PopupMenu*)pMenu)->ImplCalcVisEntries( aOutSz.Height(), nFirstEntry, &nLastVisible );
4935                 while ( n > nLastVisible )
4936 				{
4937                     ImplScroll( sal_False );
4938 					((PopupMenu*)pMenu)->ImplCalcVisEntries( aOutSz.Height(), nFirstEntry, &nLastVisible );
4939 				}
4940             }
4941             ChangeHighlightItem( n, sal_False );
4942             break;
4943         }
4944     } while ( n != nLoop );
4945 }
4946 
KeyInput(const KeyEvent & rKEvent)4947 void MenuFloatingWindow::KeyInput( const KeyEvent& rKEvent )
4948 {
4949     ImplDelData aDelData;
4950     ImplAddDel( &aDelData );
4951 
4952     sal_uInt16 nCode = rKEvent.GetKeyCode().GetCode();
4953     bKeyInput = sal_True;
4954     switch ( nCode )
4955     {
4956         case KEY_UP:
4957         case KEY_DOWN:
4958         {
4959             ImplCursorUpDown( nCode == KEY_UP );
4960         }
4961         break;
4962         case KEY_END:
4963         case KEY_HOME:
4964 		{
4965             ImplCursorUpDown( nCode == KEY_END, sal_True );
4966 		}
4967 		break;
4968         case KEY_F6:
4969         case KEY_ESCAPE:
4970 		{
4971             // Ctrl-F6 acts like ESC here, the menu bar however will then put the focus in the document
4972             if( nCode == KEY_F6 && !rKEvent.GetKeyCode().IsMod1() )
4973                 break;
4974             if( pMenu )
4975             {
4976                 if ( !pMenu->pStartedFrom )
4977                 {
4978                     StopExecute();
4979                     KillActivePopup();
4980                 }
4981                 else if ( pMenu->pStartedFrom->bIsMenuBar )
4982                 {
4983                     // Forward...
4984                     ((MenuBarWindow*)((MenuBar*)pMenu->pStartedFrom)->ImplGetWindow())->KeyInput( rKEvent );
4985                 }
4986                 else
4987                 {
4988                     StopExecute();
4989                     PopupMenu* pPopupMenu = (PopupMenu*)pMenu->pStartedFrom;
4990                     MenuFloatingWindow* pFloat = pPopupMenu->ImplGetFloatingWindow();
4991                     pFloat->GrabFocus();
4992                     pFloat->KillActivePopup();
4993                     pPopupMenu->ImplCallHighlight(pFloat->nHighlightedItem);
4994                 }
4995             }
4996 		}
4997 		break;
4998         case KEY_LEFT:
4999         {
5000             if ( pMenu && pMenu->pStartedFrom )
5001             {
5002                 StopExecute();
5003                 if ( pMenu->pStartedFrom->bIsMenuBar )
5004                 {
5005                     // Forward...
5006                     ((MenuBarWindow*)((MenuBar*)pMenu->pStartedFrom)->ImplGetWindow())->KeyInput( rKEvent );
5007                 }
5008                 else
5009                 {
5010                     MenuFloatingWindow* pFloat = ((PopupMenu*)pMenu->pStartedFrom)->ImplGetFloatingWindow();
5011                     pFloat->GrabFocus();
5012                     pFloat->KillActivePopup();
5013   		    sal_uInt16 highlightItem = pFloat->GetHighlightedItem();
5014 		    pFloat->ChangeHighlightItem(highlightItem, sal_False);
5015                 }
5016             }
5017         }
5018         break;
5019         case KEY_RIGHT:
5020         {
5021             if( pMenu )
5022             {
5023                 sal_Bool bDone = sal_False;
5024                 if ( nHighlightedItem != ITEMPOS_INVALID )
5025                 {
5026                     MenuItemData* pData = pMenu->GetItemList()->GetDataFromPos( nHighlightedItem );
5027                     if ( pData && pData->pSubMenu )
5028                     {
5029                         HighlightChanged( 0 );
5030                         bDone = sal_True;
5031                     }
5032                 }
5033                 if ( !bDone )
5034                 {
5035                     Menu* pStart = pMenu->ImplGetStartMenu();
5036                     if ( pStart && pStart->bIsMenuBar )
5037                     {
5038                         // Forward...
5039                         pStart->ImplGetWindow()->KeyInput( rKEvent );
5040                     }
5041                 }
5042             }
5043         }
5044         break;
5045         case KEY_RETURN:
5046         {
5047             if( pMenu )
5048             {
5049                 MenuItemData* pData = pMenu->GetItemList()->GetDataFromPos( nHighlightedItem );
5050                 if ( pData && pData->bEnabled )
5051                 {
5052                     if ( pData->pSubMenu )
5053                         HighlightChanged( 0 );
5054                     else
5055                         EndExecute();
5056                 }
5057                 else
5058                     StopExecute();
5059             }
5060         }
5061         break;
5062         case KEY_MENU:
5063         {
5064             if( pMenu )
5065             {
5066                 Menu* pStart = pMenu->ImplGetStartMenu();
5067                 if ( pStart && pStart->bIsMenuBar )
5068                 {
5069                     // Forward...
5070                     pStart->ImplGetWindow()->KeyInput( rKEvent );
5071                 }
5072             }
5073         }
5074         break;
5075         default:
5076         {
5077             xub_Unicode nCharCode = rKEvent.GetCharCode();
5078             sal_uInt16 nPos = 0;
5079 			sal_uInt16 nDuplicates = 0;
5080             MenuItemData* pData = (nCharCode && pMenu) ? pMenu->GetItemList()->SearchItem( nCharCode, rKEvent.GetKeyCode(), nPos, nDuplicates, nHighlightedItem ) : NULL;
5081             if ( pData )
5082             {
5083                 if ( pData->pSubMenu || nDuplicates > 1 )
5084                 {
5085                     ChangeHighlightItem( nPos, sal_False );
5086                     HighlightChanged( 0 );
5087                 }
5088                 else
5089                 {
5090                     nHighlightedItem = nPos;
5091                     EndExecute();
5092                 }
5093             }
5094             else
5095             {
5096                 // Bei ungueltigen Tasten Beepen, aber nicht bei HELP und F-Tasten
5097                 if ( !rKEvent.GetKeyCode().IsMod2() && ( nCode != KEY_HELP ) && ( rKEvent.GetKeyCode().GetGroup() != KEYGROUP_FKEYS ) )
5098                     Sound::Beep();
5099                 FloatingWindow::KeyInput( rKEvent );
5100             }
5101         }
5102     }
5103     // #105474# check if menu window was not destroyed
5104     if ( !aDelData.IsDelete() )
5105     {
5106         ImplRemoveDel( &aDelData );
5107         bKeyInput = sal_False;
5108     }
5109 }
5110 
Paint(const Rectangle &)5111 void MenuFloatingWindow::Paint( const Rectangle& )
5112 {
5113     if( ! pMenu )
5114         return;
5115 
5116     if( IsNativeControlSupported( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL ) )
5117     {
5118         SetClipRegion();
5119         long nX = pMenu->pLogo ? pMenu->pLogo->aBitmap.GetSizePixel().Width() : 0;
5120         Size aPxSize( GetOutputSizePixel() );
5121         aPxSize.Width() -= nX;
5122         ImplControlValue aVal( pMenu->nTextPos-GUTTERBORDER );
5123         DrawNativeControl( CTRL_MENU_POPUP, PART_ENTIRE_CONTROL,
5124                            Rectangle( Point( nX, 0 ), aPxSize ),
5125                            CTRL_STATE_ENABLED,
5126                            aVal,
5127                            OUString() );
5128         ImplInitClipRegion();
5129     }
5130     if ( IsScrollMenu() )
5131     {
5132         ImplDrawScroller( sal_True );
5133         ImplDrawScroller( sal_False );
5134     }
5135     SetFillColor( GetSettings().GetStyleSettings().GetMenuColor() );
5136     pMenu->ImplPaint( this, nScrollerHeight, ImplGetStartY() );
5137     if ( nHighlightedItem != ITEMPOS_INVALID )
5138         HighlightItem( nHighlightedItem, sal_True );
5139 }
5140 
ImplDrawScroller(sal_Bool bUp)5141 void MenuFloatingWindow::ImplDrawScroller( sal_Bool bUp )
5142 {
5143     if( ! pMenu )
5144         return;
5145 
5146     SetClipRegion();
5147 
5148     Size aOutSz = GetOutputSizePixel();
5149     long nY = bUp ? 0 : ( aOutSz.Height() - nScrollerHeight );
5150     long nX = pMenu->pLogo ? pMenu->pLogo->aBitmap.GetSizePixel().Width() : 0;
5151     Rectangle aRect( Point( nX, nY ), Size( aOutSz.Width()-nX, nScrollerHeight ) );
5152 
5153     DecorationView aDecoView( this );
5154     SymbolType eSymbol = bUp ? SYMBOL_SPIN_UP : SYMBOL_SPIN_DOWN;
5155 
5156     sal_uInt16 nStyle = 0;
5157     if ( ( bUp && !bScrollUp ) || ( !bUp && !bScrollDown ) )
5158         nStyle |= SYMBOL_DRAW_DISABLE;
5159 
5160     aDecoView.DrawSymbol( aRect, eSymbol, GetSettings().GetStyleSettings().GetButtonTextColor(), nStyle );
5161 
5162     ImplInitClipRegion();
5163 }
5164 
RequestHelp(const HelpEvent & rHEvt)5165 void MenuFloatingWindow::RequestHelp( const HelpEvent& rHEvt )
5166 {
5167     sal_uInt16 nId = nHighlightedItem;
5168     Menu* pM = pMenu;
5169     Window* pW = this;
5170 
5171     // #102618# Get item rect before destroying the window in EndExecute() call
5172 	Rectangle aHighlightRect( ImplGetItemRect( nHighlightedItem ) );
5173 
5174     if ( rHEvt.GetMode() & (HELPMODE_CONTEXT | HELPMODE_EXTENDED) )
5175     {
5176         nHighlightedItem = ITEMPOS_INVALID;
5177         EndExecute();
5178         pW = NULL;
5179     }
5180 
5181     if( !ImplHandleHelpEvent( pW, pM, nId, rHEvt, aHighlightRect ) )
5182         Window::RequestHelp( rHEvt );
5183 }
5184 
StateChanged(StateChangedType nType)5185 void MenuFloatingWindow::StateChanged( StateChangedType nType )
5186 {
5187     FloatingWindow::StateChanged( nType );
5188 
5189     if ( ( nType == STATE_CHANGE_CONTROLFOREGROUND ) || ( nType == STATE_CHANGE_CONTROLBACKGROUND ) )
5190     {
5191         ImplInitMenuWindow( this, sal_False, sal_False );
5192         Invalidate();
5193     }
5194 }
5195 
DataChanged(const DataChangedEvent & rDCEvt)5196 void MenuFloatingWindow::DataChanged( const DataChangedEvent& rDCEvt )
5197 {
5198     FloatingWindow::DataChanged( rDCEvt );
5199 
5200     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
5201          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
5202          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
5203           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
5204     {
5205         ImplInitMenuWindow( this, sal_False, sal_False );
5206         Invalidate();
5207     }
5208 }
5209 
Command(const CommandEvent & rCEvt)5210 void MenuFloatingWindow::Command( const CommandEvent& rCEvt )
5211 {
5212     if ( rCEvt.GetCommand() == COMMAND_WHEEL )
5213     {
5214         const CommandWheelData* pData = rCEvt.GetWheelData();
5215         if( !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) )
5216         {
5217 //          ImplCursorUpDown( pData->GetDelta() > 0L );
5218             ImplScroll( pData->GetDelta() > 0L );
5219             MouseMove( MouseEvent( GetPointerPosPixel(), 0 ) );
5220         }
5221     }
5222 }
5223 
CreateAccessible()5224 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > MenuFloatingWindow::CreateAccessible()
5225 {
5226 	::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc;
5227 
5228 	if ( pMenu && !pMenu->pStartedFrom )
5229 		xAcc = pMenu->GetAccessible();
5230 
5231 	return xAcc;
5232 }
5233 
MenuBarWindow(Window * pParent)5234 MenuBarWindow::MenuBarWindow( Window* pParent ) :
5235     Window( pParent, 0 ),
5236     aCloser( this ),
5237     aFloatBtn( this, WB_NOPOINTERFOCUS | WB_SMALLSTYLE | WB_RECTSTYLE ),
5238     aHideBtn( this, WB_NOPOINTERFOCUS | WB_SMALLSTYLE | WB_RECTSTYLE )
5239 {
5240     SetType( WINDOW_MENUBARWINDOW );
5241     pMenu = NULL;
5242     pActivePopup = NULL;
5243     nSaveFocusId = 0;
5244     nHighlightedItem = ITEMPOS_INVALID;
5245     mbAutoPopup = sal_True;
5246     nSaveFocusId = 0;
5247 	bIgnoreFirstMove = sal_True;
5248 	bStayActive = sal_False;
5249 
5250     ResMgr* pResMgr = ImplGetResMgr();
5251 
5252     if( pResMgr )
5253     {
5254         BitmapEx aBitmap( ResId( SV_RESID_BITMAP_CLOSEDOC, *pResMgr ) );
5255         BitmapEx aBitmapHC( ResId( SV_RESID_BITMAP_CLOSEDOCHC, *pResMgr ) );
5256 
5257         aCloser.maImage = Image( aBitmap );
5258         aCloser.maImageHC = Image( aBitmapHC );
5259 
5260         aCloser.SetOutStyle( TOOLBOX_STYLE_FLAT );
5261         aCloser.SetBackground();
5262         aCloser.SetPaintTransparent( sal_True );
5263         aCloser.SetParentClipMode( PARENTCLIPMODE_NOCLIP );
5264 
5265         aCloser.InsertItem( IID_DOCUMENTCLOSE,
5266         GetSettings().GetStyleSettings().GetHighContrastMode() ? aCloser.maImageHC : aCloser.maImage, 0 );
5267         aCloser.SetSelectHdl( LINK( this, MenuBarWindow, CloserHdl ) );
5268         aCloser.AddEventListener( LINK( this, MenuBarWindow, ToolboxEventHdl ) );
5269         aCloser.SetQuickHelpText( IID_DOCUMENTCLOSE, XubString( ResId( SV_HELPTEXT_CLOSEDOCUMENT, *pResMgr ) ) );
5270 
5271         aFloatBtn.SetClickHdl( LINK( this, MenuBarWindow, FloatHdl ) );
5272         aFloatBtn.SetSymbol( SYMBOL_FLOAT );
5273         aFloatBtn.SetQuickHelpText( XubString( ResId( SV_HELPTEXT_RESTORE, *pResMgr ) ) );
5274 
5275         aHideBtn.SetClickHdl( LINK( this, MenuBarWindow, HideHdl ) );
5276         aHideBtn.SetSymbol( SYMBOL_HIDE );
5277         aHideBtn.SetQuickHelpText( XubString( ResId( SV_HELPTEXT_MINIMIZE, *pResMgr ) ) );
5278     }
5279 
5280     ImplInitStyleSettings();
5281 
5282     AddEventListener( LINK( this, MenuBarWindow, ShowHideListener ) );
5283 }
5284 
~MenuBarWindow()5285 MenuBarWindow::~MenuBarWindow()
5286 {
5287     aCloser.RemoveEventListener( LINK( this, MenuBarWindow, ToolboxEventHdl ) );
5288     RemoveEventListener( LINK( this, MenuBarWindow, ShowHideListener ) );
5289 }
5290 
SetMenu(MenuBar * pMen)5291 void MenuBarWindow::SetMenu( MenuBar* pMen )
5292 {
5293     pMenu = pMen;
5294     KillActivePopup();
5295     nHighlightedItem = ITEMPOS_INVALID;
5296     ImplInitMenuWindow( this, sal_True, sal_True );
5297     if ( pMen )
5298     {
5299         aCloser.ShowItem( IID_DOCUMENTCLOSE, pMen->HasCloser() );
5300         aCloser.Show( pMen->HasCloser() || !m_aAddButtons.empty() );
5301         aFloatBtn.Show( pMen->HasFloatButton() );
5302         aHideBtn.Show( pMen->HasHideButton() );
5303     }
5304     Invalidate();
5305 
5306     // show and connect native menubar
5307     if( pMenu && pMenu->ImplGetSalMenu() )
5308     {
5309         if( pMenu->ImplGetSalMenu()->VisibleMenuBar() )
5310             ImplGetFrame()->SetMenu( pMenu->ImplGetSalMenu() );
5311 
5312         pMenu->ImplGetSalMenu()->SetFrame( ImplGetFrame() );
5313     }
5314 }
5315 
ShowButtons(sal_Bool bClose,sal_Bool bFloat,sal_Bool bHide)5316 void MenuBarWindow::ShowButtons( sal_Bool bClose, sal_Bool bFloat, sal_Bool bHide )
5317 {
5318     aCloser.ShowItem( IID_DOCUMENTCLOSE, bClose );
5319     aCloser.Show( bClose || ! m_aAddButtons.empty() );
5320     aFloatBtn.Show( bFloat );
5321     aHideBtn.Show( bHide );
5322     Resize();
5323 }
5324 
MinCloseButtonSize()5325 Size MenuBarWindow::MinCloseButtonSize()
5326 {
5327     return aCloser.getMinSize();
5328 }
5329 
IMPL_LINK(MenuBarWindow,CloserHdl,PushButton *,EMPTYARG)5330 IMPL_LINK( MenuBarWindow, CloserHdl, PushButton*, EMPTYARG )
5331 {
5332     if( ! pMenu )
5333         return 0;
5334 
5335     if( aCloser.GetCurItemId() == IID_DOCUMENTCLOSE )
5336     {
5337         // #i106052# call close hdl asynchronously to ease handler implementation
5338         // this avoids still being in the handler while the DecoToolBox already
5339         // gets destroyed
5340         Application::PostUserEvent( ((MenuBar*)pMenu)->GetCloserHdl(), pMenu );
5341     }
5342     else
5343     {
5344         std::map<sal_uInt16,AddButtonEntry>::iterator it = m_aAddButtons.find( aCloser.GetCurItemId() );
5345         if( it != m_aAddButtons.end() )
5346         {
5347             MenuBar::MenuBarButtonCallbackArg aArg;
5348             aArg.nId = it->first;
5349             aArg.bHighlight = (aCloser.GetHighlightItemId() == it->first);
5350             aArg.pMenuBar = dynamic_cast<MenuBar*>(pMenu);
5351             return it->second.m_aSelectLink.Call( &aArg );
5352         }
5353     }
5354     return 0;
5355 }
5356 
IMPL_LINK(MenuBarWindow,ToolboxEventHdl,VclWindowEvent *,pEvent)5357 IMPL_LINK( MenuBarWindow, ToolboxEventHdl, VclWindowEvent*, pEvent )
5358 {
5359     if( ! pMenu )
5360         return 0;
5361 
5362     MenuBar::MenuBarButtonCallbackArg aArg;
5363     aArg.nId = 0xffff;
5364     aArg.bHighlight = (pEvent->GetId() == VCLEVENT_TOOLBOX_HIGHLIGHT);
5365     aArg.pMenuBar = dynamic_cast<MenuBar*>(pMenu);
5366     if( pEvent->GetId() == VCLEVENT_TOOLBOX_HIGHLIGHT )
5367         aArg.nId = aCloser.GetHighlightItemId();
5368     else if( pEvent->GetId() == VCLEVENT_TOOLBOX_HIGHLIGHTOFF )
5369     {
5370         sal_uInt16 nPos = static_cast< sal_uInt16 >(reinterpret_cast<sal_IntPtr>(pEvent->GetData()));
5371         aArg.nId = aCloser.GetItemId( nPos );
5372     }
5373     std::map< sal_uInt16, AddButtonEntry >::iterator it = m_aAddButtons.find( aArg.nId );
5374     if( it != m_aAddButtons.end() )
5375     {
5376         it->second.m_aHighlightLink.Call( &aArg );
5377     }
5378     return 0;
5379 }
5380 
IMPL_LINK(MenuBarWindow,ShowHideListener,VclWindowEvent *,pEvent)5381 IMPL_LINK( MenuBarWindow, ShowHideListener, VclWindowEvent*, pEvent )
5382 {
5383     if( ! pMenu )
5384         return 0;
5385 
5386     if( pEvent->GetId() == VCLEVENT_WINDOW_SHOW )
5387         pMenu->ImplCallEventListeners( VCLEVENT_MENU_SHOW, ITEMPOS_INVALID );
5388     else if( pEvent->GetId() == VCLEVENT_WINDOW_HIDE )
5389         pMenu->ImplCallEventListeners( VCLEVENT_MENU_HIDE, ITEMPOS_INVALID );
5390     return 0;
5391 }
5392 
IMPL_LINK(MenuBarWindow,FloatHdl,PushButton *,EMPTYARG)5393 IMPL_LINK( MenuBarWindow, FloatHdl, PushButton*, EMPTYARG )
5394 {
5395     return pMenu ? ((MenuBar*)pMenu)->GetFloatButtonClickHdl().Call( pMenu ) : 0;
5396 }
5397 
IMPL_LINK(MenuBarWindow,HideHdl,PushButton *,EMPTYARG)5398 IMPL_LINK( MenuBarWindow, HideHdl, PushButton*, EMPTYARG )
5399 {
5400     return pMenu ? ((MenuBar*)pMenu)->GetHideButtonClickHdl().Call( pMenu ) : 0;
5401 }
5402 
ImplCreatePopup(sal_Bool bPreSelectFirst)5403 void MenuBarWindow::ImplCreatePopup( sal_Bool bPreSelectFirst )
5404 {
5405     MenuItemData* pItemData = pMenu ? pMenu->GetItemList()->GetDataFromPos( nHighlightedItem ) : NULL;
5406     if ( pItemData )
5407     {
5408 		bIgnoreFirstMove = sal_True;
5409         if ( pActivePopup && ( pActivePopup != pItemData->pSubMenu ) )
5410         {
5411             KillActivePopup();
5412         }
5413         if ( pItemData->bEnabled && pItemData->pSubMenu && ( nHighlightedItem != ITEMPOS_INVALID ) && ( pItemData->pSubMenu != pActivePopup ) )
5414         {
5415             pActivePopup = (PopupMenu*)pItemData->pSubMenu;
5416             long nX = 0;
5417             MenuItemData* pData = 0;
5418             for ( sal_uLong n = 0; n < nHighlightedItem; n++ )
5419             {
5420                 pData = pMenu->GetItemList()->GetDataFromPos( n );
5421                 nX += pData->aSz.Width();
5422             }
5423             pData = pMenu->pItemList->GetDataFromPos( nHighlightedItem );
5424 //          Point MyPos = GetPosPixel();
5425 //          Point aItemTopLeft( MyPos.X()+nX, MyPos.Y() );
5426             Point aItemTopLeft( nX, 0 );
5427             Point aItemBottomRight( aItemTopLeft );
5428             aItemBottomRight.X() += pData->aSz.Width();
5429 
5430             // Im Vollbild-Modus hat die MenuBar ggf. die Hoehe 0:
5431             // Nicht immer einfach die Window-Hoehe nehmen, weil ItemHeight < WindowHeight.
5432             if ( GetSizePixel().Height() )
5433             {
5434                 // #107747# give menuitems the height of the menubar
5435                 aItemBottomRight.Y() += GetOutputSizePixel().Height()-1;
5436             }
5437 
5438             // ImplExecute ist doch nicht modal...
5439             // #99071# do not grab the focus, otherwise it will be restored to the menubar
5440             // when the frame is reactivated later
5441             //GrabFocus();
5442             pActivePopup->ImplExecute( this, Rectangle( aItemTopLeft, aItemBottomRight ), FLOATWIN_POPUPMODE_DOWN, pMenu, bPreSelectFirst );
5443             if ( pActivePopup )
5444             {
5445                 // Hat kein Window, wenn vorher abgebrochen oder keine Eintraege
5446                 if ( pActivePopup->ImplGetFloatingWindow() )
5447                     pActivePopup->ImplGetFloatingWindow()->AddPopupModeWindow( this );
5448                 else
5449                     pActivePopup = NULL;
5450             }
5451         }
5452     }
5453 }
5454 
5455 
KillActivePopup()5456 void MenuBarWindow::KillActivePopup()
5457 {
5458     if ( pActivePopup )
5459     {
5460         if( pActivePopup->pWindow != NULL )
5461             if( ((FloatingWindow *) pActivePopup->pWindow)->IsInCleanUp() )
5462                 return; // kill it later
5463 
5464         if ( pActivePopup->bInCallback )
5465             pActivePopup->bCanceled = sal_True;
5466 
5467         pActivePopup->bInCallback = sal_True;
5468         pActivePopup->Deactivate();
5469         pActivePopup->bInCallback = sal_False;
5470         // Abfrage auf pActivePopup, falls im Deactivate abgeschossen...
5471         if ( pActivePopup && pActivePopup->ImplGetWindow() )
5472         {
5473             pActivePopup->ImplGetFloatingWindow()->StopExecute();
5474             pActivePopup->ImplGetFloatingWindow()->doShutdown();
5475             pActivePopup->pWindow->doLazyDelete();
5476             pActivePopup->pWindow = NULL;
5477         }
5478         pActivePopup = 0;
5479     }
5480 }
5481 
PopupClosed(Menu * pPopup)5482 void MenuBarWindow::PopupClosed( Menu* pPopup )
5483 {
5484     if ( pPopup == pActivePopup )
5485     {
5486         KillActivePopup();
5487         ChangeHighlightItem( ITEMPOS_INVALID, sal_False, ImplGetFrameWindow()->ImplGetFrameData()->mbHasFocus, sal_False );
5488     }
5489 }
5490 
MouseButtonDown(const MouseEvent & rMEvt)5491 void MenuBarWindow::MouseButtonDown( const MouseEvent& rMEvt )
5492 {
5493     mbAutoPopup = sal_True;
5494     sal_uInt16 nEntry = ImplFindEntry( rMEvt.GetPosPixel() );
5495     if ( ( nEntry != ITEMPOS_INVALID ) && ( nEntry != nHighlightedItem ) )
5496     {
5497         ChangeHighlightItem( nEntry, sal_False );
5498     }
5499     else
5500     {
5501         KillActivePopup();
5502         ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
5503     }
5504 }
5505 
MouseButtonUp(const MouseEvent &)5506 void MenuBarWindow::MouseButtonUp( const MouseEvent& )
5507 {
5508 }
5509 
MouseMove(const MouseEvent & rMEvt)5510 void MenuBarWindow::MouseMove( const MouseEvent& rMEvt )
5511 {
5512     // Im Move nur Highlighten, wenn schon eins gehighlightet.
5513     if ( rMEvt.IsSynthetic() || rMEvt.IsLeaveWindow() || rMEvt.IsEnterWindow() || ( nHighlightedItem == ITEMPOS_INVALID ) )
5514         return;
5515 
5516 	if( bIgnoreFirstMove )
5517 	{
5518 		bIgnoreFirstMove = sal_False;
5519 		return;
5520 	}
5521 
5522     sal_uInt16 nEntry = ImplFindEntry( rMEvt.GetPosPixel() );
5523     if ( ( nEntry != ITEMPOS_INVALID )
5524 #ifdef OS2
5525        && ( ImplHilite(rMEvt) )
5526 #endif
5527 	   && ( nEntry != nHighlightedItem ) )
5528         ChangeHighlightItem( nEntry, sal_False );
5529 }
5530 
ChangeHighlightItem(sal_uInt16 n,sal_Bool bSelectEntry,sal_Bool bAllowRestoreFocus,sal_Bool bDefaultToDocument)5531 void MenuBarWindow::ChangeHighlightItem( sal_uInt16 n, sal_Bool bSelectEntry, sal_Bool bAllowRestoreFocus, sal_Bool bDefaultToDocument)
5532 {
5533     if( ! pMenu )
5534         return;
5535 
5536     // #57934# ggf. das aktive Popup sofort schliessen, damit TH's Hintergrundsicherung funktioniert.
5537     MenuItemData* pNextData = pMenu->pItemList->GetDataFromPos( n );
5538     if ( pActivePopup && pActivePopup->ImplGetWindow() && ( !pNextData || ( pActivePopup != pNextData->pSubMenu ) ) )
5539         KillActivePopup(); // pActivePopup ggf. ohne pWin, wenn in Activate() Rescheduled wurde
5540 
5541     // Activate am MenuBar immer nur einmal pro Vorgang...
5542     sal_Bool bJustActivated = sal_False;
5543     if ( ( nHighlightedItem == ITEMPOS_INVALID ) && ( n != ITEMPOS_INVALID ) )
5544     {
5545         ImplGetSVData()->maWinData.mbNoDeactivate = sal_True;
5546         if( !bStayActive )
5547 		{
5548             // #105406# avoid saving the focus when we already have the focus
5549             sal_Bool bNoSaveFocus = (this == ImplGetSVData()->maWinData.mpFocusWin );
5550 
5551 			if( nSaveFocusId )
5552 			{
5553 				if( !ImplGetSVData()->maWinData.mbNoSaveFocus )
5554 				{
5555 					// we didn't clean up last time
5556 					Window::EndSaveFocus( nSaveFocusId, sal_False );	// clean up
5557                     nSaveFocusId = 0;
5558                     if( !bNoSaveFocus )
5559 					    nSaveFocusId = Window::SaveFocus();	// only save focus when initially activated
5560 				}
5561 				else {
5562 					; // do nothing: we 're activated again from taskpanelist, focus was already saved
5563                 }
5564 			}
5565 			else
5566 			{
5567                 if( !bNoSaveFocus )
5568 				    nSaveFocusId = Window::SaveFocus();	// only save focus when initially activated
5569 			}
5570 		}
5571 		else
5572 			bStayActive = sal_False;
5573         pMenu->bInCallback = sal_True;  // hier schon setzen, falls Activate ueberladen
5574         pMenu->Activate();
5575         pMenu->bInCallback = sal_False;
5576         bJustActivated = sal_True;
5577     }
5578     else if ( ( nHighlightedItem != ITEMPOS_INVALID ) && ( n == ITEMPOS_INVALID ) )
5579     {
5580         pMenu->bInCallback = sal_True;
5581         pMenu->Deactivate();
5582         pMenu->bInCallback = sal_False;
5583         ImplGetSVData()->maWinData.mbNoDeactivate = sal_False;
5584 		if( !ImplGetSVData()->maWinData.mbNoSaveFocus )
5585 		{
5586 			sal_uLong nTempFocusId = nSaveFocusId;
5587 			nSaveFocusId = 0;
5588 			Window::EndSaveFocus( nTempFocusId, bAllowRestoreFocus );
5589             // #105406# restore focus to document if we could not save focus before
5590             if( bDefaultToDocument && !nTempFocusId && bAllowRestoreFocus )
5591                 GrabFocusToDocument();
5592 		}
5593     }
5594 
5595     if ( nHighlightedItem != ITEMPOS_INVALID )
5596     {
5597         HighlightItem( nHighlightedItem, sal_False );
5598         pMenu->ImplCallEventListeners( VCLEVENT_MENU_DEHIGHLIGHT, nHighlightedItem );
5599     }
5600 
5601     nHighlightedItem = (sal_uInt16)n;
5602     DBG_ASSERT( ( nHighlightedItem == ITEMPOS_INVALID ) || pMenu->ImplIsVisible( nHighlightedItem ), "ChangeHighlightItem: Not visible!" );
5603     HighlightItem( nHighlightedItem, sal_True );
5604     pMenu->SetHightlightItem(nHighlightedItem);
5605     pMenu->ImplCallHighlight( nHighlightedItem );
5606 
5607     if( mbAutoPopup )
5608         ImplCreatePopup( bSelectEntry );
5609 
5610     // #58935# #73659# Focus, wenn kein Popup drunter haengt...
5611     if ( bJustActivated && !pActivePopup )
5612         GrabFocus();
5613 }
5614 
HighlightItem(sal_uInt16 nPos,sal_Bool bHighlight)5615 void MenuBarWindow::HighlightItem( sal_uInt16 nPos, sal_Bool bHighlight )
5616 {
5617     if( ! pMenu )
5618         return;
5619 
5620     long nX = 0;
5621     sal_uLong nCount = pMenu->pItemList->Count();
5622     for ( sal_uLong n = 0; n < nCount; n++ )
5623     {
5624         MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
5625         if ( n == nPos )
5626         {
5627             if ( pData->eType != MENUITEM_SEPARATOR )
5628             {
5629                 // #107747# give menuitems the height of the menubar
5630                 Rectangle aRect = Rectangle( Point( nX, 1 ), Size( pData->aSz.Width(), GetOutputSizePixel().Height()-2 ) );
5631                 Push( PUSH_CLIPREGION );
5632                 IntersectClipRegion( aRect );
5633                 if ( bHighlight )
5634                 {
5635                     if( IsNativeControlSupported( CTRL_MENUBAR, PART_MENU_ITEM ) &&
5636                         IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL ) )
5637                     {
5638                         // draw background (transparency)
5639                         MenubarValue aControlValue;
5640                         aControlValue.maTopDockingAreaHeight = ImplGetTopDockingAreaHeight( this );
5641 
5642                         Point tmp(0,0);
5643                         Rectangle aBgRegion( tmp, GetOutputSizePixel() );
5644                         DrawNativeControl( CTRL_MENUBAR, PART_ENTIRE_CONTROL,
5645                                            aBgRegion,
5646                                            CTRL_STATE_ENABLED,
5647                                            aControlValue,
5648                                            OUString() );
5649                         ImplAddNWFSeparator( this, aControlValue );
5650 
5651                         // draw selected item
5652                         DrawNativeControl( CTRL_MENUBAR, PART_MENU_ITEM,
5653                                            aRect,
5654                                            CTRL_STATE_ENABLED | CTRL_STATE_SELECTED,
5655                                            aControlValue,
5656                                            OUString() );
5657                     }
5658                     else
5659                     {
5660                         SetFillColor( GetSettings().GetStyleSettings().GetMenuHighlightColor() );
5661                         SetLineColor();
5662                         DrawRect( aRect );
5663                     }
5664                 }
5665                 else
5666                 {
5667                     if( IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL) )
5668                     {
5669                         MenubarValue aMenubarValue;
5670                         aMenubarValue.maTopDockingAreaHeight = ImplGetTopDockingAreaHeight( this );
5671 
5672                         // use full window size to get proper gradient
5673                         // but clip accordingly
5674                         Point aPt;
5675                         Rectangle aCtrlRect( aPt, GetOutputSizePixel() );
5676 
5677                         DrawNativeControl( CTRL_MENUBAR, PART_ENTIRE_CONTROL, aCtrlRect, CTRL_STATE_ENABLED, aMenubarValue, rtl::OUString() );
5678                         ImplAddNWFSeparator( this, aMenubarValue );
5679                     }
5680                     else
5681                         Erase( aRect );
5682                 }
5683                 Pop();
5684                 pMenu->ImplPaint( this, 0, 0, pData, bHighlight );
5685             }
5686             return;
5687         }
5688 
5689         nX += pData->aSz.Width();
5690     }
5691 }
5692 
ImplGetItemRect(sal_uInt16 nPos)5693 Rectangle MenuBarWindow::ImplGetItemRect( sal_uInt16 nPos )
5694 {
5695 	Rectangle aRect;
5696     if( pMenu )
5697     {
5698         long nX = 0;
5699         sal_uLong nCount = pMenu->pItemList->Count();
5700         for ( sal_uLong n = 0; n < nCount; n++ )
5701         {
5702             MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
5703             if ( n == nPos )
5704             {
5705                 if ( pData->eType != MENUITEM_SEPARATOR )
5706                     // #107747# give menuitems the height of the menubar
5707                     aRect = Rectangle( Point( nX, 1 ), Size( pData->aSz.Width(), GetOutputSizePixel().Height()-2 ) );
5708                 break;
5709             }
5710 
5711             nX += pData->aSz.Width();
5712         }
5713     }
5714 	return aRect;
5715 }
5716 
KeyInput(const KeyEvent & rKEvent)5717 void MenuBarWindow::KeyInput( const KeyEvent& rKEvent )
5718 {
5719     if ( !ImplHandleKeyEvent( rKEvent ) )
5720         Window::KeyInput( rKEvent );
5721 }
5722 
ImplHandleKeyEvent(const KeyEvent & rKEvent,sal_Bool bFromMenu)5723 sal_Bool MenuBarWindow::ImplHandleKeyEvent( const KeyEvent& rKEvent, sal_Bool bFromMenu )
5724 {
5725     if( ! pMenu )
5726         return sal_False;
5727 
5728     if ( pMenu->bInCallback )
5729         return sal_True;    // schlucken
5730 
5731     sal_Bool bDone = sal_False;
5732     sal_uInt16 nCode = rKEvent.GetKeyCode().GetCode();
5733 
5734 	if( GetParent() )
5735 	{
5736 		if( GetParent()->GetWindow( WINDOW_CLIENT )->IsSystemWindow() )
5737         {
5738 		    SystemWindow *pSysWin = (SystemWindow*)GetParent()->GetWindow( WINDOW_CLIENT );
5739 		    if( pSysWin->GetTaskPaneList() )
5740 			    if( pSysWin->GetTaskPaneList()->HandleKeyEvent( rKEvent ) )
5741 				    return sal_True;
5742         }
5743 	}
5744 
5745     if ( nCode == KEY_MENU && !rKEvent.GetKeyCode().IsShift() ) // only F10, not Shift-F10
5746     {
5747         mbAutoPopup = ImplGetSVData()->maNWFData.mbOpenMenuOnF10;
5748         if ( nHighlightedItem == ITEMPOS_INVALID )
5749         {
5750             ChangeHighlightItem( 0, sal_False );
5751             GrabFocus();
5752         }
5753         else
5754         {
5755             ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
5756             nSaveFocusId = 0;
5757         }
5758         bDone = sal_True;
5759     }
5760     else if ( bFromMenu )
5761     {
5762         if ( ( nCode == KEY_LEFT ) || ( nCode == KEY_RIGHT ) ||
5763 			( nCode == KEY_HOME ) || ( nCode == KEY_END ) )
5764         {
5765             sal_uInt16 n = nHighlightedItem;
5766             if ( n == ITEMPOS_INVALID )
5767             {
5768                 if ( nCode == KEY_LEFT)
5769                     n = 0;
5770                 else
5771                     n = pMenu->GetItemCount()-1;
5772             }
5773 
5774             // handling gtk like (aka mbOpenMenuOnF10)
5775             // do not highlight an item when opening a sub menu
5776             // unless there already was a higlighted sub menu item
5777             bool bWasHighlight = false;
5778             if( pActivePopup )
5779             {
5780                 MenuFloatingWindow* pSubWindow = dynamic_cast<MenuFloatingWindow*>(pActivePopup->ImplGetWindow());
5781                 if( pSubWindow )
5782                     bWasHighlight = (pSubWindow->GetHighlightedItem() != ITEMPOS_INVALID);
5783             }
5784 
5785             sal_uInt16 nLoop = n;
5786 
5787 			if( nCode == KEY_HOME )
5788 				{ n = (sal_uInt16)-1; nLoop = n+1; }
5789 			if( nCode == KEY_END )
5790 				{ n = pMenu->GetItemCount(); nLoop = n-1; }
5791 
5792             do
5793             {
5794                 if ( nCode == KEY_LEFT || nCode == KEY_END )
5795                 {
5796                     if ( n )
5797                         n--;
5798                     else
5799                         n = pMenu->GetItemCount()-1;
5800                 }
5801                 if ( nCode == KEY_RIGHT || nCode == KEY_HOME )
5802                 {
5803                     n++;
5804                     if ( n >= pMenu->GetItemCount() )
5805                         n = 0;
5806                 }
5807 
5808                 MenuItemData* pData = (MenuItemData*)pMenu->GetItemList()->GetDataFromPos( n );
5809                 if ( ( pData->eType != MENUITEM_SEPARATOR ) && pMenu->ImplIsVisible( n ) )
5810                 {
5811                     sal_Bool bDoSelect = sal_True;
5812                     if( ImplGetSVData()->maNWFData.mbOpenMenuOnF10 )
5813                         bDoSelect = bWasHighlight;
5814                     ChangeHighlightItem( n, bDoSelect );
5815                     break;
5816                 }
5817             } while ( n != nLoop );
5818             bDone = sal_True;
5819         }
5820         else if ( nCode == KEY_RETURN )
5821         {
5822             if( pActivePopup ) KillActivePopup();
5823 			else
5824 				if ( !mbAutoPopup )
5825 				{
5826 					ImplCreatePopup( sal_True );
5827 					mbAutoPopup = sal_True;
5828 				}
5829             bDone = sal_True;
5830         }
5831         else if ( ( nCode == KEY_UP ) || ( nCode == KEY_DOWN ) )
5832         {
5833             if ( !mbAutoPopup )
5834             {
5835                 ImplCreatePopup( sal_True );
5836                 mbAutoPopup = sal_True;
5837             }
5838             bDone = sal_True;
5839         }
5840         else if ( nCode == KEY_ESCAPE || ( nCode == KEY_F6 && rKEvent.GetKeyCode().IsMod1() ) )
5841         {
5842 			if( pActivePopup )
5843 			{
5844 				// bring focus to menu bar without any open popup
5845 				mbAutoPopup = sal_False;
5846 				sal_uInt16 n = nHighlightedItem;
5847 				nHighlightedItem = ITEMPOS_INVALID;
5848 				bStayActive = sal_True;
5849 				ChangeHighlightItem( n, sal_False );
5850 				bStayActive = sal_False;
5851 				KillActivePopup();
5852 				GrabFocus();
5853 			}
5854 			else
5855 				ChangeHighlightItem( ITEMPOS_INVALID, sal_False );
5856 
5857             if( nCode == KEY_F6 && rKEvent.GetKeyCode().IsMod1() )
5858             {
5859                 // put focus into document
5860                 GrabFocusToDocument();
5861             }
5862 
5863             bDone = sal_True;
5864         }
5865     }
5866 
5867     if ( !bDone && ( bFromMenu || rKEvent.GetKeyCode().IsMod2() ) )
5868     {
5869         xub_Unicode nCharCode = rKEvent.GetCharCode();
5870         if ( nCharCode )
5871         {
5872             sal_uInt16 nEntry, nDuplicates;
5873             MenuItemData* pData = pMenu->GetItemList()->SearchItem( nCharCode, rKEvent.GetKeyCode(), nEntry, nDuplicates, nHighlightedItem );
5874             if ( pData && (nEntry != ITEMPOS_INVALID) )
5875             {
5876                 mbAutoPopup = sal_True;
5877                 ChangeHighlightItem( nEntry, sal_True );
5878                 bDone = sal_True;
5879             }
5880             else
5881             {
5882                 // Wegen Systemmenu und anderen System-HotKeys, nur
5883                 // eigenstaendige Character-Kombinationen auswerten
5884                 sal_uInt16 nKeyCode = rKEvent.GetKeyCode().GetCode();
5885                 if ( ((nKeyCode >= KEY_A) && (nKeyCode <= KEY_Z)) )
5886                     Sound::Beep();
5887             }
5888         }
5889     }
5890     return bDone;
5891 }
5892 
Paint(const Rectangle &)5893 void MenuBarWindow::Paint( const Rectangle& )
5894 {
5895     if( ! pMenu )
5896         return;
5897 
5898     // no VCL paint if native menus
5899     if( pMenu->ImplGetSalMenu() && pMenu->ImplGetSalMenu()->VisibleMenuBar() )
5900     {
5901         ImplGetFrame()->DrawMenuBar();
5902         return;
5903     }
5904 
5905     if( IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL) )
5906     {
5907         Point aPt;
5908         Rectangle aCtrlRegion( aPt, GetOutputSizePixel() );
5909 
5910         MenubarValue aMenubarValue;
5911         aMenubarValue.maTopDockingAreaHeight = ImplGetTopDockingAreaHeight( this );
5912 
5913         DrawNativeControl( CTRL_MENUBAR, PART_ENTIRE_CONTROL, aCtrlRegion, CTRL_STATE_ENABLED, aMenubarValue, rtl::OUString() );
5914         ImplAddNWFSeparator( this, aMenubarValue );
5915     }
5916     SetFillColor( GetSettings().GetStyleSettings().GetMenuColor() );
5917     pMenu->ImplPaint( this, 0 );
5918     if ( nHighlightedItem != ITEMPOS_INVALID )
5919         HighlightItem( nHighlightedItem, sal_True );
5920 
5921 	// in high contrast mode draw a separating line on the lower edge
5922 	if( ! IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL) &&
5923 		GetSettings().GetStyleSettings().GetHighContrastMode() )
5924     {
5925 		Push( PUSH_LINECOLOR | PUSH_MAPMODE );
5926 		SetLineColor( Color( COL_WHITE ) );
5927 		SetMapMode( MapMode( MAP_PIXEL ) );
5928 		Size aSize = GetSizePixel();
5929 		DrawLine( Point( 0, aSize.Height()-1 ), Point( aSize.Width()-1, aSize.Height()-1 ) );
5930 		Pop();
5931     }
5932 
5933 }
5934 
Resize()5935 void MenuBarWindow::Resize()
5936 {
5937     Size aOutSz = GetOutputSizePixel();
5938     long n      = aOutSz.Height()-4;
5939     long nX     = aOutSz.Width()-3;
5940     long nY     = 2;
5941 
5942     if ( aCloser.IsVisible() )
5943     {
5944         aCloser.Hide();
5945         aCloser.SetImages( n );
5946         Size aTbxSize( aCloser.CalcWindowSizePixel() );
5947         nX -= aTbxSize.Width();
5948         long nTbxY = (aOutSz.Height() - aTbxSize.Height())/2;
5949         aCloser.SetPosSizePixel( nX, nTbxY, aTbxSize.Width(), aTbxSize.Height() );
5950         nX -= 3;
5951         aCloser.Show();
5952     }
5953     if ( aFloatBtn.IsVisible() )
5954     {
5955         nX -= n;
5956         aFloatBtn.SetPosSizePixel( nX, nY, n, n );
5957     }
5958     if ( aHideBtn.IsVisible() )
5959     {
5960         nX -= n;
5961         aHideBtn.SetPosSizePixel( nX, nY, n, n );
5962     }
5963 
5964     aFloatBtn.SetSymbol( SYMBOL_FLOAT );
5965     aHideBtn.SetSymbol( SYMBOL_HIDE );
5966     //aCloser.SetSymbol( SYMBOL_CLOSE ); //is a toolbox now
5967 
5968     Invalidate();
5969 }
5970 
ImplFindEntry(const Point & rMousePos) const5971 sal_uInt16 MenuBarWindow::ImplFindEntry( const Point& rMousePos ) const
5972 {
5973     if( pMenu )
5974     {
5975         long nX = 0;
5976         sal_uInt16 nCount = (sal_uInt16)pMenu->pItemList->Count();
5977         for ( sal_uInt16 n = 0; n < nCount; n++ )
5978         {
5979             MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
5980             if ( pMenu->ImplIsVisible( n ) )
5981             {
5982                 nX += pData->aSz.Width();
5983                 if ( nX > rMousePos.X() )
5984                     return (sal_uInt16)n;
5985             }
5986         }
5987     }
5988     return ITEMPOS_INVALID;
5989 }
5990 
RequestHelp(const HelpEvent & rHEvt)5991 void MenuBarWindow::RequestHelp( const HelpEvent& rHEvt )
5992 {
5993     sal_uInt16 nId = nHighlightedItem;
5994     if ( rHEvt.GetMode() & (HELPMODE_CONTEXT | HELPMODE_EXTENDED) )
5995         ChangeHighlightItem( ITEMPOS_INVALID, sal_True );
5996 
5997 	Rectangle aHighlightRect( ImplGetItemRect( nHighlightedItem ) );
5998     if( !ImplHandleHelpEvent( this, pMenu, nId, rHEvt, aHighlightRect ) )
5999         Window::RequestHelp( rHEvt );
6000 }
6001 
StateChanged(StateChangedType nType)6002 void MenuBarWindow::StateChanged( StateChangedType nType )
6003 {
6004     Window::StateChanged( nType );
6005 
6006     if ( ( nType == STATE_CHANGE_CONTROLFOREGROUND ) ||
6007          ( nType == STATE_CHANGE_CONTROLBACKGROUND ) )
6008     {
6009         ImplInitMenuWindow( this, sal_False, sal_True );
6010         Invalidate();
6011     }
6012     else if( pMenu )
6013         pMenu->ImplKillLayoutData();
6014 
6015 }
6016 
ImplLayoutChanged()6017 void MenuBarWindow::ImplLayoutChanged()
6018 {
6019     if( pMenu )
6020     {
6021         ImplInitMenuWindow( this, sal_True, sal_True );
6022         // Falls sich der Font geaendert hat.
6023         long nHeight = pMenu->ImplCalcSize( this ).Height();
6024 
6025         // depending on the native implementation or the displayable flag
6026         // the menubar windows is supressed (ie, height=0)
6027         if( !((MenuBar*) pMenu)->IsDisplayable() ||
6028             ( pMenu->ImplGetSalMenu() && pMenu->ImplGetSalMenu()->VisibleMenuBar() ) )
6029             nHeight = 0;
6030 
6031         SetPosSizePixel( 0, 0, 0, nHeight, WINDOW_POSSIZE_HEIGHT );
6032         GetParent()->Resize();
6033         Invalidate();
6034         Resize();
6035         if( pMenu )
6036             pMenu->ImplKillLayoutData();
6037     }
6038 }
6039 
ImplInitStyleSettings()6040 void MenuBarWindow::ImplInitStyleSettings()
6041 {
6042     if( IsNativeControlSupported( CTRL_MENUBAR, PART_MENU_ITEM ) &&
6043         IsNativeControlSupported( CTRL_MENUBAR, PART_ENTIRE_CONTROL ) )
6044     {
6045         Color aHighlightTextColor = ImplGetSVData()->maNWFData.maMenuBarHighlightTextColor;
6046         if( aHighlightTextColor != Color( COL_TRANSPARENT ) )
6047         {
6048             AllSettings aSettings( GetSettings() );
6049             StyleSettings aStyle( aSettings.GetStyleSettings() );
6050             aStyle.SetMenuHighlightTextColor( aHighlightTextColor );
6051             aSettings.SetStyleSettings( aStyle );
6052             OutputDevice::SetSettings( aSettings );
6053         }
6054     }
6055 }
6056 
DataChanged(const DataChangedEvent & rDCEvt)6057 void MenuBarWindow::DataChanged( const DataChangedEvent& rDCEvt )
6058 {
6059     Window::DataChanged( rDCEvt );
6060 
6061     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
6062          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
6063          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
6064           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
6065     {
6066         ImplLayoutChanged();
6067         ImplInitStyleSettings();
6068     }
6069 }
6070 
LoseFocus()6071 void MenuBarWindow::LoseFocus()
6072 {
6073     if ( !HasChildPathFocus( sal_True ) )
6074         ChangeHighlightItem( ITEMPOS_INVALID, sal_False, sal_False );
6075 }
6076 
GetFocus()6077 void MenuBarWindow::GetFocus()
6078 {
6079 	if ( nHighlightedItem == ITEMPOS_INVALID )
6080     {
6081         mbAutoPopup = sal_False;    // do not open menu when activated by focus handling like taskpane cycling
6082 		ChangeHighlightItem( 0, sal_False );
6083     }
6084 }
6085 
CreateAccessible()6086 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > MenuBarWindow::CreateAccessible()
6087 {
6088 	::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc;
6089 
6090 	if ( pMenu )
6091 		xAcc = pMenu->GetAccessible();
6092 
6093 	return xAcc;
6094 }
6095 
AddMenuBarButton(const Image & i_rImage,const Link & i_rLink,const String & i_rToolTip,sal_uInt16 i_nPos)6096 sal_uInt16 MenuBarWindow::AddMenuBarButton( const Image& i_rImage, const Link& i_rLink, const String& i_rToolTip, sal_uInt16 i_nPos )
6097 {
6098     // find first free button id
6099     sal_uInt16 nId = IID_DOCUMENTCLOSE;
6100     std::map< sal_uInt16, AddButtonEntry >::const_iterator it;
6101     if( i_nPos > m_aAddButtons.size() )
6102         i_nPos = static_cast<sal_uInt16>(m_aAddButtons.size());
6103     do
6104     {
6105         nId++;
6106         it = m_aAddButtons.find( nId );
6107     } while( it != m_aAddButtons.end() && nId < 128 );
6108     DBG_ASSERT( nId < 128, "too many addbuttons in menubar" );
6109     AddButtonEntry& rNewEntry = m_aAddButtons[nId];
6110     rNewEntry.m_nId = nId;
6111     rNewEntry.m_aSelectLink = i_rLink;
6112     aCloser.InsertItem( nId, i_rImage, 0, 0 );
6113     aCloser.calcMinSize();
6114     ShowButtons( aCloser.IsItemVisible( IID_DOCUMENTCLOSE ),
6115                  aFloatBtn.IsVisible(),
6116                  aHideBtn.IsVisible() );
6117     ImplLayoutChanged();
6118 
6119     if( pMenu->mpSalMenu )
6120         pMenu->mpSalMenu->AddMenuBarButton( SalMenuButtonItem( nId, i_rImage, i_rToolTip ) );
6121 
6122     return nId;
6123 }
6124 
SetMenuBarButtonHighlightHdl(sal_uInt16 nId,const Link & rLink)6125 void MenuBarWindow::SetMenuBarButtonHighlightHdl( sal_uInt16 nId, const Link& rLink )
6126 {
6127     std::map< sal_uInt16, AddButtonEntry >::iterator it = m_aAddButtons.find( nId );
6128     if( it != m_aAddButtons.end() )
6129         it->second.m_aHighlightLink = rLink;
6130 }
6131 
GetMenuBarButtonRectPixel(sal_uInt16 nId)6132 Rectangle MenuBarWindow::GetMenuBarButtonRectPixel( sal_uInt16 nId )
6133 {
6134     Rectangle aRect;
6135     if( m_aAddButtons.find( nId ) != m_aAddButtons.end() )
6136     {
6137         if( pMenu->mpSalMenu )
6138         {
6139             aRect = pMenu->mpSalMenu->GetMenuBarButtonRectPixel( nId, ImplGetWindowImpl()->mpFrame );
6140             if( aRect == Rectangle( Point( -1, -1 ), Size( 1, 1 ) ) )
6141             {
6142                 // system menu button is somehwere but location cannot be determined
6143                 return Rectangle();
6144             }
6145         }
6146 
6147         if( aRect.IsEmpty() )
6148         {
6149             aRect = aCloser.GetItemRect( nId );
6150             Point aOffset = aCloser.OutputToScreenPixel( Point() );
6151             aRect.Move( aOffset.X(), aOffset.Y() );
6152         }
6153     }
6154     return aRect;
6155 }
6156 
RemoveMenuBarButton(sal_uInt16 nId)6157 void MenuBarWindow::RemoveMenuBarButton( sal_uInt16 nId )
6158 {
6159 	sal_uInt16 nPos = aCloser.GetItemPos( nId );
6160     aCloser.RemoveItem( nPos );
6161     m_aAddButtons.erase( nId );
6162     aCloser.calcMinSize();
6163     ImplLayoutChanged();
6164 
6165     if( pMenu->mpSalMenu )
6166         pMenu->mpSalMenu->RemoveMenuBarButton( nId );
6167 }
6168 
HandleMenuButtonEvent(sal_uInt16 i_nButtonId)6169 bool MenuBarWindow::HandleMenuButtonEvent( sal_uInt16 i_nButtonId )
6170 {
6171     std::map< sal_uInt16, AddButtonEntry >::iterator it = m_aAddButtons.find( i_nButtonId );
6172     if( it != m_aAddButtons.end() )
6173     {
6174         MenuBar::MenuBarButtonCallbackArg aArg;
6175         aArg.nId = it->first;
6176         aArg.bHighlight = true;
6177         aArg.pMenuBar = dynamic_cast<MenuBar*>(pMenu);
6178         return it->second.m_aSelectLink.Call( &aArg );
6179     }
6180     return sal_False;
6181 }
6182 
ImplMenuDelData(const Menu * pMenu)6183 ImplMenuDelData::ImplMenuDelData( const Menu* pMenu )
6184 : mpNext( 0 )
6185 , mpMenu( 0 )
6186 {
6187 	if( pMenu )
6188 		const_cast< Menu* >( pMenu )->ImplAddDel( *this );
6189 }
6190 
~ImplMenuDelData()6191 ImplMenuDelData::~ImplMenuDelData()
6192 {
6193 	if( mpMenu )
6194 		const_cast< Menu* >( mpMenu )->ImplRemoveDel( *this );
6195 }
6196