svtools/source/control/stdmenu.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: stdmenu.cxx,v $
  10  * $Revision: 1.11 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include <string.h>
  35
  36 #ifndef _APP_HXX
  37 #include <vcl/svapp.hxx>
  38 #endif
  39
  40 #include <vcl/i18nhelp.hxx>
  41
  42 #include <ctrltool.hxx>
  43 #include <stdmenu.hxx>
  44
  45 // ========================================================================
  46
  47 FontNameMenu::FontNameMenu()
  48 {
  49     SetMenuFlags( GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
  50 }
  51
  52 // -----------------------------------------------------------------------
  53
  54 FontNameMenu::~FontNameMenu()
  55 {
  56 }
  57
  58 // -----------------------------------------------------------------------
  59
  60 void FontNameMenu::Select()
  61 {
  62     maCurName = GetItemText( GetCurItemId() );
  63     maSelectHdl.Call( this );
  64 }
  65
  66 // -----------------------------------------------------------------------
  67
  68 void FontNameMenu::Highlight()
  69 {
  70     XubString aTempName = maCurName;
  71     maCurName = GetItemText( GetCurItemId() );
  72     maHighlightHdl.Call( this );
  73     maCurName = aTempName;
  74 }
  75
  76 // -----------------------------------------------------------------------
  77
  78 void FontNameMenu::Fill( const FontList* pList )
  79 {
  80     // clear menu
  81     Clear();
  82
  83     // add fonts
  84     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
  85     // more than 100 fonts reduces the speed of opening the menu.
  86     // So only the first 100 fonts will be displayed.
  87     USHORT nFontCount = ::std::min( pList->GetFontNameCount(), static_cast< USHORT >(100) );
  88     for ( USHORT i = 0; i < nFontCount; i++ )
  89     {
  90         const XubString& rName = pList->GetFontName( i ).GetName();
  91
  92         // sort with the I18nHelper
  93         USHORT j = GetItemCount();
  94         while ( j )
  95         {
  96             XubString aText = GetItemText( GetItemId( j-1 ) );
  97             if ( rI18nHelper.CompareString( rName, aText ) > 0 )
  98                 break;
  99             j--;
 100         }
 101         InsertItem( i+1, rName, MIB_RADIOCHECK | MIB_AUTOCHECK, j );
 102     }
 103
 104     SetCurName( maCurName );
 105 }
 106
 107 // -----------------------------------------------------------------------
 108
 109 void FontNameMenu::SetCurName( const XubString& rName )
 110 {
 111     maCurName = rName;
 112
 113     // Menueintrag checken
 114     USHORT nChecked = 0;
 115     USHORT nItemCount = GetItemCount();
 116     for( USHORT i = 0; i < nItemCount; i++ )
 117     {
 118         USHORT nItemId = GetItemId( i );
 119
 120         if ( IsItemChecked( nItemId ) )
 121             nChecked = nItemId;
 122
 123         XubString aText = GetItemText( nItemId );
 124         if ( aText == maCurName )
 125         {
 126             CheckItem( nItemId, TRUE );
 127             return;
 128         }
 129     }
 130
 131     if ( nChecked )
 132         CheckItem( nChecked, FALSE );
 133 }
 134
 135 // ========================================================================
 136
 137 FontStyleMenu::FontStyleMenu()
 138 {
 139     SetMenuFlags( GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
 140 }
 141
 142 // -----------------------------------------------------------------------
 143
 144 FontStyleMenu::~FontStyleMenu()
 145 {
 146 }
 147
 148 // -----------------------------------------------------------------------
 149
 150 void FontStyleMenu::Select()
 151 {
 152     USHORT nCurId = GetCurItemId();
 153
 154     if ( (nCurId >= FONTSTYLEMENU_FIRSTID) && (nCurId <= FONTSTYLEMENU_LASTID) )
 155     {
 156         maCurStyle = GetItemText( nCurId );
 157         maSelectHdl.Call( this );
 158     }
 159     else
 160         PopupMenu::Select();
 161 }
 162
 163 // -----------------------------------------------------------------------
 164
 165 void FontStyleMenu::Highlight()
 166 {
 167     USHORT nCurId = GetCurItemId();
 168
 169     if ( (nCurId >= FONTSTYLEMENU_FIRSTID) && (nCurId <= FONTSTYLEMENU_LASTID) )
 170     {
 171         XubString aTempName = maCurStyle;
 172         maCurStyle = GetItemText( nCurId );
 173         maHighlightHdl.Call( this );
 174         maCurStyle = aTempName;
 175     }
 176     else
 177         PopupMenu::Highlight();
 178 }
 179
 180 // -----------------------------------------------------------------------
 181
 182 BOOL FontStyleMenu::ImplIsAlreadyInserted( const XubString& rStyleName, USHORT nCount )
 183 {
 184     for ( USHORT i = 0; i < nCount; i++ )
 185     {
 186         if ( GetItemText( i+FONTSTYLEMENU_FIRSTID ) == rStyleName )
 187             return TRUE;
 188     }
 189
 190     return FALSE;
 191 }
 192
 193 // -----------------------------------------------------------------------
 194
 195 void FontStyleMenu::Fill( const XubString& rName, const FontList* pList )
 196 {
 197     USHORT nItemId = GetItemId( 0 );
 198     while ( (nItemId >= FONTSTYLEMENU_FIRSTID) &&
 199             (nItemId <= FONTSTYLEMENU_LASTID) )
 200     {
 201         RemoveItem( 0 );
 202         nItemId = GetItemId( 0 );
 203     }
 204
 205     // Existiert ein Font mit diesem Namen
 206     sal_Handle hFontInfo = pList->GetFirstFontInfo( rName );
 207     if ( hFontInfo )
 208     {
 209         XubString       aStyleText;
 210         USHORT          nPos = 0;
 211         USHORT          nId = FONTSTYLEMENU_FIRSTID;
 212         FontWeight      eLastWeight = WEIGHT_DONTKNOW;
 213         FontItalic      eLastItalic = ITALIC_NONE;
 214         FontWidth       eLastWidth = WIDTH_DONTKNOW;
 215         BOOL            bNormal = FALSE;
 216         BOOL            bItalic = FALSE;
 217         BOOL            bBold = FALSE;
 218         BOOL            bBoldItalic = FALSE;
 219         BOOL            bInsert = FALSE;
 220         FontInfo        aInfo;
 221         while ( hFontInfo )
 222         {
 223             aInfo = pList->GetFontInfo( hFontInfo );
 224
 225             FontWeight  eWeight = aInfo.GetWeight();
 226             FontItalic  eItalic = aInfo.GetItalic();
 227             FontWidth   eWidth = aInfo.GetWidthType();
 228             // Only if the attributes are different, we insert the
 229             // Font to avoid double Entries in different languages
 230             if ( (eWeight != eLastWeight) || (eItalic != eLastItalic) ||
 231                  (eWidth != eLastWidth) )
 232             {
 233                 if ( bInsert )
 234                 {
 235                     InsertItem( nId, aStyleText,
 236                                 MIB_RADIOCHECK | MIB_AUTOCHECK, nPos );
 237                     nPos++;
 238                     nId++;
 239                 }
 240
 241                 if ( eWeight <= WEIGHT_NORMAL )
 242                 {
 243                     if ( eItalic != ITALIC_NONE )
 244                         bItalic = TRUE;
 245                     else
 246                         bNormal = TRUE;
 247                 }
 248                 else
 249                 {
 250                     if ( eItalic != ITALIC_NONE )
 251                         bBoldItalic = TRUE;
 252                     else
 253                         bBold = TRUE;
 254                 }
 255
 256                 // For wrong StyleNames we replace this with the correct once
 257                 aStyleText = pList->GetStyleName( aInfo );
 258                 bInsert = !ImplIsAlreadyInserted( aStyleText, nPos );
 259                 if ( !bInsert )
 260                 {
 261                     aStyleText = pList->GetStyleName( eWeight, eItalic );
 262                     bInsert = !ImplIsAlreadyInserted( aStyleText, nPos );
 263                 }
 264
 265                 eLastWeight = eWeight;
 266                 eLastItalic = eItalic;
 267                 eLastWidth = eWidth;
 268             }
 269             else
 270             {
 271                 if ( bInsert )
 272                 {
 273                     // If we have two names for the same attributes
 274                     // we prefer the translated standard names
 275                     const XubString& rAttrStyleText = pList->GetStyleName( eWeight, eItalic );
 276                     if ( rAttrStyleText != aStyleText )
 277                     {
 278                         XubString aTempStyleText = pList->GetStyleName( aInfo );
 279                         if ( rAttrStyleText == aTempStyleText )
 280                             aStyleText = rAttrStyleText;
 281                         bInsert = !ImplIsAlreadyInserted( aStyleText, nPos );
 282                     }
 283                 }
 284             }
 285
 286             if ( !bItalic && (aStyleText == pList->GetItalicStr()) )
 287                 bItalic = TRUE;
 288             else if ( !bBold && (aStyleText == pList->GetBoldStr()) )
 289                 bBold = TRUE;
 290             else if ( !bBoldItalic && (aStyleText == pList->GetBoldItalicStr()) )
 291                 bBoldItalic = TRUE;
 292
 293             hFontInfo = pList->GetNextFontInfo( hFontInfo );
 294         }
 295
 296         if ( bInsert )
 297         {
 298             InsertItem( nId, aStyleText,
 299                         MIB_RADIOCHECK | MIB_AUTOCHECK, nPos );
 300             nPos++;
 301             nId++;
 302         }
 303
 304         // Bestimmte Styles als Nachbildung
 305         if ( bNormal )
 306         {
 307             if ( !bItalic )
 308             {
 309                 InsertItem( nId, pList->GetItalicStr(),
 310                             MIB_RADIOCHECK | MIB_AUTOCHECK, nPos );
 311                 nPos++;
 312                 nId++;
 313             }
 314             if ( !bBold )
 315             {
 316                 InsertItem( nId, pList->GetBoldStr(),
 317                             MIB_RADIOCHECK | MIB_AUTOCHECK, nPos );
 318                 nPos++;
 319                 nId++;
 320             }
 321         }
 322         if ( !bBoldItalic )
 323         {
 324             if ( bNormal || bItalic || bBold )
 325             {
 326                 InsertItem( nId, pList->GetBoldItalicStr(),
 327                             MIB_RADIOCHECK | MIB_AUTOCHECK, nPos );
 328                 nPos++;
 329                 nId++;
 330             }
 331         }
 332     }
 333     else
 334     {
 335         // Wenn Font nicht, dann Standard-Styles einfuegen
 336         InsertItem( FONTSTYLEMENU_FIRSTID,       pList->GetNormalStr(),
 337                     MIB_RADIOCHECK | MIB_AUTOCHECK, 0 );
 338         InsertItem( FONTSTYLEMENU_FIRSTID+1, pList->GetItalicStr(),
 339                     MIB_RADIOCHECK | MIB_AUTOCHECK, 0 );
 340         InsertItem( FONTSTYLEMENU_FIRSTID+2, pList->GetBoldStr(),
 341                     MIB_RADIOCHECK | MIB_AUTOCHECK, 0 );
 342         InsertItem( FONTSTYLEMENU_FIRSTID+3, pList->GetBoldItalicStr(),
 343                     MIB_RADIOCHECK | MIB_AUTOCHECK, 0 );
 344     }
 345
 346     SetCurStyle( maCurStyle );
 347 }
 348
 349 // -----------------------------------------------------------------------
 350
 351 void FontStyleMenu::SetCurStyle( const XubString& rStyle )
 352 {
 353     maCurStyle = rStyle;
 354
 355     // Menueintrag checken
 356     USHORT nChecked = 0;
 357     USHORT nItemCount = GetItemCount();
 358     for( USHORT i = 0; i < nItemCount; i++ )
 359     {
 360         USHORT nItemId = GetItemId( i );
 361
 362         if ( (nItemId < FONTSTYLEMENU_FIRSTID) ||
 363              (nItemId > FONTSTYLEMENU_LASTID) )
 364             break;
 365
 366         if ( IsItemChecked( nItemId ) )
 367             nChecked = nItemId;
 368
 369         XubString aText = GetItemText( nItemId );
 370         if ( aText == maCurStyle )
 371         {
 372             CheckItem( nItemId, TRUE );
 373             return;
 374         }
 375     }
 376
 377     if ( nChecked )
 378         CheckItem( nChecked, FALSE );
 379 }
 380
 381 // ========================================================================
 382
 383 FontSizeMenu::FontSizeMenu()
 384 :    mpHeightAry( NULL )
 385 ,    mnCurHeight( 100 )
 386 {
 387     SetMenuFlags( GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
 388 }
 389
 390 // -----------------------------------------------------------------------
 391
 392 FontSizeMenu::~FontSizeMenu()
 393 {
 394     if ( mpHeightAry )
 395         delete[] mpHeightAry;
 396 }
 397
 398 // -----------------------------------------------------------------------
 399
 400 void FontSizeMenu::Select()
 401 {
 402     const USHORT nCurItemId = GetCurItemId();
 403     mnCurHeight = mpHeightAry[ nCurItemId - 1 ];
 404     maSelectHdl.Call( this );
 405 }
 406
 407 // -----------------------------------------------------------------------
 408
 409 void FontSizeMenu::Highlight()
 410 {
 411     const long nTempHeight = mnCurHeight;
 412     const USHORT nCurItemId = GetCurItemId();
 413     if ( !nCurItemId )
 414         mnCurHeight = 0;
 415     else
 416     {
 417         //sal_Int32 nValue = GetItemText( nCurItemId ).ToInt32();
 418         mnCurHeight = mpHeightAry[ nCurItemId - 1 ];
 419     }
 420     maHighlightHdl.Call( this );
 421     mnCurHeight = nTempHeight;
 422 }
 423
 424 // -----------------------------------------------------------------------
 425
 426 void FontSizeMenu::Fill( const FontInfo& rInfo, const FontList* pList )
 427 {
 428     Clear();
 429
 430     // setup font size array
 431     if ( mpHeightAry )
 432         delete[] mpHeightAry;
 433
 434     const long* pTempAry;
 435     const long* pAry = pList->GetSizeAry( rInfo );
 436     USHORT nSizeCount = 0;
 437     while ( pAry[nSizeCount] )
 438         nSizeCount++;
 439
 440     USHORT nPos = 0;
 441
 442     // first insert font size names (for simplified/traditional chinese)
 443     FontSizeNames aFontSizeNames( Application::GetSettings().GetUILanguage() );
 444     mpHeightAry = new long[nSizeCount+aFontSizeNames.Count()];
 445     if ( !aFontSizeNames.IsEmpty() )
 446     {
 447         if ( pAry == pList->GetStdSizeAry() )
 448         {
 449             // for scalable fonts all font size names
 450             ULONG nCount = aFontSizeNames.Count();
 451             for( ULONG i = 0; i < nCount; i++ )
 452             {
 453                 String  aSizeName = aFontSizeNames.GetIndexName( i );
 454                 long    nSize = aFontSizeNames.GetIndexSize( i );
 455                 mpHeightAry[nPos] = nSize;
 456                 nPos++; // Id is nPos+1
 457                 InsertItem( nPos, aSizeName, MIB_RADIOCHECK | MIB_AUTOCHECK );
 458             }
 459         }
 460         else
 461         {
 462             // for fixed size fonts only selectable font size names
 463             pTempAry = pAry;
 464             while ( *pTempAry )
 465             {
 466                 String aSizeName = aFontSizeNames.Size2Name( *pTempAry );
 467                 if ( aSizeName.Len() )
 468                 {
 469                     mpHeightAry[nPos] = *pTempAry;
 470                     nPos++; // Id is nPos+1
 471                     InsertItem( nPos, aSizeName, MIB_RADIOCHECK | MIB_AUTOCHECK );
 472                 }
 473                 pTempAry++;
 474             }
 475         }
 476     }
 477
 478     // then insert numerical font size values
 479     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
 480     pTempAry = pAry;
 481     while ( *pTempAry )
 482     {
 483         mpHeightAry[nPos] = *pTempAry;
 484         nPos++; // Id is nPos+1
 485         InsertItem( nPos, rI18nHelper.GetNum( *pTempAry, 1, TRUE, FALSE ), MIB_RADIOCHECK | MIB_AUTOCHECK );
 486         pTempAry++;
 487     }
 488
 489     SetCurHeight( mnCurHeight );
 490 }
 491
 492 // -----------------------------------------------------------------------
 493
 494 void FontSizeMenu::SetCurHeight( long nHeight )
 495 {
 496     mnCurHeight = nHeight;
 497
 498     // check menue item
 499     XubString   aHeight = Application::GetSettings().GetUILocaleI18nHelper().GetNum( nHeight, 1, TRUE, FALSE  );
 500     USHORT              nChecked = 0;
 501     USHORT              nItemCount = GetItemCount();
 502     for( USHORT i = 0; i < nItemCount; i++ )
 503     {
 504         USHORT nItemId = GetItemId( i );
 505
 506         if ( mpHeightAry[i] == nHeight )
 507         {
 508             CheckItem( nItemId, TRUE );
 509             return;
 510         }
 511
 512         if ( IsItemChecked( nItemId ) )
 513             nChecked = nItemId;
 514     }
 515
 516     if ( nChecked )
 517         CheckItem( nChecked, FALSE );
 518 }