svx/source/tbxctrls/toolbarmenu.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: toolbarmenu.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svx.hxx"
  34 #include <vcl/menu.hxx>
  35 #include <vcl/decoview.hxx>
  36 #include <vcl/image.hxx>
  37
  38 #include "toolbarmenu.hxx"
  39
  40 const int EXTRAITEMHEIGHT = 4;
  41 const int SEPARATOR_HEIGHT = 8;
  42
  43 class ToolbarMenuEntry
  44 {
  45 public:
  46     int mnEntryId;
  47     MenuItemBits mnBits;
  48     Size maSize;
  49
  50     bool mbHasText;
  51     bool mbHasImage;
  52     bool mbHasControl;
  53     bool mbChecked;
  54     bool mbEnabled;
  55
  56     String maText;
  57     Image maImage;
  58     Control* mpControl;
  59
  60 public:
  61     ToolbarMenuEntry( int nEntryId, const String& rText, MenuItemBits nBits );
  62     ToolbarMenuEntry( int nEntryId, const Image& rImage, MenuItemBits nBits );
  63     ToolbarMenuEntry( int nEntryId, const Image& rImage, const String& rText, MenuItemBits nBits );
  64     ToolbarMenuEntry( int nEntryId, Control* pControl, MenuItemBits nBits );
  65     ToolbarMenuEntry( int nEntryId, const String& rText, Control* pControl, MenuItemBits nBits );
  66     ~ToolbarMenuEntry();
  67
  68     void init( int nEntryId, MenuItemBits nBits );
  69 };
  70
  71 void ToolbarMenuEntry::init( int nEntryId, MenuItemBits nBits )
  72 {
  73     mnEntryId = nEntryId;
  74     mnBits = nBits;
  75
  76     mbHasText = false;
  77     mbHasImage = false;
  78     mbHasControl = false;
  79     mbChecked = false;
  80     mbEnabled = true;
  81
  82     mpControl = NULL;
  83 }
  84
  85 ToolbarMenuEntry::ToolbarMenuEntry( int nEntryId, const String& rText, MenuItemBits nBits )
  86 {
  87     init( nEntryId, nBits );
  88
  89     maText = rText;
  90     mbHasText = true;
  91 }
  92
  93 ToolbarMenuEntry::ToolbarMenuEntry( int nEntryId, const Image& rImage, MenuItemBits nBits )
  94 {
  95     init( nEntryId, nBits );
  96
  97     maImage = rImage;
  98     mbHasImage = true;
  99 }
 100
 101 ToolbarMenuEntry::ToolbarMenuEntry( int nEntryId, const Image& rImage, const String& rText, MenuItemBits nBits )
 102 {
 103     init( nEntryId, nBits );
 104
 105     maText = rText;
 106     mbHasText = true;
 107
 108     maImage = rImage;
 109     mbHasImage = true;
 110 }
 111
 112 ToolbarMenuEntry::ToolbarMenuEntry( int nEntryId, Control* pControl, MenuItemBits nBits )
 113 {
 114     init( nEntryId, nBits );
 115
 116     if( pControl )
 117     {
 118         mpControl = pControl;
 119         mpControl->Show();
 120     }
 121 }
 122
 123 ToolbarMenuEntry::ToolbarMenuEntry( int nEntryId, const String& rText, Control* pControl, MenuItemBits nBits )
 124 {
 125     init( nEntryId, nBits );
 126
 127     maText = rText;
 128     mbHasText = true;
 129
 130     if( pControl )
 131     {
 132         mpControl = pControl;
 133         mpControl->Show();
 134     }
 135 }
 136
 137 ToolbarMenuEntry::~ToolbarMenuEntry()
 138 {
 139     delete mpControl;
 140 }
 141
 142 ToolbarMenu::ToolbarMenu( Window* pParent, WinBits nStyle ) :
 143     Control( pParent, nStyle )
 144 {
 145     mnCheckPos = 0;
 146     mnImagePos = 0;
 147     mnTextPos = 0;
 148
 149     mnHighlightedEntry = -1;
 150     mnSelectedEntry = -1;
 151     initWindow();
 152 }
 153
 154 ToolbarMenu::~ToolbarMenu()
 155 {
 156     // delete all menu entries
 157     const int nEntryCount = maEntryVector.size();
 158     int nEntry;
 159     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 160     {
 161         delete maEntryVector[nEntry];
 162     }
 163 }
 164
 165 int ToolbarMenu::getSelectedEntryId() const
 166 {
 167     ToolbarMenuEntry* pEntry = implGetEntry( mnSelectedEntry );
 168     return pEntry ? pEntry->mnEntryId : -1;
 169 }
 170
 171 int ToolbarMenu::getHighlightedEntryId() const
 172 {
 173     ToolbarMenuEntry* pEntry = implGetEntry( mnHighlightedEntry );
 174     return pEntry ? pEntry->mnEntryId : -1;
 175 }
 176
 177 void ToolbarMenu::checkEntry( int nEntryId, bool bChecked )
 178 {
 179     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 180     if( pEntry && pEntry->mbChecked != bChecked )
 181     {
 182         pEntry->mbChecked = bChecked;
 183         Invalidate();
 184     }
 185 }
 186
 187 bool ToolbarMenu::isEntryChecked( int nEntryId ) const
 188 {
 189     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 190     return pEntry && pEntry->mbChecked;
 191 }
 192
 193 void ToolbarMenu::enableEntry( int nEntryId, bool bEnable )
 194 {
 195     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 196     if( pEntry && pEntry->mbEnabled != bEnable )
 197     {
 198         pEntry->mbEnabled = bEnable;
 199         if( pEntry->mpControl )
 200         {
 201             pEntry->mpControl->Enable( bEnable );
 202
 203             // hack for the valueset to make it paint itself anew
 204             pEntry->mpControl->Resize();
 205         }
 206         Invalidate();
 207     }
 208 }
 209
 210 bool ToolbarMenu::isEntryEnabled( int nEntryId ) const
 211 {
 212     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 213     return pEntry && pEntry->mbEnabled;
 214 }
 215
 216 void ToolbarMenu::setEntryText( int nEntryId, const String& rStr )
 217 {
 218     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 219     if( pEntry && pEntry->maText != rStr )
 220     {
 221         pEntry->maText = rStr;
 222         maSize = implCalcSize();
 223         if( IsVisible() )
 224             Invalidate();
 225     }
 226 }
 227
 228 const String& ToolbarMenu::getEntryText( int nEntryId ) const
 229 {
 230     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 231     if( pEntry )
 232         return pEntry->maText;
 233     else
 234     {
 235         static String aEmptyStr;
 236         return aEmptyStr;
 237     }
 238 }
 239
 240 void ToolbarMenu::setEntryImage( int nEntryId, const Image& rImage )
 241 {
 242     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 243     if( pEntry && pEntry->maImage != rImage )
 244     {
 245         pEntry->maImage = rImage;
 246         maSize = implCalcSize();
 247         if( IsVisible() )
 248             Invalidate();
 249     }
 250 }
 251
 252 const Image& ToolbarMenu::getEntryImage( int nEntryId ) const
 253 {
 254     ToolbarMenuEntry* pEntry = implSearchEntry( nEntryId );
 255     if( pEntry )
 256         return pEntry->maImage;
 257     else
 258     {
 259         static Image aEmptyImage;
 260         return aEmptyImage;
 261     }
 262 }
 263
 264 void ToolbarMenu::initWindow()
 265 {
 266     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 267
 268     SetPointFont( rStyleSettings.GetMenuFont() );
 269     SetBackground( Wallpaper( rStyleSettings.GetMenuColor() ) );
 270     SetTextColor( rStyleSettings.GetMenuTextColor() );
 271     SetTextFillColor();
 272     SetLineColor();
 273
 274     maSize = implCalcSize();
 275 }
 276
 277 Size ToolbarMenu::implCalcSize()
 278 {
 279     const long nFontHeight = GetTextHeight();
 280     long nExtra = nFontHeight/4;
 281
 282     Size aSz;
 283     Size aMaxImgSz;
 284     long nMaxTextWidth = 0;
 285     long nMinMenuItemHeight = nFontHeight;
 286     sal_Bool bCheckable = sal_False;
 287
 288     const int nEntryCount = maEntryVector.size();
 289     int nEntry;
 290
 291     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
 292     if ( rSettings.GetUseImagesInMenus() )
 293     {
 294         nMinMenuItemHeight = 16;
 295
 296         for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 297         {
 298             ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 299             if( pEntry && pEntry->mbHasImage )
 300             {
 301                 Size aImgSz = pEntry->maImage.GetSizePixel();
 302                 if ( aImgSz.Height() > aMaxImgSz.Height() )
 303                     aMaxImgSz.Height() = aImgSz.Height();
 304                 if ( aImgSz.Height() > nMinMenuItemHeight )
 305                     nMinMenuItemHeight = aImgSz.Height();
 306                 break;
 307             }
 308         }
 309     }
 310
 311     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 312     {
 313         ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 314
 315         if( pEntry )
 316         {
 317             pEntry->maSize.Height() = 0;
 318             pEntry->maSize.Width() = 0;
 319
 320
 321             if ( ( pEntry->mnBits ) & ( MIB_RADIOCHECK | MIB_CHECKABLE ) )
 322                 bCheckable = sal_True;
 323
 324             // Image:
 325             if( pEntry->mbHasImage )
 326             {
 327                 Size aImgSz = pEntry->maImage.GetSizePixel();
 328                 if ( (aImgSz.Width() + 4) > aMaxImgSz.Width() )
 329                     aMaxImgSz.Width() = aImgSz.Width() + 4;
 330                 if ( (aImgSz.Height() + 4) > aMaxImgSz.Height() )
 331                     aMaxImgSz.Height() = aImgSz.Height() + 4;
 332                 if ( (aImgSz.Height() + 4) > pEntry->maSize.Height() )
 333                     pEntry->maSize.Height() = aImgSz.Height() + 4;
 334             }
 335         }
 336     }
 337
 338     int gfxExtra = Max( nExtra, 7L );
 339
 340     mnCheckPos = nExtra;
 341 //      mnImagePos = mnCheckPos + nFontHeight/2 + gfxExtra;
 342     mnImagePos = nExtra;
 343     mnTextPos = mnImagePos + aMaxImgSz.Width();
 344
 345     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 346     {
 347         ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 348
 349         if( pEntry )
 350         {
 351             // Text:
 352             if( pEntry->mbHasText )
 353             {
 354                 long nTextWidth = GetCtrlTextWidth( pEntry->maText );
 355                 if ( nTextWidth > nMaxTextWidth )
 356                     nMaxTextWidth = nTextWidth;
 357                 long nTextHeight = GetTextHeight();
 358
 359                 pEntry->maSize.Height() = Max( Max( nTextHeight, pEntry->maSize.Height() ), nMinMenuItemHeight );
 360             }
 361
 362             // Control:
 363             if( pEntry->mpControl )
 364             {
 365                 long nTextWidth = pEntry->mbHasText ? GetCtrlTextWidth( pEntry->maText ) : -mnTextPos;
 366
 367                 Size aControlSize( pEntry->mpControl->GetOutputSizePixel() );
 368
 369                 if( nTextWidth )
 370                     nTextWidth += nExtra;
 371
 372                 nTextWidth += aControlSize.Width();
 373
 374                 if ( nTextWidth > nMaxTextWidth )
 375                     nMaxTextWidth = nTextWidth;
 376
 377                 if ( aControlSize.Height() > pEntry->maSize.Height() )
 378                     pEntry->maSize.Height() = aControlSize.Height();
 379             }
 380
 381             pEntry->maSize.Height() += EXTRAITEMHEIGHT;
 382
 383             aSz.Height() += pEntry->maSize.Height();
 384         }
 385         else
 386         {
 387             aSz.Height() += SEPARATOR_HEIGHT;
 388         }
 389     }
 390
 391     if ( aMaxImgSz.Width() )
 392         mnTextPos += gfxExtra;
 393     if ( bCheckable     )
 394         mnTextPos += 16;
 395
 396
 397     aSz.Width() = mnTextPos + nMaxTextWidth;
 398     aSz.Width() += 2*nExtra;
 399
 400     // positionate controls
 401     int nY = 0;
 402     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 403     {
 404         ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 405
 406         if( pEntry )
 407         {
 408             if( pEntry->mpControl )
 409             {
 410                 Size aControlSize( pEntry->mpControl->GetOutputSizePixel() );
 411                 Point aControlPos( pEntry->mbHasText ? mnTextPos : ( aSz.Width() - aControlSize.Width() ) / 2, nY);
 412                 if( pEntry->mbHasText )
 413                     aControlPos.X() += GetCtrlTextWidth( pEntry->maText ) + 4*gfxExtra;
 414
 415                 pEntry->mpControl->SetPosPixel( aControlPos );
 416             }
 417
 418             nY += pEntry->maSize.Height();
 419         }
 420         else
 421         {
 422             nY += SEPARATOR_HEIGHT;
 423         }
 424     }
 425
 426     return aSz;
 427 }
 428
 429 void ToolbarMenu::GetFocus()
 430 {
 431 /*
 432     if( mnHighlightedEntry == -1 )
 433     {
 434         implChangeHighlightEntry( 0 );
 435     }
 436 */
 437     Control::GetFocus();
 438 }
 439
 440 void ToolbarMenu::LoseFocus()
 441 {
 442     if( mnHighlightedEntry != -1 )
 443     {
 444         implChangeHighlightEntry( -1 );
 445     }
 446     Control::LoseFocus();
 447 }
 448
 449 void ToolbarMenu::appendEntry( int nEntryId, const String& rStr, MenuItemBits nItemBits )
 450 {
 451     appendEntry( new ToolbarMenuEntry( nEntryId, rStr, nItemBits ) );
 452 }
 453
 454 void ToolbarMenu::appendEntry( int nEntryId, const Image& rImage, MenuItemBits nItemBits )
 455 {
 456     appendEntry( new ToolbarMenuEntry( nEntryId, rImage, nItemBits ) );
 457 }
 458
 459 void ToolbarMenu::appendEntry( int nEntryId, const String& rStr, const Image& rImage, MenuItemBits nItemBits )
 460 {
 461     appendEntry( new ToolbarMenuEntry( nEntryId, rImage, rStr, nItemBits ) );
 462 }
 463
 464 void ToolbarMenu::appendEntry( int nEntryId, Control* pControl, MenuItemBits nItemBits )
 465 {
 466     appendEntry( new ToolbarMenuEntry( nEntryId, pControl, nItemBits ) );
 467 }
 468
 469 void ToolbarMenu::appendEntry( int nEntryId, const String& rStr, Control* pControl, MenuItemBits nItemBits )
 470 {
 471     appendEntry( new ToolbarMenuEntry( nEntryId, rStr, pControl, nItemBits ) );
 472 }
 473
 474 void ToolbarMenu::appendEntry( ToolbarMenuEntry* pEntry )
 475 {
 476     maEntryVector.push_back( pEntry );
 477     maSize = implCalcSize();
 478     if( IsVisible() )
 479         Invalidate();
 480 }
 481
 482 void ToolbarMenu::appendSeparator()
 483 {
 484     appendEntry( 0 );
 485 }
 486
 487 void ToolbarMenu::Resize()
 488 {
 489     Window::Resize();
 490 }
 491
 492 ToolbarMenuEntry* ToolbarMenu::implGetEntry( int nEntry ) const
 493 {
 494     if( (nEntry < 0) || (nEntry >= (int)maEntryVector.size() ) )
 495         return NULL;
 496
 497     return maEntryVector[nEntry];
 498 }
 499
 500 ToolbarMenuEntry* ToolbarMenu::implSearchEntry( int nEntryId ) const
 501 {
 502     const int nEntryCount = maEntryVector.size();
 503     int nEntry;
 504     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 505     {
 506         ToolbarMenuEntry* p = maEntryVector[nEntry];
 507         if( p && p->mnEntryId == nEntryId )
 508         {
 509             return p;
 510         }
 511     }
 512
 513     return NULL;
 514 }
 515
 516 void ToolbarMenu::implHighlightEntry( int nHighlightEntry, bool bHighlight )
 517 {
 518     Size    aSz = GetOutputSizePixel();
 519     long    nY = 0;
 520     long    nX = 0;
 521
 522     const int nEntryCount = maEntryVector.size();
 523     int nEntry;
 524     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 525     {
 526         ToolbarMenuEntry* p = maEntryVector[nEntry];
 527         if( p )
 528         {
 529             if(nEntry == nHighlightEntry)
 530             {
 531 //                              bool bRestoreLineColor = false;
 532                 Color oldLineColor;
 533 /*
 534                 if( bHighlight && ((p->mpControl == NULL) || (p->mbHasText)) )
 535                 {
 536                     if( p->mbEnabled )
 537                     {
 538                         SetFillColor( GetSettings().GetStyleSettings().GetMenuHighlightColor() );
 539                     }
 540                     else
 541                     {
 542                         SetFillColor();
 543                         oldLineColor = GetLineColor();
 544                         SetLineColor( GetSettings().GetStyleSettings().GetMenuHighlightColor() );
 545                         bRestoreLineColor = true;
 546                     }
 547                 }
 548                 else
 549 */
 550                     SetFillColor( GetSettings().GetStyleSettings().GetMenuColor() );
 551
 552                 Rectangle aRect( Point( nX, nY ), Size( aSz.Width(), p->maSize.Height() ) );
 553                 if( p->mnBits & MIB_POPUPSELECT )
 554                 {
 555                     long nFontHeight = GetTextHeight();
 556                     aRect.Right() -= nFontHeight + nFontHeight/4;
 557                 }
 558                 DrawRect( aRect );
 559                 implPaint( p, bHighlight );
 560
 561                 if( bHighlight && ((p->mpControl == NULL) || (p->mbHasText)) )
 562                 {
 563                     aRect.nLeft += 1;
 564                     aRect.nTop += 1;
 565                     aRect.nBottom -= 1;
 566                     aRect.nRight -= 1;
 567                     DrawSelectionBackground( aRect, true, false, TRUE, TRUE );
 568                 }
 569 /*
 570                 if( bRestoreLineColor )
 571                     SetLineColor( oldLineColor );
 572 */
 573                 maHighlightHdl.Call( this );
 574                 break;
 575             }
 576
 577             nY += p->maSize.Height();
 578         }
 579         else
 580         {
 581             nY += SEPARATOR_HEIGHT;
 582         }
 583     }
 584 }
 585
 586 void ToolbarMenu::implSelectEntry( int nSelectedEntry )
 587 {
 588     mnSelectedEntry = nSelectedEntry;
 589
 590     ToolbarMenuEntry* pEntry = NULL;
 591     if( nSelectedEntry != -1 )
 592         pEntry = maEntryVector[ nSelectedEntry ];
 593
 594     if( pEntry )
 595         maSelectHdl.Call( this );
 596 }
 597
 598 void ToolbarMenu::MouseButtonDown( const MouseEvent& rMEvt )
 599 {
 600     implHighlightEntry( rMEvt, true );
 601
 602     implSelectEntry( mnHighlightedEntry );
 603 }
 604
 605 void ToolbarMenu::MouseButtonUp( const MouseEvent& )
 606 {
 607 }
 608
 609 void ToolbarMenu::MouseMove( const MouseEvent& rMEvt )
 610 {
 611     if ( !IsVisible() )
 612         return;
 613
 614     implHighlightEntry( rMEvt, false );
 615 }
 616
 617 void ToolbarMenu::implHighlightEntry( const MouseEvent& rMEvt, bool bMBDown )
 618 {
 619     long nY = 0;
 620     long nMouseY = rMEvt.GetPosPixel().Y();
 621     Size aOutSz = GetOutputSizePixel();
 622     if ( ( nMouseY >= 0 ) && ( nMouseY < aOutSz.Height() ) )
 623     {
 624         bool bHighlighted = FALSE;
 625
 626         const int nEntryCount = maEntryVector.size();
 627         int nEntry;
 628         for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 629         {
 630             ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 631             if( pEntry )
 632             {
 633                 long nOldY = nY;
 634                 nY += pEntry->maSize.Height();
 635                 if ( ( nOldY <= nMouseY ) && ( nY > nMouseY ) )
 636                 {
 637                     if( bMBDown )
 638                     {
 639                         if( nEntry != mnHighlightedEntry )
 640                         {
 641                             implChangeHighlightEntry( nEntry );
 642                         }
 643                     }
 644                     else
 645                     {
 646                         if ( nEntry != mnHighlightedEntry )
 647                         {
 648                             implChangeHighlightEntry( nEntry );
 649                         }
 650                     }
 651                     bHighlighted = true;
 652                 }
 653             }
 654             else
 655             {
 656                 nY += SEPARATOR_HEIGHT;
 657             }
 658         }
 659         if ( !bHighlighted )
 660             implChangeHighlightEntry( -1 );
 661     }
 662     else
 663     {
 664         implChangeHighlightEntry( -1 );
 665     }
 666 }
 667
 668 void ToolbarMenu::implChangeHighlightEntry( int nEntry )
 669 {
 670     if( mnHighlightedEntry != -1 )
 671     {
 672         implHighlightEntry( mnHighlightedEntry, false );
 673     }
 674
 675     mnHighlightedEntry = nEntry;
 676     if( mnHighlightedEntry != -1 )
 677     {
 678         implHighlightEntry( mnHighlightedEntry, true );
 679     }
 680 }
 681
 682 ToolbarMenuEntry* ToolbarMenu::implCursorUpDown( bool bUp, bool bHomeEnd )
 683 {
 684     int n = mnHighlightedEntry;
 685     if( n == -1 )
 686     {
 687         if( bUp )
 688             n = 0;
 689         else
 690             n = maEntryVector.size()-1;
 691     }
 692
 693     int nLoop = n;
 694
 695     if( bHomeEnd )
 696     {
 697         // absolute positioning
 698         if( bUp )
 699         {
 700             n = maEntryVector.size();
 701             nLoop = n-1;
 702         }
 703         else
 704         {
 705             n = -1;
 706             nLoop = n+1;
 707         }
 708     }
 709
 710     do
 711     {
 712         if( bUp )
 713         {
 714             if ( n )
 715                 n--;
 716             else
 717                 if( mnHighlightedEntry == -1 )
 718                     n = maEntryVector.size()-1;
 719 //                else
 720 //                    break;
 721         }
 722         else
 723         {
 724             if( n < ((int)maEntryVector.size()-1) )
 725                 n++;
 726             else
 727                 if( mnHighlightedEntry == -1 )
 728                     n = 0;
 729 //                else
 730 //                    break;
 731         }
 732
 733         ToolbarMenuEntry* pData = maEntryVector[n];
 734         if( pData )
 735         {
 736             implChangeHighlightEntry( n );
 737             return pData;
 738         }
 739     } while ( n != nLoop );
 740
 741     return 0;
 742 }
 743
 744 void ToolbarMenu::KeyInput( const KeyEvent& rKEvent )
 745 {
 746     USHORT nCode = rKEvent.GetKeyCode().GetCode();
 747     switch ( nCode )
 748     {
 749         case KEY_UP:
 750         case KEY_DOWN:
 751         {
 752             int nOldEntry = mnHighlightedEntry;
 753             ToolbarMenuEntry*p = implCursorUpDown( nCode == KEY_UP, false );
 754             if( p && p->mpControl && !p->mbHasText )
 755             {
 756                 p->mpControl->GrabFocus();
 757                 if( nOldEntry != mnHighlightedEntry )
 758                 {
 759                     KeyCode aKeyCode( (nCode == KEY_UP) ? KEY_END : KEY_HOME );
 760                     KeyEvent aKeyEvent( 0, aKeyCode );
 761                     p->mpControl->KeyInput( aKeyEvent );
 762                 }
 763             }
 764         }
 765         break;
 766         case KEY_END:
 767         case KEY_HOME:
 768         {
 769             ToolbarMenuEntry* p = implCursorUpDown( nCode == KEY_END, true );
 770             if( p && p->mpControl && !p->mbHasText )
 771             {
 772                 p->mpControl->GrabFocus();
 773                 KeyCode aKeyCode( KEY_HOME );
 774                 KeyEvent aKeyEvent( 0, aKeyCode );
 775                 p->mpControl->KeyInput( aKeyEvent );
 776             }
 777         }
 778         break;
 779         case KEY_F6:
 780         case KEY_ESCAPE:
 781         {
 782             // Ctrl-F6 acts like ESC here, the menu bar however will then put the focus in the document
 783             if( nCode == KEY_F6 && !rKEvent.GetKeyCode().IsMod1() )
 784                 break;
 785
 786             implSelectEntry( -1 );
 787 /*
 788             if ( !pMenu->pStartedFrom )
 789             {
 790                 StopExecute();
 791                 KillActivePopup();
 792             }
 793             else if ( pMenu->pStartedFrom->bIsMenuBar )
 794             {
 795                 // Forward...
 796                 ((MenuBarWindow*)((MenuBar*)pMenu->pStartedFrom)->ImplGetWindow())->KeyInput( rKEvent );
 797             }
 798             else
 799             {
 800                 StopExecute();
 801                 ToolbarMenu* pFloat = ((PopupMenu*)pMenu->pStartedFrom)->ImplGetFloatingWindow();
 802                 pFloat->GrabFocus();
 803                 pFloat->KillActivePopup();
 804             }
 805 */
 806         }
 807         break;
 808
 809         case KEY_RETURN:
 810         {
 811             ToolbarMenuEntry* pEntry = implGetEntry( mnHighlightedEntry );
 812             if ( pEntry && pEntry->mbEnabled )
 813             {
 814                 if( pEntry->mpControl )
 815                 {
 816                     pEntry->mpControl->GrabFocus();
 817                 }
 818                 else
 819                 {
 820                     implSelectEntry( mnHighlightedEntry );
 821                 }
 822             }
 823   //          else
 824   //              StopExecute();
 825         }
 826         break;
 827         default:
 828         {
 829 /*
 830             xub_Unicode nCharCode = rKEvent.GetCharCode();
 831             USHORT nPos;
 832             USHORT nDuplicates = 0;
 833             MenuItemData* pData = nCharCode ? pMenu->GetItemList()->SearchItem( nCharCode, nPos, nDuplicates, nHighlightedItem ) : NULL;
 834             if ( pData )
 835             {
 836                 if ( pData->pSubMenu || nDuplicates > 1 )
 837                 {
 838                     implChangeHighlightEntry( nPos );
 839                     HighlightChanged( 0 );
 840                 }
 841                 else
 842                 {
 843                     nHighlightedItem = nPos;
 844                     EndExecute();
 845                 }
 846             }
 847             else
 848             {
 849                 // Bei ungueltigen Tasten Beepen, aber nicht bei HELP und F-Tasten
 850                 if ( !rKEvent.GetKeyCode().IsControlMod() && ( nCode != KEY_HELP ) && ( rKEvent.GetKeyCode().GetGroup() != KEYGROUP_FKEYS ) )
 851                     Sound::Beep();
 852                 FloatingWindow::KeyInput( rKEvent );
 853             }
 854     */
 855         }
 856     }
 857 }
 858
 859 void ToolbarMenu::implPaint( ToolbarMenuEntry* pThisOnly, bool bHighlighted )
 860 {
 861     const long nFontHeight = GetTextHeight();
 862     const long nExtra = nFontHeight/4;
 863
 864     DecorationView aDecoView( this );
 865     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
 866
 867     const Size aOutSz( GetOutputSizePixel() );
 868 //    const long nMaxY = aOutSz.Height();
 869
 870     Point aTopLeft, aTmpPos;
 871
 872     const int nEntryCount = maEntryVector.size();
 873     int nEntry;
 874     for( nEntry = 0; nEntry < nEntryCount; nEntry++ )
 875     {
 876         ToolbarMenuEntry* pEntry = maEntryVector[nEntry];
 877         Point aPos( aTopLeft );
 878
 879         USHORT  nTextStyle   = 0;
 880         USHORT  nSymbolStyle = 0;
 881         USHORT  nImageStyle  = 0;
 882         if( pEntry && !pEntry->mbEnabled )
 883         {
 884             nTextStyle   |= TEXT_DRAW_DISABLE;
 885             nSymbolStyle |= SYMBOL_DRAW_DISABLE;
 886             nImageStyle  |= IMAGE_DRAW_DISABLE;
 887         }
 888
 889         // Separator
 890         if( pEntry == NULL )
 891         {
 892             if( pThisOnly == NULL  )
 893             {
 894                 aTmpPos.Y() = aPos.Y() + ((SEPARATOR_HEIGHT-2)/2);
 895                 aTmpPos.X() = aPos.X() + 2;
 896
 897                 SetLineColor( rSettings.GetShadowColor() );
 898                 DrawLine( aTmpPos, Point( aOutSz.Width() - 3, aTmpPos.Y() ) );
 899                 aTmpPos.Y()++;
 900                 SetLineColor( rSettings.GetLightColor() );
 901                 DrawLine( aTmpPos, Point( aOutSz.Width() - 3, aTmpPos.Y() ) );
 902                 SetLineColor();
 903             }
 904
 905             aTopLeft.Y() += SEPARATOR_HEIGHT;
 906         }
 907         else
 908         {
 909             if( !pThisOnly || ( pEntry == pThisOnly ) )
 910             {
 911                 if( pThisOnly && bHighlighted )
 912                     SetTextColor( rSettings.GetMenuHighlightTextColor() );
 913
 914                 long nTextOffsetY = ((pEntry->maSize.Height()-nFontHeight)/2);
 915
 916                 // Image
 917                 if( pEntry->mbHasImage )
 918                 {
 919                     aTmpPos.X() = aPos.X() + mnImagePos;
 920                     aTmpPos.Y() = aPos.Y();
 921                     aTmpPos.Y() += (pEntry->maSize.Height()-pEntry->maImage.GetSizePixel().Height())/2;
 922                     DrawImage( aTmpPos, pEntry->maImage, nImageStyle );
 923                 }
 924                 // Text:
 925                 if( pEntry->mbHasText )
 926                 {
 927                     aTmpPos.X() = aPos.X() + mnTextPos;
 928                     aTmpPos.Y() = aPos.Y();
 929                     aTmpPos.Y() += nTextOffsetY;
 930                     USHORT nStyle = nTextStyle|TEXT_DRAW_MNEMONIC;
 931
 932                     DrawCtrlText( aTmpPos, pEntry->maText, 0, pEntry->maText.Len(), nStyle );
 933                 }
 934                 // CheckMark
 935                 if( pEntry->mbChecked )
 936                 {
 937                     if( pEntry->mbHasImage )
 938                     {
 939                         aTmpPos.X() = aPos.X() + mnImagePos;
 940                         aTmpPos.Y() = aPos.Y();
 941                         aTmpPos.Y() += (pEntry->maSize.Height()-pEntry->maImage.GetSizePixel().Height())/2;
 942
 943                         Rectangle aRect( aTmpPos, pEntry->maImage.GetSizePixel() );
 944                         aRect.nLeft -= 2;
 945                         aRect.nTop -= 2;
 946                         aRect.nRight += 2;
 947                         aRect.nBottom += 2;
 948                         DrawSelectionBackground( aRect, false, true, TRUE, TRUE );
 949                     }
 950                     else
 951                     {
 952                         Rectangle aRect;
 953                         SymbolType eSymbol;
 954                         aTmpPos.Y() = aPos.Y();
 955                         aTmpPos.Y() += nExtra/2;
 956                         aTmpPos.Y() += pEntry->maSize.Height() / 2;
 957                         if ( pEntry->mnBits & MIB_RADIOCHECK )
 958                         {
 959                             aTmpPos.X() = aPos.X() + mnCheckPos;
 960                             eSymbol = SYMBOL_RADIOCHECKMARK;
 961                             aTmpPos.Y() -= nFontHeight/4;
 962                             aRect = Rectangle( aTmpPos, Size( nFontHeight/2, nFontHeight/2 ) );
 963                         }
 964                         else
 965                         {
 966                             aTmpPos.X() = aPos.X() + mnCheckPos;
 967                             eSymbol = SYMBOL_CHECKMARK;
 968                             aTmpPos.Y() -= nFontHeight/4;
 969                             aRect = Rectangle( aTmpPos, Size( (nFontHeight*25)/40, nFontHeight/2 ) );
 970                         }
 971                         aDecoView.DrawSymbol( aRect, eSymbol, GetTextColor(), nSymbolStyle );
 972                     }
 973                 }
 974
 975                 if( pThisOnly && bHighlighted )
 976                     SetTextColor( rSettings.GetMenuTextColor() );
 977             }
 978
 979             aTopLeft.Y() += pEntry->maSize.Height();
 980         }
 981     }
 982 }
 983
 984 void ToolbarMenu::Paint( const Rectangle& )
 985 {
 986     implPaint();
 987
 988     if( mnHighlightedEntry != -1 )
 989         implHighlightEntry( mnHighlightedEntry, true );
 990 }
 991
 992 void ToolbarMenu::RequestHelp( const HelpEvent& rHEvt )
 993 {
 994     Window::RequestHelp( rHEvt );
 995 }
 996
 997 void ToolbarMenu::StateChanged( StateChangedType nType )
 998 {
 999     Control::StateChanged( nType );
1000
1001     if ( ( nType == STATE_CHANGE_CONTROLFOREGROUND ) || ( nType == STATE_CHANGE_CONTROLBACKGROUND ) )
1002     {
1003         initWindow();
1004         Invalidate();
1005     }
1006 }
1007
1008 void ToolbarMenu::DataChanged( const DataChangedEvent& rDCEvt )
1009 {
1010     Control::DataChanged( rDCEvt );
1011
1012     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1013          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1014          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1015           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1016     {
1017         initWindow();
1018         Invalidate();
1019     }
1020 }
1021
1022 void ToolbarMenu::Command( const CommandEvent& rCEvt )
1023 {
1024     if ( rCEvt.GetCommand() == COMMAND_WHEEL )
1025     {
1026         const CommandWheelData* pData = rCEvt.GetWheelData();
1027         if( !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) )
1028         {
1029             implCursorUpDown( pData->GetDelta() > 0L, false );
1030         }
1031     }
1032 }