1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_cui.hxx" 30 31 #include <stdlib.h> 32 #include <time.h> 33 34 #ifndef _HELP_HXX //autogen 35 #include <vcl/help.hxx> 36 #endif 37 #ifndef _MSGBOX_HXX //autogen 38 #include <vcl/msgbox.hxx> 39 #endif 40 #include <vcl/decoview.hxx> 41 #include <vcl/toolbox.hxx> 42 #include <vcl/scrbar.hxx> 43 44 //added for issue73355 45 //#ifndef _SV_SVDATA_HXX 46 //#include <vcl/svdata.hxx> 47 //#endif 48 //issue73355 ends 49 50 #include <sfx2/app.hxx> 51 #include <sfx2/sfxdlg.hxx> 52 #include <sfx2/viewfrm.hxx> 53 #include <sfx2/viewsh.hxx> 54 #include <sfx2/msg.hxx> 55 #include <sfx2/msgpool.hxx> 56 #include <sfx2/mnumgr.hxx> 57 #include <sfx2/minfitem.hxx> 58 #include <sfx2/objsh.hxx> 59 #include <sfx2/request.hxx> 60 #include <sfx2/filedlghelper.hxx> 61 #include <svl/stritem.hxx> 62 #include <svtools/miscopt.hxx> 63 #include <tools/diagnose_ex.h> 64 #include <toolkit/unohlp.hxx> 65 66 #include <algorithm> 67 //add 68 #include <cuires.hrc> 69 #include "cfg.hrc" 70 #include "helpid.hrc" 71 72 #include "acccfg.hxx" 73 #include "cfg.hxx" 74 #include "eventdlg.hxx" 75 #include <dialmgr.hxx> 76 77 #include <comphelper/documentinfo.hxx> 78 #include <comphelper/processfactory.hxx> 79 #ifndef _UNOTOOLS_CONFIGMGR_HXX_ 80 #include <unotools/configmgr.hxx> 81 #endif 82 #include <com/sun/star/ui/ItemType.hpp> 83 #include <com/sun/star/ui/ItemStyle.hpp> 84 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp> 85 #include <com/sun/star/frame/XController.hpp> 86 #include <com/sun/star/frame/XDesktop.hpp> 87 #include <com/sun/star/ui/XUIConfiguration.hpp> 88 #include <com/sun/star/ui/XUIConfigurationListener.hpp> 89 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp> 90 #include <com/sun/star/ui/XUIConfigurationPersistence.hpp> 91 #include <com/sun/star/ui/XUIConfigurationStorage.hpp> 92 #include <com/sun/star/ui/XModuleUIConfigurationManager.hpp> 93 #include <com/sun/star/ui/XUIElement.hpp> 94 #ifndef _COM_SUN_STAR_UI_UIElementType_HPP_ 95 #include <com/sun/star/ui/UIElementType.hpp> 96 #endif 97 #include <com/sun/star/ui/ImageType.hpp> 98 #include <com/sun/star/frame/XLayoutManager.hpp> 99 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> 100 #include "com/sun/star/ui/dialogs/TemplateDescription.hpp" 101 #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> 102 #include <com/sun/star/frame/XFramesSupplier.hpp> 103 #include <com/sun/star/frame/XFrames.hpp> 104 #include <com/sun/star/frame/FrameSearchFlag.hpp> 105 #include <com/sun/star/embed/ElementModes.hpp> 106 107 #include "dlgname.hxx" 108 109 #define PRTSTR(x) rtl::OUStringToOString(x, RTL_TEXTENCODING_ASCII_US).pData->buffer 110 111 #define ENTRY_HEIGHT 16 112 113 static const char ITEM_DESCRIPTOR_COMMANDURL[] = "CommandURL"; 114 static const char ITEM_DESCRIPTOR_CONTAINER[] = "ItemDescriptorContainer"; 115 static const char ITEM_DESCRIPTOR_LABEL[] = "Label"; 116 static const char ITEM_DESCRIPTOR_TYPE[] = "Type"; 117 static const char ITEM_DESCRIPTOR_STYLE[] = "Style"; 118 static const char ITEM_DESCRIPTOR_ISVISIBLE[] = "IsVisible"; 119 static const char ITEM_DESCRIPTOR_RESOURCEURL[] = "ResourceURL"; 120 static const char ITEM_DESCRIPTOR_UINAME[] = "UIName"; 121 122 static const char ITEM_MENUBAR_URL[] = "private:resource/menubar/menubar"; 123 static const char ITEM_TOOLBAR_URL[] = "private:resource/toolbar/"; 124 125 static const char CUSTOM_TOOLBAR_STR[] = "custom_toolbar_"; 126 static const char CUSTOM_MENU_STR[] = "vnd.openoffice.org:CustomMenu"; 127 128 static const char __FAR_DATA pSeparatorStr[] = 129 "----------------------------------"; 130 static const char __FAR_DATA pMenuSeparatorStr[] = " | "; 131 132 #ifdef _MSC_VER 133 #pragma warning (disable:4355) 134 #endif 135 136 using rtl::OUString; 137 namespace css = com::sun::star; 138 namespace uno = com::sun::star::uno; 139 namespace frame = com::sun::star::frame; 140 namespace lang = com::sun::star::lang; 141 namespace container = com::sun::star::container; 142 namespace beans = com::sun::star::beans; 143 namespace graphic = com::sun::star::graphic; 144 145 #if OSL_DEBUG_LEVEL > 1 146 147 void printPropertySet( 148 const OUString& prefix, 149 const uno::Reference< beans::XPropertySet >& xPropSet ) 150 { 151 uno::Reference< beans::XPropertySetInfo > xPropSetInfo = 152 xPropSet->getPropertySetInfo(); 153 154 uno::Sequence< beans::Property > aPropDetails = 155 xPropSetInfo->getProperties(); 156 157 OSL_TRACE("printPropertySet: %d properties", aPropDetails.getLength()); 158 159 for ( sal_Int32 i = 0; i < aPropDetails.getLength(); i++ ) 160 { 161 OUString tmp; 162 sal_Int32 ival; 163 164 uno::Any a = xPropSet->getPropertyValue( aPropDetails[i].Name ); 165 166 if ( ( a >>= tmp ) /* && tmp.getLength() != 0 */ ) 167 { 168 OSL_TRACE("%s: Got property: %s = %s", 169 PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(tmp)); 170 } 171 else if ( ( a >>= ival ) ) 172 { 173 OSL_TRACE("%s: Got property: %s = %d", 174 PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(tmp)); 175 } 176 else 177 { 178 OSL_TRACE("%s: Got property: %s of type %s", 179 PRTSTR(prefix), PRTSTR(aPropDetails[i].Name), PRTSTR(a.getValueTypeName())); 180 } 181 } 182 } 183 184 void printProperties( 185 const OUString& prefix, 186 const uno::Sequence< beans::PropertyValue >& aProp ) 187 { 188 for ( sal_Int32 i = 0; i < aProp.getLength(); i++ ) 189 { 190 OUString tmp; 191 192 aProp[i].Value >>= tmp; 193 194 OSL_TRACE("%s: Got property: %s = %s", 195 PRTSTR(prefix), PRTSTR(aProp[i].Name), PRTSTR(tmp)); 196 } 197 } 198 199 void printEntries(SvxEntries* entries) 200 { 201 SvxEntries::const_iterator iter = entries->begin(); 202 203 for ( ; iter != entries->end(); iter++ ) 204 { 205 SvxConfigEntry* entry = *iter; 206 207 OSL_TRACE("printEntries: %s", PRTSTR(entry->GetName())); 208 } 209 } 210 211 #endif 212 213 OUString 214 stripHotKey( const OUString& str ) 215 { 216 sal_Int32 index = str.indexOf( '~' ); 217 if ( index == -1 ) 218 { 219 return str; 220 } 221 else 222 { 223 return str.replaceAt( index, 1, OUString() ); 224 } 225 } 226 227 OUString replaceSaveInName( 228 const OUString& rMessage, 229 const OUString& rSaveInName ) 230 { 231 OUString name; 232 OUString placeholder = OUString::createFromAscii( "%SAVE IN SELECTION%" ); 233 234 sal_Int32 pos = rMessage.indexOf( placeholder ); 235 236 if ( pos != -1 ) 237 { 238 name = rMessage.replaceAt( 239 pos, placeholder.getLength(), rSaveInName ); 240 } 241 else 242 { 243 // don't change the message 244 } 245 246 return name; 247 } 248 249 OUString 250 replaceSixteen( const OUString& str, sal_Int32 nReplacement ) 251 { 252 OUString result( str ); 253 OUString sixteen = OUString::valueOf( (sal_Int32)16 ); 254 OUString expected = OUString::valueOf( nReplacement ); 255 256 sal_Int32 len = sixteen.getLength(); 257 sal_Int32 index = result.indexOf( sixteen ); 258 259 while ( index != -1 ) 260 { 261 result = result.replaceAt( index, len, expected ); 262 index = result.indexOf( sixteen, index ); 263 } 264 265 return result; 266 } 267 268 OUString 269 generateCustomName( 270 const OUString& prefix, 271 SvxEntries* entries, 272 sal_Int32 suffix = 1 ) 273 { 274 // find and replace the %n placeholder in the prefix string 275 OUString name; 276 OUString placeholder = OUString::createFromAscii( "%n" ); 277 278 sal_Int32 pos = prefix.indexOf( 279 OUString::createFromAscii( "%n" ) ); 280 281 if ( pos != -1 ) 282 { 283 name = prefix.replaceAt( 284 pos, placeholder.getLength(), OUString::valueOf( suffix ) ); 285 } 286 else 287 { 288 // no placeholder found so just append the suffix 289 name = prefix + OUString::valueOf( suffix ); 290 } 291 292 // now check is there is an already existing entry with this name 293 SvxEntries::const_iterator iter = entries->begin(); 294 295 SvxConfigEntry* pEntry; 296 while ( iter != entries->end() ) 297 { 298 pEntry = *iter; 299 300 if ( name.equals( pEntry->GetName() ) ) 301 { 302 break; 303 } 304 iter++; 305 } 306 307 if ( iter != entries->end() ) 308 { 309 // name already exists so try the next number up 310 return generateCustomName( prefix, entries, ++suffix ); 311 } 312 313 return name; 314 } 315 316 sal_uInt32 generateRandomValue() 317 { 318 srand( unsigned( time( NULL ) )); 319 return sal_uInt32( rand() ); 320 } 321 322 OUString 323 generateCustomURL( 324 SvxEntries* entries ) 325 { 326 OUString url = OUString::createFromAscii( ITEM_TOOLBAR_URL ); 327 url += OUString::createFromAscii( CUSTOM_TOOLBAR_STR ); 328 329 // use a random number to minimize possible clash with existing custom toolbars 330 url += OUString::valueOf( sal_Int64( generateRandomValue() ), 16 ); 331 332 // now check is there is an already existing entry with this url 333 SvxEntries::const_iterator iter = entries->begin(); 334 335 SvxConfigEntry* pEntry; 336 while ( iter != entries->end() ) 337 { 338 pEntry = *iter; 339 340 if ( url.equals( pEntry->GetCommand() ) ) 341 { 342 break; 343 } 344 iter++; 345 } 346 347 if ( iter != entries->end() ) 348 { 349 // url already exists so try the next number up 350 return generateCustomURL( entries ); 351 } 352 353 return url; 354 } 355 356 OUString 357 generateCustomMenuURL( 358 SvxEntries* entries, 359 sal_Int32 suffix = 1 ) 360 { 361 OUString url = OUString::createFromAscii( CUSTOM_MENU_STR ); 362 url += OUString::valueOf( suffix ); 363 364 // now check is there is an already existing entry with this url 365 SvxEntries::const_iterator iter = entries->begin(); 366 367 SvxConfigEntry* pEntry; 368 while ( iter != entries->end() ) 369 { 370 pEntry = *iter; 371 372 if ( url.equals( pEntry->GetCommand() ) ) 373 { 374 break; 375 } 376 iter++; 377 } 378 379 if ( iter != entries->end() ) 380 { 381 // url already exists so try the next number up 382 return generateCustomMenuURL( entries, ++suffix ); 383 } 384 385 return url; 386 } 387 388 static sal_Int16 theImageType = 389 css::ui::ImageType::COLOR_NORMAL | 390 css::ui::ImageType::SIZE_DEFAULT; 391 392 void InitImageType() 393 { 394 theImageType = 395 css::ui::ImageType::COLOR_NORMAL | 396 css::ui::ImageType::SIZE_DEFAULT; 397 398 if ( SvtMiscOptions().AreCurrentSymbolsLarge() ) 399 { 400 theImageType |= css::ui::ImageType::SIZE_LARGE; 401 } 402 403 Window* topwin = Application::GetActiveTopWindow(); 404 if ( topwin != NULL && 405 topwin->GetSettings().GetStyleSettings().GetHighContrastMode() ) 406 { 407 theImageType |= css::ui::ImageType::COLOR_HIGHCONTRAST; 408 } 409 } 410 411 sal_Int16 GetImageType() 412 { 413 return theImageType; 414 } 415 416 void RemoveEntry( SvxEntries* pEntries, SvxConfigEntry* pChildEntry ) 417 { 418 SvxEntries::iterator iter = pEntries->begin(); 419 420 while ( iter != pEntries->end() ) 421 { 422 if ( pChildEntry == *iter ) 423 { 424 pEntries->erase( iter ); 425 break; 426 } 427 iter++; 428 } 429 } 430 431 bool 432 SvxConfigPage::CanConfig( const OUString& aModuleId ) 433 { 434 OSL_TRACE("SupportsDocumentConfig: %s", PRTSTR(aModuleId)); 435 436 if ( aModuleId.equalsAscii( "com.sun.star.script.BasicIDE" ) 437 || aModuleId.equalsAscii( "com.sun.star.frame.Bibliography" ) 438 ) 439 { 440 return sal_False; 441 } 442 return sal_True; 443 } 444 445 OUString GetModuleName( const OUString& aModuleId ) 446 { 447 if ( aModuleId.equalsAscii( "com.sun.star.text.TextDocument" ) || 448 aModuleId.equalsAscii( "com.sun.star.text.GlobalDocument" ) ) 449 return OUString::createFromAscii("Writer"); 450 else if ( aModuleId.equalsAscii( "com.sun.star.text.WebDocument" ) ) 451 return OUString::createFromAscii("Writer/Web"); 452 else if ( aModuleId.equalsAscii( "com.sun.star.drawing.DrawingDocument" ) ) 453 return OUString::createFromAscii("Draw"); 454 else if ( aModuleId.equalsAscii( "com.sun.star.presentation.PresentationDocument" ) ) 455 return OUString::createFromAscii("Impress"); 456 else if ( aModuleId.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" ) ) 457 return OUString::createFromAscii("Calc"); 458 else if ( aModuleId.equalsAscii( "com.sun.star.script.BasicIDE" ) ) 459 return OUString::createFromAscii("Basic"); 460 else if ( aModuleId.equalsAscii( "com.sun.star.formula.FormulaProperties" ) ) 461 return OUString::createFromAscii("Math"); 462 else if ( aModuleId.equalsAscii( "com.sun.star.sdb.RelationDesign" ) ) 463 return OUString::createFromAscii("Relation Design"); 464 else if ( aModuleId.equalsAscii( "com.sun.star.sdb.QueryDesign" ) ) 465 return OUString::createFromAscii("Query Design"); 466 else if ( aModuleId.equalsAscii( "com.sun.star.sdb.TableDesign" ) ) 467 return OUString::createFromAscii("Table Design"); 468 else if ( aModuleId.equalsAscii( "com.sun.star.sdb.DataSourceBrowser" ) ) 469 return OUString::createFromAscii("Data Source Browser" ); 470 else if ( aModuleId.equalsAscii( "com.sun.star.sdb.DatabaseDocument" ) ) 471 return OUString::createFromAscii("Database" ); 472 473 return ::rtl::OUString(); 474 } 475 476 OUString GetUIModuleName( const OUString& aModuleId, const uno::Reference< css::frame::XModuleManager >& rModuleManager ) 477 { 478 OUString aModuleUIName; 479 480 if ( rModuleManager.is() ) 481 { 482 uno::Reference< css::container::XNameAccess > xNameAccess( rModuleManager, uno::UNO_QUERY ); 483 if ( xNameAccess.is() ) 484 { 485 try 486 { 487 uno::Any a = xNameAccess->getByName( aModuleId ); 488 uno::Sequence< beans::PropertyValue > aSeq; 489 490 if ( a >>= aSeq ) 491 { 492 OUString aUIName; 493 for ( sal_Int32 i = 0; i < aSeq.getLength(); i++ ) 494 { 495 if ( aSeq[i].Name.equalsAscii( "ooSetupFactoryUIName" )) 496 { 497 aSeq[i].Value >>= aModuleUIName; 498 break; 499 } 500 } 501 } 502 } 503 catch ( uno::RuntimeException& e ) 504 { 505 throw e; 506 } 507 catch ( uno::Exception& ) 508 { 509 } 510 } 511 } 512 513 if ( aModuleUIName.getLength() == 0 ) 514 aModuleUIName = GetModuleName( aModuleId ); 515 516 return aModuleUIName; 517 } 518 519 bool GetMenuItemData( 520 const uno::Reference< container::XIndexAccess >& rItemContainer, 521 sal_Int32 nIndex, 522 OUString& rCommandURL, 523 OUString& rLabel, 524 sal_uInt16& rType, 525 uno::Reference< container::XIndexAccess >& rSubMenu ) 526 { 527 try 528 { 529 uno::Sequence< beans::PropertyValue > aProp; 530 if ( rItemContainer->getByIndex( nIndex ) >>= aProp ) 531 { 532 for ( sal_Int32 i = 0; i < aProp.getLength(); i++ ) 533 { 534 if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_COMMANDURL )) 535 { 536 aProp[i].Value >>= rCommandURL; 537 } 538 else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_CONTAINER )) 539 { 540 aProp[i].Value >>= rSubMenu; 541 } 542 else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL )) 543 { 544 aProp[i].Value >>= rLabel; 545 } 546 else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_TYPE )) 547 { 548 aProp[i].Value >>= rType; 549 } 550 } 551 552 return sal_True; 553 } 554 } 555 catch ( ::com::sun::star::lang::IndexOutOfBoundsException& ) 556 { 557 } 558 559 return sal_False; 560 } 561 562 bool GetToolbarItemData( 563 const uno::Reference< container::XIndexAccess >& rItemContainer, 564 sal_Int32 nIndex, 565 OUString& rCommandURL, 566 OUString& rLabel, 567 sal_uInt16& rType, 568 sal_Bool& rIsVisible, 569 sal_Int32& rStyle, 570 uno::Reference< container::XIndexAccess >& rSubMenu ) 571 { 572 try 573 { 574 uno::Sequence< beans::PropertyValue > aProp; 575 if ( rItemContainer->getByIndex( nIndex ) >>= aProp ) 576 { 577 for ( sal_Int32 i = 0; i < aProp.getLength(); i++ ) 578 { 579 if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_COMMANDURL )) 580 { 581 aProp[i].Value >>= rCommandURL; 582 } 583 if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE )) 584 { 585 aProp[i].Value >>= rStyle; 586 } 587 else if (aProp[i].Name.equalsAscii(ITEM_DESCRIPTOR_CONTAINER)) 588 { 589 aProp[i].Value >>= rSubMenu; 590 } 591 else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL )) 592 { 593 aProp[i].Value >>= rLabel; 594 } 595 else if ( aProp[i].Name.equalsAscii( ITEM_DESCRIPTOR_TYPE )) 596 { 597 aProp[i].Value >>= rType; 598 } 599 else if (aProp[i].Name.equalsAscii(ITEM_DESCRIPTOR_ISVISIBLE)) 600 { 601 aProp[i].Value >>= rIsVisible; 602 } 603 } 604 605 return sal_True; 606 } 607 } 608 catch ( ::com::sun::star::lang::IndexOutOfBoundsException& ) 609 { 610 } 611 612 return sal_False; 613 } 614 615 uno::Sequence< beans::PropertyValue > 616 ConvertSvxConfigEntry( 617 const uno::Reference< container::XNameAccess >& xCommandToLabelMap, 618 const SvxConfigEntry* pEntry ) 619 { 620 static const OUString aDescriptorCommandURL ( 621 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_COMMANDURL ) ); 622 623 static const OUString aDescriptorType( 624 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) ); 625 626 static const OUString aDescriptorLabel( 627 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_LABEL ) ); 628 629 static const OUString aDescriptorContainer( 630 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) ); 631 632 uno::Sequence< beans::PropertyValue > aPropSeq( 3 ); 633 634 aPropSeq[0].Name = aDescriptorCommandURL; 635 aPropSeq[0].Value <<= rtl::OUString( pEntry->GetCommand() ); 636 637 aPropSeq[1].Name = aDescriptorType; 638 aPropSeq[1].Value <<= css::ui::ItemType::DEFAULT; 639 640 // If the name has not been changed and the name is the same as 641 // in the default command to label map then the label can be stored 642 // as an empty string. 643 // It will be initialised again later using the command to label map. 644 aPropSeq[2].Name = aDescriptorLabel; 645 if ( pEntry->HasChangedName() == sal_False && pEntry->GetCommand().getLength() ) 646 { 647 sal_Bool isDefaultName = sal_False; 648 try 649 { 650 uno::Any a( xCommandToLabelMap->getByName( pEntry->GetCommand() ) ); 651 uno::Sequence< beans::PropertyValue > tmpPropSeq; 652 if ( a >>= tmpPropSeq ) 653 { 654 for ( sal_Int32 i = 0; i < tmpPropSeq.getLength(); i++ ) 655 { 656 if ( tmpPropSeq[i].Name.equals( aDescriptorLabel ) ) 657 { 658 OUString tmpLabel; 659 tmpPropSeq[i].Value >>= tmpLabel; 660 661 if ( tmpLabel.equals( pEntry->GetName() ) ) 662 { 663 isDefaultName = sal_True; 664 } 665 666 break; 667 } 668 } 669 } 670 } 671 catch ( container::NoSuchElementException& ) 672 { 673 // isDefaultName is left as FALSE 674 } 675 676 if ( isDefaultName ) 677 { 678 aPropSeq[2].Value <<= rtl::OUString(); 679 } 680 else 681 { 682 aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() ); 683 } 684 } 685 else 686 { 687 aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() ); 688 } 689 690 return aPropSeq; 691 } 692 693 uno::Sequence< beans::PropertyValue > 694 ConvertToolbarEntry( 695 const uno::Reference< container::XNameAccess >& xCommandToLabelMap, 696 const SvxConfigEntry* pEntry ) 697 { 698 static const OUString aDescriptorCommandURL ( 699 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_COMMANDURL ) ); 700 701 static const OUString aDescriptorType( 702 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) ); 703 704 static const OUString aDescriptorLabel( 705 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_LABEL ) ); 706 707 static const OUString aDescriptorContainer( 708 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) ); 709 710 static const OUString aIsVisible( 711 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_ISVISIBLE ) ); 712 713 uno::Sequence< beans::PropertyValue > aPropSeq( 4 ); 714 715 aPropSeq[0].Name = aDescriptorCommandURL; 716 aPropSeq[0].Value <<= rtl::OUString( pEntry->GetCommand() ); 717 718 aPropSeq[1].Name = aDescriptorType; 719 aPropSeq[1].Value <<= css::ui::ItemType::DEFAULT; 720 721 // If the name has not been changed and the name is the same as 722 // in the default command to label map then the label can be stored 723 // as an empty string. 724 // It will be initialised again later using the command to label map. 725 aPropSeq[2].Name = aDescriptorLabel; 726 if ( pEntry->HasChangedName() == sal_False && pEntry->GetCommand().getLength() ) 727 { 728 sal_Bool isDefaultName = sal_False; 729 try 730 { 731 uno::Any a( xCommandToLabelMap->getByName( pEntry->GetCommand() ) ); 732 uno::Sequence< beans::PropertyValue > tmpPropSeq; 733 if ( a >>= tmpPropSeq ) 734 { 735 for ( sal_Int32 i = 0; i < tmpPropSeq.getLength(); i++ ) 736 { 737 if ( tmpPropSeq[i].Name.equals( aDescriptorLabel ) ) 738 { 739 OUString tmpLabel; 740 tmpPropSeq[i].Value >>= tmpLabel; 741 742 if ( tmpLabel.equals( pEntry->GetName() ) ) 743 { 744 isDefaultName = sal_True; 745 } 746 747 break; 748 } 749 } 750 } 751 } 752 catch ( container::NoSuchElementException& ) 753 { 754 // isDefaultName is left as FALSE 755 } 756 757 if ( isDefaultName ) 758 { 759 aPropSeq[2].Value <<= rtl::OUString(); 760 } 761 else 762 { 763 aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() ); 764 } 765 } 766 else 767 { 768 aPropSeq[2].Value <<= rtl::OUString( pEntry->GetName() ); 769 } 770 771 aPropSeq[3].Name = aIsVisible; 772 aPropSeq[3].Value <<= pEntry->IsVisible(); 773 774 return aPropSeq; 775 } 776 777 SfxTabPage *CreateSvxMenuConfigPage( Window *pParent, const SfxItemSet& rSet ) 778 { 779 return new SvxMenuConfigPage( pParent, rSet ); 780 } 781 782 SfxTabPage *CreateKeyboardConfigPage( Window *pParent, const SfxItemSet& rSet ) 783 { 784 return new SfxAcceleratorConfigPage( pParent, rSet ); 785 } 786 787 SfxTabPage *CreateSvxToolbarConfigPage( Window *pParent, const SfxItemSet& rSet ) 788 { 789 return new SvxToolbarConfigPage( pParent, rSet ); 790 } 791 792 SfxTabPage *CreateSvxEventConfigPage( Window *pParent, const SfxItemSet& rSet ) 793 { 794 return new SvxEventConfigPage( pParent, rSet, SvxEventConfigPage::EarlyInit() ); 795 } 796 797 sal_Bool impl_showKeyConfigTabPage( const css::uno::Reference< css::frame::XFrame >& xFrame ) 798 { 799 static ::rtl::OUString SERVICENAME_MODULEMANAGER = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager"); 800 static ::rtl::OUString SERVICENAME_DESKTOP = ::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop" ); 801 static ::rtl::OUString MODULEID_STARTMODULE = ::rtl::OUString::createFromAscii("com.sun.star.frame.StartModule" ); 802 803 try 804 { 805 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = ::comphelper::getProcessServiceFactory(); 806 css::uno::Reference< css::frame::XFramesSupplier > xDesktop(xSMGR->createInstance(SERVICENAME_DESKTOP), css::uno::UNO_QUERY_THROW); 807 css::uno::Reference< css::frame::XModuleManager > xMM (xSMGR->createInstance(SERVICENAME_MODULEMANAGER), css::uno::UNO_QUERY_THROW); 808 809 if (xMM.is() && xFrame.is()) 810 { 811 ::rtl::OUString sModuleId = xMM->identify(xFrame); 812 if ( 813 ( sModuleId.getLength() ) && 814 (!sModuleId.equals(MODULEID_STARTMODULE)) 815 ) 816 return sal_True; 817 } 818 } 819 catch(const css::uno::Exception&) 820 {} 821 822 return sal_False; 823 } 824 825 /****************************************************************************** 826 * 827 * SvxConfigDialog is the configuration dialog which is brought up from the 828 * Tools menu. It includes tabs for customizing menus, toolbars, events and 829 * key bindings. 830 * 831 *****************************************************************************/ 832 SvxConfigDialog::SvxConfigDialog( 833 Window * pParent, const SfxItemSet* pSet_ ) 834 : 835 SfxTabDialog( pParent, 836 CUI_RES( RID_SVXDLG_CUSTOMIZE ), pSet_ ) 837 { 838 FreeResource(); 839 840 InitImageType(); 841 842 AddTabPage( RID_SVXPAGE_MENUS, CreateSvxMenuConfigPage, NULL ); 843 AddTabPage( RID_SVXPAGE_KEYBOARD, CreateKeyboardConfigPage, NULL ); 844 AddTabPage( RID_SVXPAGE_TOOLBARS, CreateSvxToolbarConfigPage, NULL ); 845 AddTabPage( RID_SVXPAGE_EVENTS, CreateSvxEventConfigPage, NULL ); 846 847 const SfxPoolItem* pItem = 848 pSet_->GetItem( pSet_->GetPool()->GetWhich( SID_CONFIG ) ); 849 850 if ( pItem ) 851 { 852 OUString text = ((const SfxStringItem*)pItem)->GetValue(); 853 854 if (text.indexOf(OUString::createFromAscii(ITEM_TOOLBAR_URL)) == 0) 855 { 856 SetCurPageId( RID_SVXPAGE_TOOLBARS ); 857 } 858 } 859 } 860 861 void SvxConfigDialog::SetFrame(const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame) 862 { 863 m_xFrame = xFrame; 864 865 if (!impl_showKeyConfigTabPage( xFrame )) 866 RemoveTabPage( RID_SVXPAGE_KEYBOARD ); 867 } 868 869 SvxConfigDialog::~SvxConfigDialog() 870 { 871 } 872 873 short SvxConfigDialog::Ok() 874 { 875 return SfxTabDialog::Ok(); 876 } 877 878 void SvxConfigDialog::PageCreated( sal_uInt16 nId, SfxTabPage& rPage ) 879 { 880 (void)rPage; 881 882 switch ( nId ) 883 { 884 case RID_SVXPAGE_MENUS: 885 case RID_SVXPAGE_TOOLBARS: 886 case RID_SVXPAGE_KEYBOARD: 887 { 888 rPage.SetFrame(m_xFrame); 889 } 890 break; 891 case RID_SVXPAGE_EVENTS: 892 { 893 dynamic_cast< SvxEventConfigPage& >( rPage ).LateInit( m_xFrame ); 894 }; 895 break; 896 default: 897 break; 898 } 899 } 900 901 /****************************************************************************** 902 * 903 * The SaveInData class is used to hold data for entries in the Save In 904 * ListBox controls in the menu and toolbar tabs 905 * 906 ******************************************************************************/ 907 908 // Initialize static variable which holds default XImageManager 909 uno::Reference< css::ui::XImageManager>* SaveInData::xDefaultImgMgr = NULL; 910 911 SaveInData::SaveInData( 912 const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr, 913 const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr, 914 const OUString& aModuleId, 915 bool isDocConfig ) 916 : 917 bModified( sal_False ), 918 bDocConfig( isDocConfig ), 919 bReadOnly( sal_False ), 920 m_xCfgMgr( xCfgMgr ), 921 m_xParentCfgMgr( xParentCfgMgr ) 922 { 923 uno::Reference< beans::XPropertySet > xProps( 924 ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY ); 925 926 xProps->getPropertyValue( 927 OUString::createFromAscii( "DefaultContext" )) 928 >>= m_xComponentContext; 929 930 m_aSeparatorSeq.realloc( 1 ); 931 m_aSeparatorSeq[0].Name = OUString( 932 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_TYPE ) ); 933 m_aSeparatorSeq[0].Value <<= css::ui::ItemType::SEPARATOR_LINE; 934 935 if ( bDocConfig ) 936 { 937 uno::Reference< css::ui::XUIConfigurationPersistence > 938 xDocPersistence( GetConfigManager(), uno::UNO_QUERY ); 939 940 bReadOnly = xDocPersistence->isReadOnly(); 941 } 942 943 m_xServiceManager = uno::Reference< lang::XMultiServiceFactory >( 944 ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); 945 946 uno::Reference< container::XNameAccess > xNameAccess( 947 m_xServiceManager->createInstance( 948 OUString( RTL_CONSTASCII_USTRINGPARAM( 949 "com.sun.star.frame.UICommandDescription" ) ) ), 950 uno::UNO_QUERY ); 951 952 if ( xNameAccess.is() ) 953 xNameAccess->getByName( aModuleId ) >>= m_xCommandToLabelMap; 954 955 if ( !m_xImgMgr.is() ) 956 { 957 m_xImgMgr = uno::Reference< css::ui::XImageManager >( 958 GetConfigManager()->getImageManager(), uno::UNO_QUERY ); 959 } 960 961 if ( !IsDocConfig() ) 962 { 963 // If this is not a document configuration then it is the settings 964 // for the module (writer, calc, impress etc.) Use this as the default 965 // XImageManager instance 966 xDefaultImgMgr = &m_xImgMgr; 967 } 968 else 969 { 970 // If this is a document configuration then use the module image manager 971 // as default. 972 if ( m_xParentCfgMgr.is() ) 973 { 974 m_xParentImgMgr = uno::Reference< css::ui::XImageManager >( 975 m_xParentCfgMgr->getImageManager(), uno::UNO_QUERY ); 976 xDefaultImgMgr = &m_xParentImgMgr; 977 } 978 } 979 } 980 981 uno::Reference< graphic::XGraphic > GetGraphic( 982 const uno::Reference< css::ui::XImageManager >& xImageManager, 983 const OUString& rCommandURL ) 984 { 985 uno::Reference< graphic::XGraphic > result; 986 987 if ( xImageManager.is() ) 988 { 989 // TODO handle large and high contrast graphics 990 uno::Sequence< uno::Reference< graphic::XGraphic > > aGraphicSeq; 991 992 uno::Sequence< OUString > aImageCmdSeq( 1 ); 993 aImageCmdSeq[0] = rCommandURL; 994 995 try 996 { 997 aGraphicSeq = 998 xImageManager->getImages( GetImageType(), aImageCmdSeq ); 999 1000 if ( aGraphicSeq.getLength() > 0 ) 1001 { 1002 result = aGraphicSeq[0]; 1003 } 1004 } 1005 catch ( uno::Exception& ) 1006 { 1007 // will return empty XGraphic 1008 } 1009 } 1010 1011 return result; 1012 } 1013 1014 Image SaveInData::GetImage( const OUString& rCommandURL ) 1015 { 1016 Image aImage; 1017 1018 uno::Reference< graphic::XGraphic > xGraphic = 1019 GetGraphic( m_xImgMgr, rCommandURL ); 1020 1021 if ( xGraphic.is() ) 1022 { 1023 aImage = Image( xGraphic ); 1024 } 1025 else if ( xDefaultImgMgr != NULL && (*xDefaultImgMgr).is() ) 1026 { 1027 xGraphic = GetGraphic( (*xDefaultImgMgr), rCommandURL ); 1028 1029 if ( xGraphic.is() ) 1030 { 1031 aImage = Image( xGraphic ); 1032 } 1033 } 1034 1035 return aImage; 1036 } 1037 1038 bool SaveInData::PersistChanges( 1039 const uno::Reference< uno::XInterface >& xManager ) 1040 { 1041 bool result = sal_True; 1042 1043 try 1044 { 1045 if ( xManager.is() && !IsReadOnly() ) 1046 { 1047 uno::Reference< css::ui::XUIConfigurationPersistence > 1048 xConfigPersistence( xManager, uno::UNO_QUERY ); 1049 1050 if ( xConfigPersistence->isModified() ) 1051 { 1052 xConfigPersistence->store(); 1053 } 1054 } 1055 } 1056 catch ( com::sun::star::io::IOException& ) 1057 { 1058 result = sal_False; 1059 } 1060 1061 return result; 1062 } 1063 1064 /****************************************************************************** 1065 * 1066 * The MenuSaveInData class extends SaveInData and provides menu specific 1067 * load and store functionality. 1068 * 1069 ******************************************************************************/ 1070 1071 // Initialize static variable which holds default Menu data 1072 MenuSaveInData* MenuSaveInData::pDefaultData = NULL; 1073 1074 MenuSaveInData::MenuSaveInData( 1075 const uno::Reference< css::ui::XUIConfigurationManager >& cfgmgr, 1076 const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr, 1077 const OUString& aModuleId, 1078 bool isDocConfig ) 1079 : 1080 SaveInData( cfgmgr, xParentCfgMgr, aModuleId, isDocConfig ), 1081 m_aMenuResourceURL( 1082 RTL_CONSTASCII_USTRINGPARAM( ITEM_MENUBAR_URL ) ), 1083 m_aDescriptorContainer( 1084 RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) ), 1085 pRootEntry( 0 ) 1086 { 1087 try 1088 { 1089 OUString url( RTL_CONSTASCII_USTRINGPARAM( ITEM_MENUBAR_URL ) ); 1090 m_xMenuSettings = GetConfigManager()->getSettings( url, sal_False ); 1091 } 1092 catch ( container::NoSuchElementException& ) 1093 { 1094 // will use menu settings for the module 1095 } 1096 1097 // If this is not a document configuration then it is the settings 1098 // for the module (writer, calc, impress etc.). These settings should 1099 // be set as the default to be used for SaveIn locations that do not 1100 // have custom settings 1101 if ( !IsDocConfig() ) 1102 { 1103 SetDefaultData( this ); 1104 } 1105 } 1106 1107 MenuSaveInData::~MenuSaveInData() 1108 { 1109 if ( pRootEntry != NULL ) 1110 { 1111 delete pRootEntry; 1112 } 1113 } 1114 1115 SvxEntries* 1116 MenuSaveInData::GetEntries() 1117 { 1118 if ( pRootEntry == NULL ) 1119 { 1120 pRootEntry = new SvxConfigEntry( 1121 String::CreateFromAscii("MainMenus"), String(), sal_True ); 1122 1123 if ( m_xMenuSettings.is() ) 1124 { 1125 LoadSubMenus( m_xMenuSettings, String(), pRootEntry ); 1126 } 1127 else if ( GetDefaultData() != NULL ) 1128 { 1129 // If the doc has no config settings use module config settings 1130 LoadSubMenus( GetDefaultData()->m_xMenuSettings, String(), pRootEntry ); 1131 } 1132 } 1133 1134 return pRootEntry->GetEntries(); 1135 } 1136 1137 void 1138 MenuSaveInData::SetEntries( SvxEntries* pNewEntries ) 1139 { 1140 // delete old menu hierarchy first 1141 if ( pRootEntry != NULL ) 1142 { 1143 delete pRootEntry->GetEntries(); 1144 } 1145 1146 // now set new menu hierarchy 1147 pRootEntry->SetEntries( pNewEntries ); 1148 } 1149 1150 bool MenuSaveInData::LoadSubMenus( 1151 const uno::Reference< container::XIndexAccess >& xMenuSettings, 1152 const OUString& rBaseTitle, 1153 SvxConfigEntry* pParentData ) 1154 { 1155 SvxEntries* pEntries = pParentData->GetEntries(); 1156 1157 // Don't access non existing menu configuration! 1158 if ( !xMenuSettings.is() ) 1159 return true; 1160 1161 for ( sal_Int32 nIndex = 0; nIndex < xMenuSettings->getCount(); nIndex++ ) 1162 { 1163 uno::Reference< container::XIndexAccess > xSubMenu; 1164 OUString aCommandURL; 1165 OUString aLabel; 1166 bool bIsUserDefined = sal_True; 1167 1168 sal_uInt16 nType( css::ui::ItemType::DEFAULT ); 1169 1170 bool bItem = GetMenuItemData( xMenuSettings, nIndex, 1171 aCommandURL, aLabel, nType, xSubMenu ); 1172 1173 if ( bItem ) 1174 { 1175 if ( nType == css::ui::ItemType::DEFAULT ) 1176 { 1177 uno::Any a; 1178 try 1179 { 1180 a = m_xCommandToLabelMap->getByName( aCommandURL ); 1181 bIsUserDefined = sal_False; 1182 } 1183 catch ( container::NoSuchElementException& ) 1184 { 1185 bIsUserDefined = sal_True; 1186 } 1187 1188 // If custom label not set retrieve it from the command 1189 // to info service 1190 if ( aLabel.equals( OUString() ) ) 1191 { 1192 uno::Sequence< beans::PropertyValue > aPropSeq; 1193 if ( a >>= aPropSeq ) 1194 { 1195 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) 1196 { 1197 if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) ) 1198 { 1199 aPropSeq[i].Value >>= aLabel; 1200 break; 1201 } 1202 } 1203 } 1204 } 1205 1206 if ( xSubMenu.is() ) 1207 { 1208 // popup menu 1209 SvxConfigEntry* pEntry = new SvxConfigEntry( 1210 aLabel, aCommandURL, sal_True ); 1211 1212 pEntry->SetUserDefined( bIsUserDefined ); 1213 1214 pEntries->push_back( pEntry ); 1215 1216 OUString subMenuTitle( rBaseTitle ); 1217 1218 if ( subMenuTitle.getLength() != 0 ) 1219 { 1220 subMenuTitle += 1221 OUString::createFromAscii(pMenuSeparatorStr); 1222 } 1223 else 1224 { 1225 pEntry->SetMain( sal_True ); 1226 } 1227 1228 subMenuTitle += stripHotKey( aLabel ); 1229 1230 LoadSubMenus( xSubMenu, subMenuTitle, pEntry ); 1231 } 1232 else 1233 { 1234 SvxConfigEntry* pEntry = new SvxConfigEntry( 1235 aLabel, aCommandURL, sal_False ); 1236 pEntry->SetUserDefined( bIsUserDefined ); 1237 pEntries->push_back( pEntry ); 1238 } 1239 } 1240 else 1241 { 1242 SvxConfigEntry* pEntry = new SvxConfigEntry; 1243 pEntry->SetUserDefined( bIsUserDefined ); 1244 pEntries->push_back( pEntry ); 1245 } 1246 } 1247 } 1248 return true; 1249 } 1250 1251 bool MenuSaveInData::Apply() 1252 { 1253 bool result = sal_False; 1254 1255 if ( IsModified() ) 1256 { 1257 // Apply new menu bar structure to our settings container 1258 m_xMenuSettings = uno::Reference< container::XIndexAccess >( 1259 GetConfigManager()->createSettings(), uno::UNO_QUERY ); 1260 1261 uno::Reference< container::XIndexContainer > xIndexContainer ( 1262 m_xMenuSettings, uno::UNO_QUERY ); 1263 1264 uno::Reference< lang::XSingleComponentFactory > xFactory ( 1265 m_xMenuSettings, uno::UNO_QUERY ); 1266 1267 Apply( pRootEntry, xIndexContainer, xFactory, NULL ); 1268 1269 try 1270 { 1271 if ( GetConfigManager()->hasSettings( m_aMenuResourceURL ) ) 1272 { 1273 GetConfigManager()->replaceSettings( 1274 m_aMenuResourceURL, m_xMenuSettings ); 1275 } 1276 else 1277 { 1278 GetConfigManager()->insertSettings( 1279 m_aMenuResourceURL, m_xMenuSettings ); 1280 } 1281 } 1282 catch ( container::NoSuchElementException& ) 1283 { 1284 OSL_TRACE("caught container::NoSuchElementException saving settings"); 1285 } 1286 catch ( com::sun::star::io::IOException& ) 1287 { 1288 OSL_TRACE("caught IOException saving settings"); 1289 } 1290 catch ( com::sun::star::uno::Exception& ) 1291 { 1292 OSL_TRACE("caught some other exception saving settings"); 1293 } 1294 1295 SetModified( sal_False ); 1296 1297 result = PersistChanges( GetConfigManager() ); 1298 } 1299 1300 return result; 1301 } 1302 1303 void MenuSaveInData::Apply( 1304 SvxConfigEntry* pRootEntry_, 1305 uno::Reference< container::XIndexContainer >& rMenuBar, 1306 uno::Reference< lang::XSingleComponentFactory >& rFactory, 1307 SvLBoxEntry *pParentEntry ) 1308 { 1309 (void)pRootEntry_; 1310 (void)pParentEntry; 1311 1312 SvxEntries::const_iterator iter = GetEntries()->begin(); 1313 SvxEntries::const_iterator end = GetEntries()->end(); 1314 1315 for ( ; iter != end; iter++ ) 1316 { 1317 SvxConfigEntry* pEntryData = *iter; 1318 1319 uno::Sequence< beans::PropertyValue > aPropValueSeq = 1320 ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntryData ); 1321 1322 uno::Reference< container::XIndexContainer > xSubMenuBar( 1323 rFactory->createInstanceWithContext( m_xComponentContext ), 1324 uno::UNO_QUERY ); 1325 1326 sal_Int32 nIndex = aPropValueSeq.getLength(); 1327 aPropValueSeq.realloc( nIndex + 1 ); 1328 aPropValueSeq[nIndex].Name = m_aDescriptorContainer; 1329 aPropValueSeq[nIndex].Value <<= xSubMenuBar; 1330 rMenuBar->insertByIndex( 1331 rMenuBar->getCount(), uno::makeAny( aPropValueSeq )); 1332 ApplyMenu( xSubMenuBar, rFactory, pEntryData ); 1333 } 1334 } 1335 1336 void MenuSaveInData::ApplyMenu( 1337 uno::Reference< container::XIndexContainer >& rMenuBar, 1338 uno::Reference< lang::XSingleComponentFactory >& rFactory, 1339 SvxConfigEntry* pMenuData ) 1340 { 1341 SvxEntries::const_iterator iter = pMenuData->GetEntries()->begin(); 1342 SvxEntries::const_iterator end = pMenuData->GetEntries()->end(); 1343 1344 for ( ; iter != end; iter++ ) 1345 { 1346 SvxConfigEntry* pEntry = *iter; 1347 1348 if ( pEntry->IsPopup() ) 1349 { 1350 uno::Sequence< beans::PropertyValue > aPropValueSeq = 1351 ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntry ); 1352 1353 uno::Reference< container::XIndexContainer > xSubMenuBar( 1354 rFactory->createInstanceWithContext( m_xComponentContext ), 1355 uno::UNO_QUERY ); 1356 1357 sal_Int32 nIndex = aPropValueSeq.getLength(); 1358 aPropValueSeq.realloc( nIndex + 1 ); 1359 aPropValueSeq[nIndex].Name = m_aDescriptorContainer; 1360 aPropValueSeq[nIndex].Value <<= xSubMenuBar; 1361 1362 rMenuBar->insertByIndex( 1363 rMenuBar->getCount(), uno::makeAny( aPropValueSeq )); 1364 1365 ApplyMenu( xSubMenuBar, rFactory, pEntry ); 1366 } 1367 else if ( pEntry->IsSeparator() ) 1368 { 1369 rMenuBar->insertByIndex( 1370 rMenuBar->getCount(), uno::makeAny( m_aSeparatorSeq )); 1371 } 1372 else 1373 { 1374 uno::Sequence< beans::PropertyValue > aPropValueSeq = 1375 ConvertSvxConfigEntry( m_xCommandToLabelMap, pEntry ); 1376 rMenuBar->insertByIndex( 1377 rMenuBar->getCount(), uno::makeAny( aPropValueSeq )); 1378 } 1379 } 1380 } 1381 1382 void 1383 MenuSaveInData::Reset() 1384 { 1385 GetConfigManager()->reset(); 1386 1387 delete pRootEntry; 1388 pRootEntry = NULL; 1389 1390 try 1391 { 1392 m_xMenuSettings = GetConfigManager()->getSettings( 1393 m_aMenuResourceURL, sal_False ); 1394 } 1395 catch ( container::NoSuchElementException& ) 1396 { 1397 // will use default settings 1398 } 1399 } 1400 1401 class PopupPainter : public SvLBoxString 1402 { 1403 public: 1404 PopupPainter( SvLBoxEntry* pEntry, const String& rStr ) 1405 : SvLBoxString( pEntry, 0, rStr ) 1406 { } 1407 1408 ~PopupPainter() { } 1409 1410 void Paint( const Point& rPos, SvLBox& rOutDev, 1411 sal_uInt16 nViewDataEntryFlags, SvLBoxEntry* pEntry ) 1412 { 1413 SvLBoxString::Paint( rPos, rOutDev, nViewDataEntryFlags, pEntry ); 1414 1415 Color aOldFillColor = rOutDev.GetFillColor(); 1416 1417 SvTreeListBox* pTreeBox = static_cast< SvTreeListBox* >( &rOutDev ); 1418 long nX = pTreeBox->GetSizePixel().Width(); 1419 1420 ScrollBar* pVScroll = pTreeBox->GetVScroll(); 1421 if ( pVScroll->IsVisible() ) 1422 { 1423 nX -= pVScroll->GetSizePixel().Width(); 1424 } 1425 1426 SvViewDataItem* pItem = rOutDev.GetViewDataItem( pEntry, this ); 1427 nX -= pItem->aSize.Height(); 1428 1429 long nSize = pItem->aSize.Height() / 2; 1430 long nHalfSize = nSize / 2; 1431 long nY = rPos.Y() + nHalfSize; 1432 1433 if ( aOldFillColor == COL_WHITE ) 1434 { 1435 rOutDev.SetFillColor( Color( COL_BLACK ) ); 1436 } 1437 else 1438 { 1439 rOutDev.SetFillColor( Color( COL_WHITE ) ); 1440 } 1441 1442 long n = 0; 1443 while ( n <= nHalfSize ) 1444 { 1445 rOutDev.DrawRect( Rectangle( nX+n, nY+n, nX+n, nY+nSize-n ) ); 1446 n++; 1447 } 1448 1449 rOutDev.SetFillColor( aOldFillColor ); 1450 } 1451 }; 1452 1453 /****************************************************************************** 1454 * 1455 * SvxMenuEntriesListBox is the listbox in which the menu items for a 1456 * particular menu are shown. We have a custom listbox because we need 1457 * to add drag'n'drop support from the Macro Selector and within the 1458 * listbox 1459 * 1460 *****************************************************************************/ 1461 SvxMenuEntriesListBox::SvxMenuEntriesListBox( 1462 Window* pParent, const ResId& rResId) 1463 : SvTreeListBox( pParent, rResId ) 1464 , pPage( (SvxMenuConfigPage*) pParent ) 1465 , m_bIsInternalDrag( sal_False ) 1466 { 1467 SetStyle( 1468 GetStyle() | WB_CLIPCHILDREN | WB_HSCROLL | WB_HIDESELECTION ); 1469 1470 SetSpaceBetweenEntries( 3 ); 1471 SetEntryHeight( ENTRY_HEIGHT ); 1472 1473 SetHighlightRange(); 1474 SetSelectionMode(SINGLE_SELECTION); 1475 1476 SetDragDropMode( SV_DRAGDROP_CTRL_MOVE | 1477 SV_DRAGDROP_APP_COPY | 1478 SV_DRAGDROP_ENABLE_TOP | 1479 SV_DRAGDROP_APP_DROP); 1480 } 1481 1482 SvxMenuEntriesListBox::~SvxMenuEntriesListBox() 1483 { 1484 // do nothing 1485 } 1486 1487 // drag and drop support 1488 DragDropMode SvxMenuEntriesListBox::NotifyStartDrag( 1489 TransferDataContainer& aTransferDataContainer, SvLBoxEntry* pEntry ) 1490 { 1491 (void)aTransferDataContainer; 1492 (void)pEntry; 1493 1494 m_bIsInternalDrag = sal_True; 1495 return GetDragDropMode(); 1496 } 1497 1498 void SvxMenuEntriesListBox::DragFinished( sal_Int8 nDropAction ) 1499 { 1500 (void)nDropAction; 1501 m_bIsInternalDrag = sal_False; 1502 } 1503 1504 sal_Int8 SvxMenuEntriesListBox::AcceptDrop( const AcceptDropEvent& rEvt ) 1505 { 1506 if ( m_bIsInternalDrag ) 1507 { 1508 // internal copy isn't allowed! 1509 if ( rEvt.mnAction == DND_ACTION_COPY ) 1510 return DND_ACTION_NONE; 1511 else 1512 return SvTreeListBox::AcceptDrop( rEvt ); 1513 } 1514 1515 // Always do COPY instead of MOVE if D&D comes from outside! 1516 AcceptDropEvent aNewAcceptDropEvent( rEvt ); 1517 aNewAcceptDropEvent.mnAction = DND_ACTION_COPY; 1518 return SvTreeListBox::AcceptDrop( aNewAcceptDropEvent ); 1519 } 1520 1521 sal_Bool SvxMenuEntriesListBox::NotifyAcceptDrop( SvLBoxEntry* ) 1522 { 1523 return sal_True; 1524 } 1525 1526 sal_Bool SvxMenuEntriesListBox::NotifyMoving( 1527 SvLBoxEntry* pTarget, SvLBoxEntry* pSource, 1528 SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos) 1529 { 1530 // only try to do a move if we are dragging within the list box 1531 if ( m_bIsInternalDrag ) 1532 { 1533 if ( pPage->MoveEntryData( pSource, pTarget ) == sal_True ) 1534 { 1535 SvTreeListBox::NotifyMoving( 1536 pTarget, pSource, rpNewParent, rNewChildPos ); 1537 return sal_True; 1538 } 1539 else 1540 { 1541 return sal_False; 1542 } 1543 } 1544 else 1545 { 1546 return NotifyCopying( pTarget, pSource, rpNewParent, rNewChildPos ); 1547 } 1548 } 1549 1550 sal_Bool SvxMenuEntriesListBox::NotifyCopying( 1551 SvLBoxEntry* pTarget, SvLBoxEntry* pSource, 1552 SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos) 1553 { 1554 (void)pSource; 1555 (void)rpNewParent; 1556 (void)rNewChildPos; 1557 1558 if ( !m_bIsInternalDrag ) 1559 { 1560 // if the target is NULL then add function to the start of the list 1561 pPage->AddFunction( pTarget, pTarget == NULL ); 1562 1563 // AddFunction already adds the listbox entry so return FALSE 1564 // to stop another listbox entry being added 1565 return sal_False; 1566 } 1567 1568 // Copying is only allowed from external controls, not within the listbox 1569 return sal_False; 1570 } 1571 1572 void SvxMenuEntriesListBox::KeyInput( const KeyEvent& rKeyEvent ) 1573 { 1574 KeyCode keycode = rKeyEvent.GetKeyCode(); 1575 1576 // support DELETE for removing the current entry 1577 if ( keycode == KEY_DELETE ) 1578 { 1579 pPage->DeleteSelectedContent(); 1580 } 1581 // support CTRL+UP and CTRL+DOWN for moving selected entries 1582 else if ( keycode.GetCode() == KEY_UP && keycode.IsMod1() ) 1583 { 1584 pPage->MoveEntry( sal_True ); 1585 } 1586 else if ( keycode.GetCode() == KEY_DOWN && keycode.IsMod1() ) 1587 { 1588 pPage->MoveEntry( sal_False ); 1589 } 1590 else 1591 { 1592 // pass on to superclass 1593 SvTreeListBox::KeyInput( rKeyEvent ); 1594 } 1595 } 1596 1597 // class SvxDescriptionEdit ---------------------------------------------- 1598 1599 SvxDescriptionEdit::SvxDescriptionEdit( Window* pParent, const ResId& _rId ) : 1600 1601 ExtMultiLineEdit( pParent, _rId ) 1602 1603 { 1604 // calculate the available space for help text 1605 m_aRealRect = Rectangle( Point(), GetSizePixel() ); 1606 if ( GetVScrollBar() ) 1607 m_aRealRect.Right() -= ( GetVScrollBar()->GetSizePixel().Width() + 4 ); 1608 1609 SetLeftMargin(2); 1610 SetBorderStyle( WINDOW_BORDER_MONO ); 1611 } 1612 1613 // ----------------------------------------------------------------------- 1614 1615 void SvxDescriptionEdit::SetNewText( const String& _rText ) 1616 { 1617 String sTemp( _rText ); 1618 sal_Bool bShow = sal_False; 1619 if ( sTemp.Len() > 0 ) 1620 { 1621 // detect if a scrollbar is necessary 1622 Rectangle aRect = GetTextRect( m_aRealRect, sTemp, TEXT_DRAW_WORDBREAK | TEXT_DRAW_MULTILINE ); 1623 bShow = ( aRect.Bottom() > m_aRealRect.Bottom() ); 1624 } 1625 1626 if ( GetVScrollBar() ) 1627 GetVScrollBar()->Show( bShow ); 1628 1629 if ( bShow ) 1630 sTemp += '\n'; 1631 1632 SetText( sTemp ); 1633 } 1634 1635 /****************************************************************************** 1636 * 1637 * SvxConfigPage is the abstract base class on which the Menu and Toolbar 1638 * configuration tabpages are based. It includes methods which are common to 1639 * both tabpages to add, delete, move and rename items etc. 1640 * 1641 *****************************************************************************/ 1642 SvxConfigPage::SvxConfigPage( 1643 Window *pParent, const SfxItemSet& rSet ) 1644 : 1645 SfxTabPage( pParent, CUI_RES( RID_SVXPAGE_MENUS ), rSet ), 1646 bInitialised( sal_False ), 1647 pCurrentSaveInData( 0 ), 1648 aTopLevelSeparator( this, CUI_RES( GRP_MENUS ) ), 1649 aTopLevelLabel( this, CUI_RES( FT_MENUS ) ), 1650 aTopLevelListBox( this, CUI_RES( LB_MENUS ) ), 1651 aNewTopLevelButton( this, CUI_RES( BTN_NEW ) ), 1652 aModifyTopLevelButton( this, CUI_RES( BTN_CHANGE ) ), 1653 aContentsSeparator( this, CUI_RES( GRP_MENU_SEPARATOR ) ), 1654 aContentsLabel( this, CUI_RES( GRP_MENU_ENTRIES ) ), 1655 aContentsListBox( 0 ), 1656 aAddCommandsButton( this, CUI_RES( BTN_ADD_COMMANDS ) ), 1657 aModifyCommandButton( this, CUI_RES( BTN_CHANGE_ENTRY ) ), 1658 aMoveUpButton( this, CUI_RES( BTN_UP ) ), 1659 aMoveDownButton( this, CUI_RES( BTN_DOWN ) ), 1660 aSaveInText( this, CUI_RES( TXT_SAVEIN ) ), 1661 aSaveInListBox( this, CUI_RES( LB_SAVEIN ) ), 1662 aDescriptionLabel( this, CUI_RES( FT_DESCRIPTION ) ), 1663 aDescriptionField( this, CUI_RES( ED_DESCRIPTION ) ), 1664 pSelectorDlg( 0 ) 1665 { 1666 aDescriptionField.SetControlBackground( GetSettings().GetStyleSettings().GetDialogColor() ); 1667 aDescriptionField.SetAutoScroll( sal_True ); 1668 aDescriptionField.EnableCursor( sal_False ); 1669 1670 aMoveUpButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_UP))); 1671 aMoveDownButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_DOWN))); 1672 aMoveUpButton.SetAccessibleRelationMemberOf(&aContentsSeparator); 1673 aMoveDownButton.SetAccessibleRelationMemberOf(&aContentsSeparator); 1674 aNewTopLevelButton.SetAccessibleRelationMemberOf(&aTopLevelSeparator); 1675 aModifyTopLevelButton.SetAccessibleRelationMemberOf(&aTopLevelSeparator); 1676 aAddCommandsButton.SetAccessibleRelationMemberOf(&aContentsSeparator); 1677 aModifyCommandButton.SetAccessibleRelationMemberOf(&aContentsSeparator); 1678 } 1679 1680 SvxConfigPage::~SvxConfigPage() 1681 { 1682 } 1683 1684 void SvxConfigPage::Reset( const SfxItemSet& ) 1685 { 1686 // If we haven't initialised our XMultiServiceFactory reference 1687 // then Reset is being called at the opening of the dialog. 1688 // 1689 // Load menu configuration data for the module of the currently 1690 // selected document, for the currently selected document, and for 1691 // all other open documents of the same module type 1692 if ( !bInitialised ) 1693 { 1694 sal_uInt16 nPos = 0; 1695 uno::Reference < css::ui::XUIConfigurationManager > xCfgMgr; 1696 uno::Reference < css::ui::XUIConfigurationManager > xDocCfgMgr; 1697 1698 uno::Reference< lang::XMultiServiceFactory > xServiceManager( 1699 ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); 1700 1701 m_xFrame = GetFrame(); 1702 OUString aModuleId = GetFrameWithDefaultAndIdentify( m_xFrame ); 1703 1704 // replace %MODULENAME in the label with the correct module name 1705 uno::Reference< css::frame::XModuleManager > xModuleManager( 1706 xServiceManager->createInstance( 1707 OUString( RTL_CONSTASCII_USTRINGPARAM( 1708 "com.sun.star.frame.ModuleManager" ) ) ), 1709 uno::UNO_QUERY_THROW ); 1710 OUString aModuleName = GetUIModuleName( aModuleId, xModuleManager ); 1711 1712 OUString title = aTopLevelSeparator.GetText(); 1713 OUString aSearchString = OUString::createFromAscii( "%MODULENAME" ); 1714 sal_Int32 index = title.indexOf( aSearchString ); 1715 1716 if ( index != -1 ) 1717 { 1718 title = title.replaceAt( 1719 index, aSearchString.getLength(), aModuleName ); 1720 aTopLevelSeparator.SetText( title ); 1721 } 1722 1723 uno::Reference< css::ui::XModuleUIConfigurationManagerSupplier > 1724 xModuleCfgSupplier( xServiceManager->createInstance( 1725 OUString( RTL_CONSTASCII_USTRINGPARAM( 1726 "com.sun.star.ui.ModuleUIConfigurationManagerSupplier" ))), 1727 uno::UNO_QUERY ); 1728 1729 // Set up data for module specific menus 1730 SaveInData* pModuleData = NULL; 1731 1732 try 1733 { 1734 xCfgMgr = 1735 xModuleCfgSupplier->getUIConfigurationManager( aModuleId ); 1736 1737 pModuleData = CreateSaveInData( xCfgMgr, 1738 uno::Reference< css::ui::XUIConfigurationManager >(), 1739 aModuleId, 1740 sal_False ); 1741 } 1742 catch ( container::NoSuchElementException& ) 1743 { 1744 } 1745 1746 if ( pModuleData != NULL ) 1747 { 1748 OUString label; 1749 utl::ConfigManager::GetDirectConfigProperty( 1750 utl::ConfigManager::PRODUCTNAME ) >>= label; 1751 label += OUString::createFromAscii( " " ); 1752 label += aModuleName; 1753 1754 nPos = aSaveInListBox.InsertEntry( label ); 1755 aSaveInListBox.SetEntryData( nPos, pModuleData ); 1756 } 1757 1758 // try to retrieve the document based ui configuration manager 1759 OUString aTitle; 1760 uno::Reference< frame::XController > xController = 1761 m_xFrame->getController(); 1762 if ( CanConfig( aModuleId ) && xController.is() ) 1763 { 1764 uno::Reference< frame::XModel > xModel( xController->getModel() ); 1765 if ( xModel.is() ) 1766 { 1767 uno::Reference< css::ui::XUIConfigurationManagerSupplier > 1768 xCfgSupplier( xModel, uno::UNO_QUERY ); 1769 1770 if ( xCfgSupplier.is() ) 1771 { 1772 xDocCfgMgr = xCfgSupplier->getUIConfigurationManager(); 1773 } 1774 aTitle = ::comphelper::DocumentInfo::getDocumentTitle( xModel ); 1775 } 1776 } 1777 1778 SaveInData* pDocData = NULL; 1779 if ( xDocCfgMgr.is() ) 1780 { 1781 pDocData = CreateSaveInData( xDocCfgMgr, xCfgMgr, aModuleId, sal_True ); 1782 1783 if ( !pDocData->IsReadOnly() ) 1784 { 1785 nPos = aSaveInListBox.InsertEntry( aTitle ); 1786 aSaveInListBox.SetEntryData( nPos, pDocData ); 1787 } 1788 } 1789 1790 // if an item to select has been passed in (eg. the ResourceURL for a 1791 // toolbar) then try to select the SaveInData entry that has that item 1792 bool bURLToSelectFound = sal_False; 1793 if ( m_aURLToSelect.getLength() != 0 ) 1794 { 1795 if ( pDocData != NULL && pDocData->HasURL( m_aURLToSelect ) ) 1796 { 1797 aSaveInListBox.SelectEntryPos( nPos, sal_True ); 1798 pCurrentSaveInData = pDocData; 1799 bURLToSelectFound = sal_True; 1800 } 1801 else if ( pModuleData->HasURL( m_aURLToSelect ) ) 1802 { 1803 aSaveInListBox.SelectEntryPos( 0, sal_True ); 1804 pCurrentSaveInData = pModuleData; 1805 bURLToSelectFound = sal_True; 1806 } 1807 } 1808 1809 if ( bURLToSelectFound == sal_False ) 1810 { 1811 // if the document has menu configuration settings select it 1812 // it the SaveIn listbox, otherwise select the module data 1813 if ( pDocData != NULL && pDocData->HasSettings() ) 1814 { 1815 aSaveInListBox.SelectEntryPos( nPos, sal_True ); 1816 pCurrentSaveInData = pDocData; 1817 } 1818 else 1819 { 1820 aSaveInListBox.SelectEntryPos( 0, sal_True ); 1821 pCurrentSaveInData = pModuleData; 1822 } 1823 } 1824 1825 #ifdef DBG_UTIL 1826 DBG_ASSERT( pCurrentSaveInData, "SvxConfigPage::Reset(): no SaveInData" ); 1827 #endif 1828 1829 if ( CanConfig( aModuleId ) ) 1830 { 1831 // Load configuration for other open documents which have 1832 // same module type 1833 uno::Sequence< uno::Reference< frame::XFrame > > aFrameList; 1834 try 1835 { 1836 uno::Reference< frame::XFramesSupplier > xFramesSupplier( 1837 xServiceManager->createInstance( 1838 OUString( RTL_CONSTASCII_USTRINGPARAM( 1839 "com.sun.star.frame.Desktop" ) ) ), 1840 uno::UNO_QUERY_THROW ); 1841 1842 uno::Reference< frame::XFrames > xFrames = 1843 xFramesSupplier->getFrames(); 1844 1845 aFrameList = xFrames->queryFrames( 1846 frame::FrameSearchFlag::ALL & ~frame::FrameSearchFlag::SELF ); 1847 1848 } 1849 catch( const uno::Exception& ) 1850 { 1851 DBG_UNHANDLED_EXCEPTION(); 1852 } 1853 1854 for ( sal_Int32 i = 0; i < aFrameList.getLength(); i++ ) 1855 { 1856 SaveInData* pData = NULL; 1857 uno::Reference < frame::XFrame > xf = aFrameList[i]; 1858 1859 if ( xf.is() && xf != m_xFrame ) 1860 { 1861 OUString aCheckId; 1862 try{ 1863 aCheckId = xModuleManager->identify( xf ); 1864 } catch(const uno::Exception&) 1865 { aCheckId = ::rtl::OUString(); } 1866 1867 if ( aModuleId.equals( aCheckId ) ) 1868 { 1869 // try to get the document based ui configuration manager 1870 OUString aTitle2; 1871 uno::Reference< frame::XController > xController_ = 1872 xf->getController(); 1873 1874 if ( xController_.is() ) 1875 { 1876 uno::Reference< frame::XModel > xModel( 1877 xController_->getModel() ); 1878 1879 if ( xModel.is() ) 1880 { 1881 uno::Reference< 1882 css::ui::XUIConfigurationManagerSupplier > 1883 xCfgSupplier( xModel, uno::UNO_QUERY ); 1884 1885 if ( xCfgSupplier.is() ) 1886 { 1887 xDocCfgMgr = 1888 xCfgSupplier->getUIConfigurationManager(); 1889 } 1890 aTitle2 = ::comphelper::DocumentInfo::getDocumentTitle( xModel ); 1891 } 1892 } 1893 1894 if ( xDocCfgMgr.is() ) 1895 { 1896 pData = CreateSaveInData( xDocCfgMgr, xCfgMgr, aModuleId, sal_True ); 1897 1898 if ( pData && !pData->IsReadOnly() ) 1899 { 1900 nPos = aSaveInListBox.InsertEntry( aTitle2 ); 1901 aSaveInListBox.SetEntryData( nPos, pData ); 1902 } 1903 } 1904 } 1905 } 1906 } 1907 } 1908 1909 aSaveInListBox.SetSelectHdl( 1910 LINK( this, SvxConfigPage, SelectSaveInLocation ) ); 1911 1912 bInitialised = sal_True; 1913 1914 Init(); 1915 } 1916 else 1917 { 1918 if ( QueryReset() == RET_YES ) 1919 { 1920 // Reset menu configuration for currently selected SaveInData 1921 GetSaveInData()->Reset(); 1922 1923 Init(); 1924 } 1925 } 1926 } 1927 1928 ::rtl::OUString SvxConfigPage::GetFrameWithDefaultAndIdentify( uno::Reference< frame::XFrame >& _inout_rxFrame ) 1929 { 1930 ::rtl::OUString sModuleID; 1931 try 1932 { 1933 uno::Reference< lang::XMultiServiceFactory > xServiceManager( 1934 ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); 1935 1936 uno::Reference< frame::XFramesSupplier > xFramesSupplier( 1937 xServiceManager->createInstance( 1938 OUString( RTL_CONSTASCII_USTRINGPARAM( 1939 "com.sun.star.frame.Desktop" ) ) ), 1940 uno::UNO_QUERY_THROW ); 1941 1942 if ( !_inout_rxFrame.is() ) 1943 _inout_rxFrame = xFramesSupplier->getActiveFrame(); 1944 1945 if ( !_inout_rxFrame.is() ) 1946 { 1947 uno::Reference< frame::XDesktop > xDesktop( xFramesSupplier, uno::UNO_QUERY_THROW ); 1948 _inout_rxFrame = xDesktop->getCurrentFrame(); 1949 } 1950 1951 if ( !_inout_rxFrame.is() && SfxViewFrame::Current() ) 1952 _inout_rxFrame = SfxViewFrame::Current()->GetFrame().GetFrameInterface(); 1953 1954 if ( !_inout_rxFrame.is() ) 1955 { 1956 DBG_ERRORFILE( "SvxConfigPage::GetFrameWithDefaultAndIdentify(): no frame found!" ); 1957 return sModuleID; 1958 } 1959 1960 uno::Reference< css::frame::XModuleManager > xModuleManager( 1961 xServiceManager->createInstance( 1962 OUString( RTL_CONSTASCII_USTRINGPARAM( 1963 "com.sun.star.frame.ModuleManager" ) ) ), 1964 uno::UNO_QUERY_THROW ); 1965 1966 try 1967 { 1968 sModuleID = xModuleManager->identify( _inout_rxFrame ); 1969 } 1970 catch ( const frame::UnknownModuleException& ) 1971 { 1972 } 1973 1974 } 1975 catch( const uno::Exception& ) 1976 { 1977 DBG_UNHANDLED_EXCEPTION(); 1978 } 1979 1980 return sModuleID; 1981 } 1982 1983 sal_Bool SvxConfigPage::FillItemSet( SfxItemSet& ) 1984 { 1985 bool result = sal_False; 1986 1987 for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ ) 1988 { 1989 SaveInData* pData = 1990 (SaveInData*) aSaveInListBox.GetEntryData( i ); 1991 1992 result = pData->Apply(); 1993 } 1994 return result; 1995 } 1996 1997 void SvxConfigPage::PositionContentsListBox() 1998 { 1999 if ( aContentsListBox == NULL ) 2000 { 2001 return; 2002 } 2003 2004 Point p, newp; 2005 Size s, news; 2006 long x, y, width, height; 2007 2008 // x and width is same as aTopLevelListBox 2009 x = aTopLevelListBox.GetPosPixel().X(); 2010 width = aTopLevelListBox.GetSizePixel().Width(); 2011 2012 // y is same as aAddCommandsButton 2013 y = aAddCommandsButton.GetPosPixel().Y(); 2014 2015 // get gap between aAddCommandsButton and aContentsSeparator 2016 p = aContentsSeparator.GetPosPixel(); 2017 s = aContentsSeparator.GetSizePixel(); 2018 long gap = y - ( p.Y() + s.Height() ); 2019 2020 height = aSaveInListBox.GetPosPixel().Y() - y - gap; 2021 2022 aContentsListBox->SetPosPixel( Point( x, y ) ); 2023 aContentsListBox->SetSizePixel( Size( width, height ) ); 2024 } 2025 2026 IMPL_LINK( SvxConfigPage, SelectSaveInLocation, ListBox *, pBox ) 2027 { 2028 (void)pBox; 2029 2030 pCurrentSaveInData = (SaveInData*) aSaveInListBox.GetEntryData( 2031 aSaveInListBox.GetSelectEntryPos()); 2032 2033 Init(); 2034 return 1; 2035 } 2036 2037 void SvxConfigPage::ReloadTopLevelListBox( SvxConfigEntry* pToSelect ) 2038 { 2039 sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos(); 2040 aTopLevelListBox.Clear(); 2041 2042 if ( GetSaveInData() && GetSaveInData()->GetEntries() ) 2043 { 2044 SvxEntries::const_iterator iter = GetSaveInData()->GetEntries()->begin(); 2045 SvxEntries::const_iterator end = GetSaveInData()->GetEntries()->end(); 2046 2047 for ( ; iter != end; iter++ ) 2048 { 2049 SvxConfigEntry* pEntryData = *iter; 2050 sal_uInt16 nPos = aTopLevelListBox.InsertEntry( stripHotKey( pEntryData->GetName() ) ); 2051 aTopLevelListBox.SetEntryData( nPos, pEntryData ); 2052 2053 if ( pEntryData == pToSelect ) 2054 nSelectionPos = nPos; 2055 2056 AddSubMenusToUI( stripHotKey( pEntryData->GetName() ), pEntryData ); 2057 } 2058 } 2059 #ifdef DBG_UTIL 2060 else 2061 { 2062 DBG_ASSERT( GetSaveInData(), "SvxConfigPage::ReloadTopLevelListBox(): no SaveInData" ); 2063 DBG_ASSERT( GetSaveInData()->GetEntries() , 2064 "SvxConfigPage::ReloadTopLevelListBox(): no SaveInData entries" ); 2065 } 2066 #endif 2067 2068 nSelectionPos = nSelectionPos < aTopLevelListBox.GetEntryCount() ? 2069 nSelectionPos : aTopLevelListBox.GetEntryCount() - 1; 2070 2071 aTopLevelListBox.SelectEntryPos( nSelectionPos, sal_True ); 2072 aTopLevelListBox.GetSelectHdl().Call( this ); 2073 } 2074 2075 void SvxConfigPage::AddSubMenusToUI( 2076 const String& rBaseTitle, SvxConfigEntry* pParentData ) 2077 { 2078 SvxEntries::const_iterator iter = pParentData->GetEntries()->begin(); 2079 SvxEntries::const_iterator end = pParentData->GetEntries()->end(); 2080 2081 for ( ; iter != end; iter++ ) 2082 { 2083 SvxConfigEntry* pEntryData = *iter; 2084 2085 if ( pEntryData->IsPopup() ) 2086 { 2087 OUString subMenuTitle( rBaseTitle ); 2088 subMenuTitle += OUString::createFromAscii( pMenuSeparatorStr ); 2089 subMenuTitle += stripHotKey( pEntryData->GetName() ); 2090 2091 sal_uInt16 nPos = aTopLevelListBox.InsertEntry( subMenuTitle ); 2092 aTopLevelListBox.SetEntryData( nPos, pEntryData ); 2093 2094 AddSubMenusToUI( subMenuTitle, pEntryData ); 2095 } 2096 } 2097 } 2098 2099 SvxEntries* SvxConfigPage::FindParentForChild( 2100 SvxEntries* pRootEntries, SvxConfigEntry* pChildData ) 2101 { 2102 SvxEntries::const_iterator iter = pRootEntries->begin(); 2103 SvxEntries::const_iterator end = pRootEntries->end(); 2104 2105 for ( ; iter != end; iter++ ) 2106 { 2107 SvxConfigEntry* pEntryData = *iter; 2108 2109 if ( pEntryData == pChildData ) 2110 { 2111 return pRootEntries; 2112 } 2113 else if ( pEntryData->IsPopup() ) 2114 { 2115 SvxEntries* result = 2116 FindParentForChild( pEntryData->GetEntries(), pChildData ); 2117 2118 if ( result != NULL ) 2119 { 2120 return result; 2121 } 2122 } 2123 } 2124 return NULL; 2125 } 2126 2127 SvLBoxEntry* SvxConfigPage::AddFunction( 2128 SvLBoxEntry* pTarget, bool bFront, bool bAllowDuplicates ) 2129 { 2130 String aDisplayName = pSelectorDlg->GetSelectedDisplayName(); 2131 String aHelpText = pSelectorDlg->GetSelectedHelpText(); 2132 String aURL = pSelectorDlg->GetScriptURL(); 2133 2134 if ( !aURL.Len() ) 2135 { 2136 return NULL; 2137 } 2138 2139 SvxConfigEntry* pNewEntryData = 2140 new SvxConfigEntry( aDisplayName, aURL, sal_False ); 2141 pNewEntryData->SetUserDefined( sal_True ); 2142 2143 // check that this function is not already in the menu 2144 SvxConfigEntry* pParent = GetTopLevelSelection(); 2145 2146 SvxEntries::const_iterator iter = pParent->GetEntries()->begin(); 2147 SvxEntries::const_iterator end = pParent->GetEntries()->end(); 2148 2149 if ( !bAllowDuplicates ) 2150 { 2151 while ( iter != end ) 2152 { 2153 SvxConfigEntry *pCurEntry = *iter; 2154 2155 if ( pCurEntry->GetCommand() == pNewEntryData->GetCommand() ) 2156 { 2157 // asynchronous error message, because of MsgBoxes 2158 PostUserEvent( 2159 LINK( this, SvxConfigPage, AsyncInfoMsg ) ); 2160 return NULL; 2161 } 2162 2163 iter++; 2164 } 2165 } 2166 2167 return InsertEntry( pNewEntryData, pTarget, bFront ); 2168 } 2169 2170 SvLBoxEntry* SvxConfigPage::InsertEntry( 2171 SvxConfigEntry* pNewEntryData, 2172 SvLBoxEntry* pTarget, 2173 bool bFront ) 2174 { 2175 // Grab the entries list for the currently selected menu 2176 SvxEntries* pEntries = GetTopLevelSelection()->GetEntries(); 2177 2178 SvLBoxEntry* pNewEntry = NULL; 2179 SvLBoxEntry* pCurEntry = 2180 pTarget != NULL ? pTarget : aContentsListBox->GetCurEntry(); 2181 2182 if ( bFront ) 2183 { 2184 pEntries->insert( pEntries->begin(), pNewEntryData ); 2185 pNewEntry = InsertEntryIntoUI( pNewEntryData, 0 ); 2186 } 2187 else if ( pCurEntry == NULL || pCurEntry == aContentsListBox->Last() ) 2188 { 2189 pEntries->push_back( pNewEntryData ); 2190 pNewEntry = InsertEntryIntoUI( pNewEntryData ); 2191 } 2192 else 2193 { 2194 SvxConfigEntry* pEntryData = 2195 (SvxConfigEntry*) pCurEntry->GetUserData(); 2196 2197 SvxEntries::iterator iter = pEntries->begin(); 2198 SvxEntries::const_iterator end = pEntries->end(); 2199 2200 // Advance the iterator to the data for currently selected entry 2201 sal_uInt16 nPos = 0; 2202 while (*iter != pEntryData && ++iter != end) 2203 { 2204 nPos++; 2205 } 2206 2207 // Now step past it to the entry after the currently selected one 2208 iter++; 2209 nPos++; 2210 2211 // Now add the new entry to the UI and to the parent's list 2212 if ( iter != end ) 2213 { 2214 pEntries->insert( iter, pNewEntryData ); 2215 pNewEntry = InsertEntryIntoUI( pNewEntryData, nPos ); 2216 } 2217 } 2218 2219 if ( pNewEntry != NULL ) 2220 { 2221 aContentsListBox->Select( pNewEntry ); 2222 aContentsListBox->MakeVisible( pNewEntry ); 2223 2224 GetSaveInData()->SetModified( sal_True ); 2225 } 2226 2227 return pNewEntry; 2228 } 2229 2230 SvLBoxEntry* SvxConfigPage::InsertEntryIntoUI( 2231 SvxConfigEntry* pNewEntryData, sal_uLong nPos ) 2232 { 2233 SvLBoxEntry* pNewEntry = NULL; 2234 2235 if (pNewEntryData->IsSeparator()) 2236 { 2237 pNewEntry = aContentsListBox->InsertEntry( 2238 String::CreateFromAscii( pSeparatorStr ), 2239 0, sal_False, nPos, pNewEntryData ); 2240 } 2241 else 2242 { 2243 OUString aName = stripHotKey( pNewEntryData->GetName() ); 2244 2245 Image aImage = GetSaveInData()->GetImage( 2246 pNewEntryData->GetCommand()); 2247 2248 if ( !!aImage ) 2249 { 2250 pNewEntry = aContentsListBox->InsertEntry( 2251 aName, aImage, aImage, 0, sal_False, nPos, pNewEntryData ); 2252 } 2253 else 2254 { 2255 pNewEntry = aContentsListBox->InsertEntry( 2256 aName, 0, sal_False, nPos, pNewEntryData ); 2257 } 2258 2259 if ( pNewEntryData->IsPopup() || 2260 pNewEntryData->GetStyle() & css::ui::ItemStyle::DROP_DOWN ) 2261 { 2262 // add new popup painter, it gets destructed by the entry 2263 pNewEntry->ReplaceItem( 2264 new PopupPainter( pNewEntry, aName ), 2265 pNewEntry->ItemCount() - 1 ); 2266 } 2267 } 2268 2269 return pNewEntry; 2270 } 2271 2272 IMPL_LINK( SvxConfigPage, AsyncInfoMsg, String*, pMsg ) 2273 { 2274 (void)pMsg; 2275 2276 // Asynchronous msg because of D&D 2277 InfoBox( this, CUI_RES( 2278 IBX_MNUCFG_ALREADY_INCLUDED ) ).Execute(); 2279 2280 return 0; 2281 } 2282 2283 IMPL_LINK( SvxConfigPage, MoveHdl, Button *, pButton ) 2284 { 2285 MoveEntry( pButton == &aMoveUpButton ); 2286 return 0; 2287 } 2288 2289 void SvxConfigPage::MoveEntry( bool bMoveUp ) 2290 { 2291 SvLBoxEntry *pSourceEntry = aContentsListBox->FirstSelected(); 2292 SvLBoxEntry *pTargetEntry = NULL; 2293 SvLBoxEntry *pToSelect = NULL; 2294 2295 if ( !pSourceEntry ) 2296 { 2297 return; 2298 } 2299 2300 if ( bMoveUp ) 2301 { 2302 // Move Up is just a Move Down with the source and target reversed 2303 pTargetEntry = pSourceEntry; 2304 pSourceEntry = aContentsListBox->PrevSibling( pTargetEntry ); 2305 pToSelect = pTargetEntry; 2306 } 2307 else 2308 { 2309 pTargetEntry = aContentsListBox->NextSibling( pSourceEntry ); 2310 pToSelect = pSourceEntry; 2311 } 2312 2313 if ( MoveEntryData( pSourceEntry, pTargetEntry ) ) 2314 { 2315 aContentsListBox->GetModel()->Move( pSourceEntry, pTargetEntry ); 2316 aContentsListBox->Select( pToSelect ); 2317 aContentsListBox->MakeVisible( pToSelect ); 2318 2319 UpdateButtonStates(); 2320 } 2321 } 2322 2323 bool SvxConfigPage::MoveEntryData( 2324 SvLBoxEntry* pSourceEntry, SvLBoxEntry* pTargetEntry ) 2325 { 2326 //modified by shizhoubo for issue53677 2327 if ( NULL == pSourceEntry || NULL == pTargetEntry ) 2328 { 2329 return sal_False; 2330 } 2331 2332 // Grab the entries list for the currently selected menu 2333 SvxEntries* pEntries = GetTopLevelSelection()->GetEntries(); 2334 2335 SvxConfigEntry* pSourceData = 2336 (SvxConfigEntry*) pSourceEntry->GetUserData(); 2337 2338 if ( pTargetEntry == NULL ) 2339 { 2340 RemoveEntry( pEntries, pSourceData ); 2341 pEntries->insert( 2342 pEntries->begin(), pSourceData ); 2343 2344 GetSaveInData()->SetModified( sal_True ); 2345 2346 return sal_True; 2347 } 2348 else 2349 { 2350 SvxConfigEntry* pTargetData = 2351 (SvxConfigEntry*) pTargetEntry->GetUserData(); 2352 2353 if ( pSourceData != NULL && pTargetData != NULL ) 2354 { 2355 // remove the source entry from our list 2356 RemoveEntry( pEntries, pSourceData ); 2357 2358 SvxEntries::iterator iter = pEntries->begin(); 2359 SvxEntries::const_iterator end = pEntries->end(); 2360 2361 // advance the iterator to the position of the target entry 2362 while (*iter != pTargetData && ++iter != end) ; 2363 2364 // insert the source entry at the position after the target 2365 pEntries->insert( ++iter, pSourceData ); 2366 2367 GetSaveInData()->SetModified( sal_True ); 2368 2369 return sal_True; 2370 } 2371 } 2372 2373 return sal_False; 2374 } 2375 2376 SvxMenuConfigPage::SvxMenuConfigPage( 2377 Window *pParent, const SfxItemSet& rSet ) 2378 : 2379 SvxConfigPage( pParent, rSet ) 2380 { 2381 aContentsListBox = new SvxMenuEntriesListBox( this, CUI_RES( BOX_ENTRIES ) ); 2382 FreeResource(); 2383 2384 PositionContentsListBox(); 2385 aContentsListBox->SetZOrder( &aAddCommandsButton, WINDOW_ZORDER_BEFOR ); 2386 2387 aTopLevelListBox.SetSelectHdl( 2388 LINK( this, SvxMenuConfigPage, SelectMenu ) ); 2389 2390 aContentsListBox->SetSelectHdl( 2391 LINK( this, SvxMenuConfigPage, SelectMenuEntry ) ); 2392 2393 aMoveUpButton.SetClickHdl ( LINK( this, SvxConfigPage, MoveHdl) ); 2394 aMoveDownButton.SetClickHdl ( LINK( this, SvxConfigPage, MoveHdl) ); 2395 2396 aNewTopLevelButton.SetClickHdl ( 2397 LINK( this, SvxMenuConfigPage, NewMenuHdl ) ); 2398 2399 aAddCommandsButton.SetClickHdl ( 2400 LINK( this, SvxMenuConfigPage, AddCommandsHdl ) ); 2401 2402 PopupMenu* pMenu = new PopupMenu( CUI_RES( MODIFY_MENU ) ); 2403 pMenu->SetMenuFlags( 2404 pMenu->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ); 2405 2406 aModifyTopLevelButton.SetPopupMenu( pMenu ); 2407 aModifyTopLevelButton.SetSelectHdl( 2408 LINK( this, SvxMenuConfigPage, MenuSelectHdl ) ); 2409 2410 PopupMenu* pEntry = new PopupMenu( CUI_RES( MODIFY_ENTRY ) ); 2411 pEntry->SetMenuFlags( 2412 pEntry->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ); 2413 2414 aModifyCommandButton.SetPopupMenu( pEntry ); 2415 aModifyCommandButton.SetSelectHdl( 2416 LINK( this, SvxMenuConfigPage, EntrySelectHdl ) ); 2417 } 2418 2419 // Populates the Menu combo box 2420 void SvxMenuConfigPage::Init() 2421 { 2422 // ensure that the UI is cleared before populating it 2423 aTopLevelListBox.Clear(); 2424 aContentsListBox->Clear(); 2425 2426 ReloadTopLevelListBox(); 2427 2428 aTopLevelListBox.SelectEntryPos(0, sal_True); 2429 aTopLevelListBox.GetSelectHdl().Call(this); 2430 } 2431 2432 SvxMenuConfigPage::~SvxMenuConfigPage() 2433 { 2434 for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ ) 2435 { 2436 MenuSaveInData* pData = 2437 (MenuSaveInData*) aSaveInListBox.GetEntryData( i ); 2438 2439 delete pData; 2440 } 2441 2442 if ( pSelectorDlg != NULL ) 2443 { 2444 delete pSelectorDlg; 2445 } 2446 2447 delete aContentsListBox; 2448 } 2449 2450 IMPL_LINK( SvxMenuConfigPage, SelectMenuEntry, Control *, pBox ) 2451 { 2452 (void)pBox; 2453 2454 UpdateButtonStates(); 2455 2456 return 1; 2457 } 2458 2459 void SvxMenuConfigPage::UpdateButtonStates() 2460 { 2461 PopupMenu* pPopup = aModifyCommandButton.GetPopupMenu(); 2462 2463 // Disable Up and Down buttons depending on current selection 2464 SvLBoxEntry* selection = aContentsListBox->GetCurEntry(); 2465 2466 if ( aContentsListBox->GetEntryCount() == 0 || selection == NULL ) 2467 { 2468 aMoveUpButton.Enable( sal_False ); 2469 aMoveDownButton.Enable( sal_False ); 2470 2471 pPopup->EnableItem( ID_BEGIN_GROUP, sal_True ); 2472 pPopup->EnableItem( ID_RENAME, sal_False ); 2473 pPopup->EnableItem( ID_DELETE, sal_False ); 2474 2475 aDescriptionField.Clear(); 2476 2477 return; 2478 } 2479 2480 SvLBoxEntry* first = aContentsListBox->First(); 2481 SvLBoxEntry* last = aContentsListBox->Last(); 2482 2483 aMoveUpButton.Enable( selection != first ); 2484 aMoveDownButton.Enable( selection != last ); 2485 2486 SvxConfigEntry* pEntryData = 2487 (SvxConfigEntry*) selection->GetUserData(); 2488 2489 if ( pEntryData->IsSeparator() ) 2490 { 2491 pPopup->EnableItem( ID_DELETE, sal_True ); 2492 pPopup->EnableItem( ID_BEGIN_GROUP, sal_False ); 2493 pPopup->EnableItem( ID_RENAME, sal_False ); 2494 2495 aDescriptionField.Clear(); 2496 } 2497 else 2498 { 2499 pPopup->EnableItem( ID_BEGIN_GROUP, sal_True ); 2500 pPopup->EnableItem( ID_DELETE, sal_True ); 2501 pPopup->EnableItem( ID_RENAME, sal_True ); 2502 2503 aDescriptionField.SetNewText( pEntryData->GetHelpText() ); 2504 } 2505 } 2506 2507 void SvxMenuConfigPage::DeleteSelectedTopLevel() 2508 { 2509 SvxConfigEntry* pMenuData = GetTopLevelSelection(); 2510 2511 SvxEntries* pParentEntries = 2512 FindParentForChild( GetSaveInData()->GetEntries(), pMenuData ); 2513 2514 RemoveEntry( pParentEntries, pMenuData ); 2515 delete pMenuData; 2516 2517 ReloadTopLevelListBox(); 2518 2519 GetSaveInData()->SetModified( sal_True ); 2520 } 2521 2522 bool SvxMenuConfigPage::DeleteSelectedContent() 2523 { 2524 SvLBoxEntry *pActEntry = aContentsListBox->FirstSelected(); 2525 2526 if ( pActEntry != NULL ) 2527 { 2528 // get currently selected menu entry 2529 SvxConfigEntry* pMenuEntry = 2530 (SvxConfigEntry*) pActEntry->GetUserData(); 2531 2532 // get currently selected menu 2533 SvxConfigEntry* pMenu = GetTopLevelSelection(); 2534 2535 // remove menu entry from the list for this menu 2536 RemoveEntry( pMenu->GetEntries(), pMenuEntry ); 2537 2538 // remove menu entry from UI 2539 aContentsListBox->GetModel()->Remove( pActEntry ); 2540 2541 // if this is a submenu entry, redraw the menus list box 2542 if ( pMenuEntry->IsPopup() ) 2543 { 2544 ReloadTopLevelListBox(); 2545 } 2546 2547 // delete data for menu entry 2548 delete pMenuEntry; 2549 2550 GetSaveInData()->SetModified( sal_True ); 2551 2552 return sal_True; 2553 } 2554 return sal_False; 2555 } 2556 2557 short SvxMenuConfigPage::QueryReset() 2558 { 2559 String msg = 2560 String( CUI_RES( RID_SVXSTR_CONFIRM_MENU_RESET ) ); 2561 2562 String saveInName = aSaveInListBox.GetEntry( 2563 aSaveInListBox.GetSelectEntryPos() ); 2564 2565 OUString label = replaceSaveInName( msg, saveInName ); 2566 2567 QueryBox qbox( this, WB_YES_NO, label ); 2568 2569 return qbox.Execute(); 2570 } 2571 2572 IMPL_LINK( SvxMenuConfigPage, SelectMenu, ListBox *, pBox ) 2573 { 2574 (void)pBox; 2575 2576 aContentsListBox->Clear(); 2577 2578 SvxConfigEntry* pMenuData = GetTopLevelSelection(); 2579 2580 PopupMenu* pPopup = aModifyTopLevelButton.GetPopupMenu(); 2581 if ( pMenuData ) 2582 { 2583 pPopup->EnableItem( ID_DELETE, pMenuData->IsDeletable() ); 2584 pPopup->EnableItem( ID_RENAME, pMenuData->IsRenamable() ); 2585 pPopup->EnableItem( ID_MOVE, pMenuData->IsMovable() ); 2586 2587 SvxEntries* pEntries = pMenuData->GetEntries(); 2588 SvxEntries::const_iterator iter = pEntries->begin(); 2589 2590 for ( ; iter != pEntries->end(); iter++ ) 2591 { 2592 SvxConfigEntry* pEntry = *iter; 2593 InsertEntryIntoUI( pEntry ); 2594 } 2595 } 2596 2597 UpdateButtonStates(); 2598 2599 return 0; 2600 } 2601 2602 IMPL_LINK( SvxMenuConfigPage, MenuSelectHdl, MenuButton *, pButton ) 2603 { 2604 switch( pButton->GetCurItemId() ) 2605 { 2606 case ID_DELETE: 2607 { 2608 DeleteSelectedTopLevel(); 2609 break; 2610 } 2611 case ID_RENAME: 2612 { 2613 SvxConfigEntry* pMenuData = GetTopLevelSelection(); 2614 2615 String aNewName( stripHotKey( pMenuData->GetName() ) ); 2616 String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME ); 2617 2618 SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc ); 2619 pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_MENU ); 2620 pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_MENU ) ); 2621 2622 bool ret = pNameDialog->Execute(); 2623 2624 if ( ret == RET_OK ) { 2625 pNameDialog->GetName( aNewName ); 2626 pMenuData->SetName( aNewName ); 2627 2628 ReloadTopLevelListBox(); 2629 2630 GetSaveInData()->SetModified( sal_True ); 2631 } 2632 2633 // #i68101# Moemory leak (!) 2634 delete pNameDialog; 2635 2636 break; 2637 } 2638 case ID_MOVE: 2639 { 2640 SvxConfigEntry* pMenuData = GetTopLevelSelection(); 2641 2642 SvxMainMenuOrganizerDialog* pDialog = 2643 new SvxMainMenuOrganizerDialog( this, 2644 GetSaveInData()->GetEntries(), pMenuData ); 2645 2646 bool ret = pDialog->Execute(); 2647 2648 if ( ret == RET_OK ) 2649 { 2650 GetSaveInData()->SetEntries( pDialog->GetEntries() ); 2651 2652 ReloadTopLevelListBox( pDialog->GetSelectedEntry() ); 2653 2654 GetSaveInData()->SetModified( sal_True ); 2655 } 2656 2657 delete pDialog; 2658 2659 break; 2660 } 2661 default: 2662 return sal_False; 2663 } 2664 return sal_True; 2665 } 2666 2667 IMPL_LINK( SvxMenuConfigPage, EntrySelectHdl, MenuButton *, pButton ) 2668 { 2669 switch( pButton->GetCurItemId() ) 2670 { 2671 case ID_ADD_SUBMENU: 2672 { 2673 String aNewName; 2674 String aDesc = CUI_RESSSTR( RID_SVXSTR_SUBMENU_NAME ); 2675 2676 SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc ); 2677 pNameDialog->SetHelpId( HID_SVX_CONFIG_NAME_SUBMENU ); 2678 pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_ADD_SUBMENU ) ); 2679 2680 bool ret = pNameDialog->Execute(); 2681 2682 if ( ret == RET_OK ) { 2683 pNameDialog->GetName(aNewName); 2684 2685 SvxConfigEntry* pNewEntryData = 2686 new SvxConfigEntry( aNewName, aNewName, sal_True ); 2687 pNewEntryData->SetUserDefined( sal_True ); 2688 2689 InsertEntry( pNewEntryData ); 2690 2691 ReloadTopLevelListBox(); 2692 2693 GetSaveInData()->SetModified( sal_True ); 2694 } 2695 2696 delete pNameDialog; 2697 2698 break; 2699 } 2700 case ID_BEGIN_GROUP: 2701 { 2702 SvxConfigEntry* pNewEntryData = new SvxConfigEntry; 2703 pNewEntryData->SetUserDefined( sal_True ); 2704 InsertEntry( pNewEntryData ); 2705 2706 break; 2707 } 2708 case ID_DELETE: 2709 { 2710 DeleteSelectedContent(); 2711 break; 2712 } 2713 case ID_RENAME: 2714 { 2715 SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry(); 2716 SvxConfigEntry* pEntry = 2717 (SvxConfigEntry*) pActEntry->GetUserData(); 2718 2719 String aNewName( stripHotKey( pEntry->GetName() ) ); 2720 String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME ); 2721 2722 SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc ); 2723 pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_MENU_ITEM ); 2724 pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_MENU ) ); 2725 2726 bool ret = pNameDialog->Execute(); 2727 2728 if ( ret == RET_OK ) { 2729 pNameDialog->GetName(aNewName); 2730 2731 pEntry->SetName( aNewName ); 2732 aContentsListBox->SetEntryText( pActEntry, aNewName ); 2733 2734 GetSaveInData()->SetModified( sal_True ); 2735 } 2736 2737 delete pNameDialog; 2738 2739 break; 2740 } 2741 default: 2742 { 2743 return sal_False; 2744 } 2745 } 2746 2747 if ( GetSaveInData()->IsModified() ) 2748 { 2749 UpdateButtonStates(); 2750 } 2751 2752 return sal_True; 2753 } 2754 2755 IMPL_LINK( SvxMenuConfigPage, AddFunctionHdl, 2756 SvxScriptSelectorDialog *, pDialog ) 2757 { 2758 (void)pDialog; 2759 2760 AddFunction(); 2761 2762 return 0; 2763 } 2764 2765 IMPL_LINK( SvxMenuConfigPage, NewMenuHdl, Button *, pButton ) 2766 { 2767 (void)pButton; 2768 2769 SvxMainMenuOrganizerDialog* pDialog = 2770 new SvxMainMenuOrganizerDialog( 0, 2771 GetSaveInData()->GetEntries(), NULL, sal_True ); 2772 2773 bool ret = pDialog->Execute(); 2774 2775 if ( ret == RET_OK ) 2776 { 2777 GetSaveInData()->SetEntries( pDialog->GetEntries() ); 2778 ReloadTopLevelListBox( pDialog->GetSelectedEntry() ); 2779 GetSaveInData()->SetModified( sal_True ); 2780 } 2781 2782 delete pDialog; 2783 2784 return 0; 2785 } 2786 2787 IMPL_LINK( SvxMenuConfigPage, AddCommandsHdl, Button *, pButton ) 2788 { 2789 (void)pButton; 2790 2791 if ( pSelectorDlg == NULL ) 2792 { 2793 // Create Script Selector which also shows builtin commands 2794 pSelectorDlg = new SvxScriptSelectorDialog( this, sal_True, m_xFrame ); 2795 2796 pSelectorDlg->SetAddHdl( 2797 LINK( this, SvxMenuConfigPage, AddFunctionHdl ) ); 2798 2799 pSelectorDlg->SetDialogDescription( String( 2800 CUI_RES( RID_SVXSTR_MENU_ADDCOMMANDS_DESCRIPTION ) ) ); 2801 } 2802 2803 // Position the Script Selector over the Add button so it is 2804 // beside the menu contents list and does not obscure it 2805 pSelectorDlg->SetPosPixel( aAddCommandsButton.GetPosPixel() ); 2806 2807 pSelectorDlg->SetImageProvider( 2808 static_cast< ImageProvider* >( GetSaveInData() ) ); 2809 2810 pSelectorDlg->Show(); 2811 return 1; 2812 } 2813 2814 SaveInData* SvxMenuConfigPage::CreateSaveInData( 2815 const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr, 2816 const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr, 2817 const OUString& aModuleId, 2818 bool bDocConfig ) 2819 { 2820 return static_cast< SaveInData* >( 2821 new MenuSaveInData( xCfgMgr, xParentCfgMgr, aModuleId, bDocConfig )); 2822 } 2823 2824 SvxMainMenuOrganizerDialog::SvxMainMenuOrganizerDialog( 2825 Window* pParent, SvxEntries* entries, 2826 SvxConfigEntry* selection, bool bCreateMenu ) 2827 : 2828 ModalDialog( pParent, CUI_RES( MD_MENU_ORGANISER ) ), 2829 aMenuNameText( this, CUI_RES( TXT_MENU_NAME ) ), 2830 aMenuNameEdit( this, CUI_RES( EDIT_MENU_NAME ) ), 2831 aMenuListText( this, CUI_RES( TXT_MENU ) ), 2832 aMenuListBox( this, CUI_RES( BOX_MAIN_MENUS ) ), 2833 aMoveUpButton( this, CUI_RES( BTN_MENU_UP ) ), 2834 aMoveDownButton( this, CUI_RES( BTN_MENU_DOWN ) ), 2835 aOKButton( this, CUI_RES( BTN_MENU_ADD ) ), 2836 aCloseButton( this, CUI_RES( BTN_MENU_CLOSE ) ), 2837 aHelpButton( this, CUI_RES( BTN_MENU_HELP ) ), 2838 bModified( sal_False ) 2839 { 2840 FreeResource(); 2841 2842 // Copy the entries list passed in 2843 if ( entries != NULL ) 2844 { 2845 SvxConfigEntry* pEntry; 2846 SvLBoxEntry* pLBEntry; 2847 2848 pEntries = new SvxEntries(); 2849 SvxEntries::const_iterator iter = entries->begin(); 2850 2851 while ( iter != entries->end() ) 2852 { 2853 pEntry = *iter; 2854 pLBEntry = 2855 aMenuListBox.InsertEntry( stripHotKey( pEntry->GetName() ) ); 2856 pLBEntry->SetUserData( pEntry ); 2857 pEntries->push_back( pEntry ); 2858 2859 if ( pEntry == selection ) 2860 { 2861 aMenuListBox.Select( pLBEntry ); 2862 } 2863 iter++; 2864 } 2865 } 2866 2867 if ( bCreateMenu ) 2868 { 2869 // Generate custom name for new menu 2870 String prefix = 2871 String( CUI_RES( RID_SVXSTR_NEW_MENU ) ); 2872 2873 OUString newname = generateCustomName( prefix, entries ); 2874 OUString newurl = generateCustomMenuURL( pEntries ); 2875 2876 SvxConfigEntry* pNewEntryData = 2877 new SvxConfigEntry( newname, newurl, sal_True ); 2878 pNewEntryData->SetUserDefined( sal_True ); 2879 pNewEntryData->SetMain( sal_True ); 2880 2881 pNewMenuEntry = 2882 aMenuListBox.InsertEntry( stripHotKey( pNewEntryData->GetName() ) ); 2883 aMenuListBox.Select( pNewMenuEntry ); 2884 2885 pNewMenuEntry->SetUserData( pNewEntryData ); 2886 2887 pEntries->push_back( pNewEntryData ); 2888 2889 aMenuNameEdit.SetText( newname ); 2890 aMenuNameEdit.SetModifyHdl( 2891 LINK( this, SvxMainMenuOrganizerDialog, ModifyHdl ) ); 2892 } 2893 else 2894 { 2895 Point p, newp; 2896 Size s, news; 2897 2898 // get offset to bottom of name textfield from top of dialog 2899 p = aMenuNameEdit.GetPosPixel(); 2900 s = aMenuNameEdit.GetSizePixel(); 2901 long offset = p.Y() + s.Height(); 2902 2903 // reposition menu list and label 2904 aMenuListText.SetPosPixel( aMenuNameText.GetPosPixel() ); 2905 aMenuListBox.SetPosPixel( aMenuNameEdit.GetPosPixel() ); 2906 2907 // reposition up and down buttons 2908 p = aMoveUpButton.GetPosPixel(); 2909 newp = Point( p.X(), p.Y() - offset ); 2910 aMoveUpButton.SetPosPixel( newp ); 2911 2912 p = aMoveDownButton.GetPosPixel(); 2913 newp = Point( p.X(), p.Y() - offset ); 2914 aMoveDownButton.SetPosPixel( newp ); 2915 2916 // change size of dialog 2917 s = GetSizePixel(); 2918 news = Size( s.Width(), s.Height() - offset ); 2919 SetSizePixel( news ); 2920 2921 // hide name label and textfield 2922 aMenuNameText.Hide(); 2923 aMenuNameEdit.Hide(); 2924 2925 // change the title 2926 SetText( CUI_RES( RID_SVXSTR_MOVE_MENU ) ); 2927 } 2928 2929 aMenuListBox.SetSelectHdl( 2930 LINK( this, SvxMainMenuOrganizerDialog, SelectHdl ) ); 2931 2932 aMoveUpButton.SetClickHdl ( 2933 LINK( this, SvxMainMenuOrganizerDialog, MoveHdl) ); 2934 aMoveDownButton.SetClickHdl ( 2935 LINK( this, SvxMainMenuOrganizerDialog, MoveHdl) ); 2936 2937 aMoveUpButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_UP))); 2938 aMoveDownButton.SetAccessibleName(String(CUI_RES(BUTTON_STR_DOWN))); 2939 } 2940 2941 IMPL_LINK(SvxMainMenuOrganizerDialog, ModifyHdl, Edit*, pEdit) 2942 { 2943 (void)pEdit; 2944 2945 // if the Edit control is empty do not change the name 2946 if ( aMenuNameEdit.GetText().Equals( String() ) ) 2947 { 2948 return 0; 2949 } 2950 2951 SvxConfigEntry* pNewEntryData = 2952 (SvxConfigEntry*) pNewMenuEntry->GetUserData(); 2953 2954 pNewEntryData->SetName( aMenuNameEdit.GetText() ); 2955 2956 aMenuListBox.SetEntryText( pNewMenuEntry, pNewEntryData->GetName() ); 2957 2958 return 0; 2959 } 2960 2961 SvxMainMenuOrganizerDialog::~SvxMainMenuOrganizerDialog() 2962 { 2963 } 2964 2965 IMPL_LINK( SvxMainMenuOrganizerDialog, SelectHdl, Control*, pCtrl ) 2966 { 2967 (void)pCtrl; 2968 UpdateButtonStates(); 2969 return 1; 2970 } 2971 2972 void SvxMainMenuOrganizerDialog::UpdateButtonStates() 2973 { 2974 // Disable Up and Down buttons depending on current selection 2975 SvLBoxEntry* selection = aMenuListBox.GetCurEntry(); 2976 SvLBoxEntry* first = aMenuListBox.First(); 2977 SvLBoxEntry* last = aMenuListBox.Last(); 2978 2979 aMoveUpButton.Enable( selection != first ); 2980 aMoveDownButton.Enable( selection != last ); 2981 } 2982 2983 IMPL_LINK( SvxMainMenuOrganizerDialog, MoveHdl, Button *, pButton ) 2984 { 2985 SvLBoxEntry *pSourceEntry = aMenuListBox.FirstSelected(); 2986 SvLBoxEntry *pTargetEntry = NULL; 2987 2988 if ( !pSourceEntry ) 2989 { 2990 return 0; 2991 } 2992 2993 if ( pButton == &aMoveDownButton ) 2994 { 2995 pTargetEntry = aMenuListBox.NextSibling( pSourceEntry ); 2996 } 2997 else if ( pButton == &aMoveUpButton ) 2998 { 2999 // Move Up is just a Move Down with the source and target reversed 3000 pTargetEntry = pSourceEntry; 3001 pSourceEntry = aMenuListBox.PrevSibling( pTargetEntry ); 3002 } 3003 3004 if ( pSourceEntry != NULL && pTargetEntry != NULL ) 3005 { 3006 SvxConfigEntry* pSourceData = 3007 (SvxConfigEntry*) pSourceEntry->GetUserData(); 3008 SvxConfigEntry* pTargetData = 3009 (SvxConfigEntry*) pTargetEntry->GetUserData(); 3010 3011 SvxEntries::iterator iter1 = GetEntries()->begin(); 3012 SvxEntries::iterator iter2 = GetEntries()->begin(); 3013 SvxEntries::const_iterator end = GetEntries()->end(); 3014 3015 // Advance the iterators to the positions of the source and target 3016 while (*iter1 != pSourceData && ++iter1 != end) ; 3017 while (*iter2 != pTargetData && ++iter2 != end) ; 3018 3019 // Now swap the entries in the menu list and in the UI 3020 if ( iter1 != end && iter2 != end ) 3021 { 3022 std::swap( *iter1, *iter2 ); 3023 aMenuListBox.GetModel()->Move( pSourceEntry, pTargetEntry ); 3024 aMenuListBox.MakeVisible( pSourceEntry ); 3025 3026 bModified = sal_True; 3027 } 3028 } 3029 3030 if ( bModified ) 3031 { 3032 UpdateButtonStates(); 3033 } 3034 3035 return 0; 3036 } 3037 3038 SvxEntries* SvxMainMenuOrganizerDialog::GetEntries() 3039 { 3040 return pEntries; 3041 } 3042 3043 SvxConfigEntry* SvxMainMenuOrganizerDialog::GetSelectedEntry() 3044 { 3045 return (SvxConfigEntry*)aMenuListBox.FirstSelected()->GetUserData(); 3046 } 3047 3048 const OUString& 3049 SvxConfigEntry::GetHelpText() 3050 { 3051 if ( aHelpText.getLength() == 0 ) 3052 { 3053 if ( aCommand.getLength() ) 3054 { 3055 aHelpText = Application::GetHelp()->GetHelpText( aCommand, NULL ); 3056 } 3057 } 3058 3059 return aHelpText; 3060 } 3061 3062 SvxConfigEntry::SvxConfigEntry( const OUString& rDisplayName, 3063 const OUString& rCommandURL, bool bPopup, bool bParentData ) 3064 : nId( 1 ) 3065 , aLabel(rDisplayName) 3066 , aCommand(rCommandURL) 3067 , bPopUp(bPopup) 3068 , bStrEdited( sal_False ) 3069 , bIsUserDefined( sal_False ) 3070 , bIsMain( sal_False ) 3071 , bIsParentData( bParentData ) 3072 , bIsVisible( sal_True ) 3073 , nStyle( 0 ) 3074 , pEntries( 0 ) 3075 { 3076 if (bPopUp) 3077 { 3078 pEntries = new SvxEntries(); 3079 } 3080 } 3081 3082 SvxConfigEntry::~SvxConfigEntry() 3083 { 3084 if ( pEntries != NULL ) 3085 { 3086 SvxEntries::const_iterator iter = pEntries->begin(); 3087 3088 for ( ; iter != pEntries->end(); iter++ ) 3089 { 3090 delete *iter; 3091 } 3092 delete pEntries; 3093 } 3094 } 3095 3096 bool SvxConfigEntry::IsMovable() 3097 { 3098 if ( IsPopup() && !IsMain() ) 3099 { 3100 return sal_False; 3101 } 3102 return sal_True; 3103 } 3104 3105 bool SvxConfigEntry::IsDeletable() 3106 { 3107 if ( IsMain() && !IsUserDefined() ) 3108 { 3109 return sal_False; 3110 } 3111 return sal_True; 3112 } 3113 3114 bool SvxConfigEntry::IsRenamable() 3115 { 3116 if ( IsMain() && !IsUserDefined() ) 3117 { 3118 return sal_False; 3119 } 3120 return sal_True; 3121 } 3122 3123 SvxToolbarConfigPage::SvxToolbarConfigPage( 3124 Window *pParent, const SfxItemSet& rSet ) 3125 : 3126 SvxConfigPage( pParent, rSet ) 3127 { 3128 SetHelpId( HID_SVX_CONFIG_TOOLBAR ); 3129 3130 aContentsListBox = new SvxToolbarEntriesListBox(this, CUI_RES(BOX_ENTRIES)); 3131 FreeResource(); 3132 PositionContentsListBox(); 3133 aContentsListBox->SetZOrder( &aAddCommandsButton, WINDOW_ZORDER_BEFOR ); 3134 3135 aContentsListBox->SetHelpId( HID_SVX_CONFIG_TOOLBAR_CONTENTS ); 3136 aNewTopLevelButton.SetHelpId( HID_SVX_NEW_TOOLBAR ); 3137 aModifyTopLevelButton.SetHelpId( HID_SVX_MODIFY_TOOLBAR ); 3138 aAddCommandsButton.SetHelpId( HID_SVX_NEW_TOOLBAR_ITEM ); 3139 aModifyCommandButton.SetHelpId( HID_SVX_MODIFY_TOOLBAR_ITEM ); 3140 aSaveInListBox.SetHelpId( HID_SVX_SAVE_IN ); 3141 3142 aTopLevelSeparator.SetText( 3143 CUI_RES ( RID_SVXSTR_PRODUCTNAME_TOOLBARS ) ); 3144 3145 aTopLevelLabel.SetText( CUI_RES( RID_SVXSTR_TOOLBAR ) ); 3146 aModifyTopLevelButton.SetText( CUI_RES( RID_SVXSTR_TOOLBAR ) ); 3147 aContentsSeparator.SetText( CUI_RES( RID_SVXSTR_TOOLBAR_CONTENT ) ); 3148 aContentsLabel.SetText( CUI_RES( RID_SVXSTR_COMMANDS ) ); 3149 3150 aTopLevelListBox.SetSelectHdl( 3151 LINK( this, SvxToolbarConfigPage, SelectToolbar ) ); 3152 aContentsListBox->SetSelectHdl( 3153 LINK( this, SvxToolbarConfigPage, SelectToolbarEntry ) ); 3154 3155 aNewTopLevelButton.SetClickHdl ( 3156 LINK( this, SvxToolbarConfigPage, NewToolbarHdl ) ); 3157 3158 aAddCommandsButton.SetClickHdl ( 3159 LINK( this, SvxToolbarConfigPage, AddCommandsHdl ) ); 3160 3161 aMoveUpButton.SetClickHdl ( LINK( this, SvxToolbarConfigPage, MoveHdl) ); 3162 aMoveDownButton.SetClickHdl ( LINK( this, SvxToolbarConfigPage, MoveHdl) ); 3163 // Always enable Up and Down buttons 3164 // added for issue i53677 by shizhoubo 3165 aMoveDownButton.Enable( sal_True ); 3166 aMoveUpButton.Enable( sal_True ); 3167 3168 PopupMenu* pMenu = new PopupMenu( CUI_RES( MODIFY_TOOLBAR ) ); 3169 pMenu->SetMenuFlags( 3170 pMenu->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ); 3171 3172 aModifyTopLevelButton.SetPopupMenu( pMenu ); 3173 aModifyTopLevelButton.SetSelectHdl( 3174 LINK( this, SvxToolbarConfigPage, ToolbarSelectHdl ) ); 3175 3176 PopupMenu* pEntry = new PopupMenu( 3177 CUI_RES( MODIFY_TOOLBAR_CONTENT ) ); 3178 pEntry->SetMenuFlags( 3179 pEntry->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ); 3180 3181 aModifyCommandButton.SetPopupMenu( pEntry ); 3182 aModifyCommandButton.SetSelectHdl( 3183 LINK( this, SvxToolbarConfigPage, EntrySelectHdl ) ); 3184 3185 // default toolbar to select is standardbar unless a different one 3186 // has been passed in 3187 m_aURLToSelect = OUString::createFromAscii( ITEM_TOOLBAR_URL ); 3188 m_aURLToSelect += OUString::createFromAscii( "standardbar" ); 3189 3190 const SfxPoolItem* pItem = 3191 rSet.GetItem( rSet.GetPool()->GetWhich( SID_CONFIG ) ); 3192 3193 if ( pItem ) 3194 { 3195 OUString text = ((const SfxStringItem*)pItem)->GetValue(); 3196 if (text.indexOf(OUString::createFromAscii(ITEM_TOOLBAR_URL)) == 0) 3197 { 3198 m_aURLToSelect = text.copy( 0 ); 3199 } 3200 } 3201 3202 long nTxtW = aTopLevelLabel.GetCtrlTextWidth( aTopLevelLabel.GetText() ); 3203 long nCtrlW = aTopLevelLabel.GetSizePixel().Width(); 3204 if ( nTxtW >= nCtrlW ) 3205 { 3206 long nDelta = Max( (long)10, nTxtW - nCtrlW ); 3207 Size aNewSz = aTopLevelLabel.GetSizePixel(); 3208 aNewSz.Width() += nDelta; 3209 aTopLevelLabel.SetSizePixel( aNewSz ); 3210 aNewSz = aTopLevelListBox.GetSizePixel(); 3211 aNewSz.Width() -= nDelta; 3212 Point aNewPt = aTopLevelListBox.GetPosPixel(); 3213 aNewPt.X() += nDelta; 3214 aTopLevelListBox.SetPosSizePixel( aNewPt, aNewSz ); 3215 } 3216 } 3217 3218 SvxToolbarConfigPage::~SvxToolbarConfigPage() 3219 { 3220 for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ ) 3221 { 3222 ToolbarSaveInData* pData = 3223 (ToolbarSaveInData*) aSaveInListBox.GetEntryData( i ); 3224 3225 delete pData; 3226 } 3227 3228 if ( pSelectorDlg != NULL ) 3229 { 3230 delete pSelectorDlg; 3231 } 3232 3233 3234 delete aContentsListBox; 3235 } 3236 3237 void SvxToolbarConfigPage::DeleteSelectedTopLevel() 3238 { 3239 sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos(); 3240 ToolbarSaveInData* pSaveInData = (ToolbarSaveInData*) GetSaveInData(); 3241 pSaveInData->RemoveToolbar( GetTopLevelSelection() ); 3242 3243 if ( aTopLevelListBox.GetEntryCount() > 1 ) 3244 { 3245 // select next entry after the one being deleted 3246 // selection position is indexed from 0 so need to 3247 // subtract one from the entry count 3248 if ( nSelectionPos != aTopLevelListBox.GetEntryCount() - 1 ) 3249 { 3250 aTopLevelListBox.SelectEntryPos( nSelectionPos + 1, sal_True ); 3251 } 3252 else 3253 { 3254 aTopLevelListBox.SelectEntryPos( nSelectionPos - 1, sal_True ); 3255 } 3256 aTopLevelListBox.GetSelectHdl().Call( this ); 3257 3258 // and now remove the entry 3259 aTopLevelListBox.RemoveEntry( nSelectionPos ); 3260 } 3261 else 3262 { 3263 ReloadTopLevelListBox(); 3264 } 3265 } 3266 3267 bool SvxToolbarConfigPage::DeleteSelectedContent() 3268 { 3269 SvLBoxEntry *pActEntry = aContentsListBox->FirstSelected(); 3270 3271 if ( pActEntry != NULL ) 3272 { 3273 // get currently selected entry 3274 SvxConfigEntry* pEntry = 3275 (SvxConfigEntry*) pActEntry->GetUserData(); 3276 3277 SvxConfigEntry* pToolbar = GetTopLevelSelection(); 3278 3279 // remove entry from the list for this toolbar 3280 RemoveEntry( pToolbar->GetEntries(), pEntry ); 3281 3282 // remove toolbar entry from UI 3283 aContentsListBox->GetModel()->Remove( pActEntry ); 3284 3285 // delete data for toolbar entry 3286 delete pEntry; 3287 3288 (( ToolbarSaveInData* ) GetSaveInData())->ApplyToolbar( pToolbar ); 3289 UpdateButtonStates(); 3290 3291 // if this is the last entry in the toolbar and it is a user 3292 // defined toolbar pop up a dialog asking the user if they 3293 // want to delete the toolbar 3294 if ( aContentsListBox->GetEntryCount() == 0 && 3295 GetTopLevelSelection()->IsDeletable() ) 3296 { 3297 QueryBox qbox( this, 3298 CUI_RES( QBX_CONFIRM_DELETE_TOOLBAR ) ); 3299 3300 if ( qbox.Execute() == RET_YES ) 3301 { 3302 DeleteSelectedTopLevel(); 3303 } 3304 } 3305 3306 return sal_True; 3307 } 3308 3309 return sal_False; 3310 } 3311 3312 IMPL_LINK( SvxToolbarConfigPage, MoveHdl, Button *, pButton ) 3313 { 3314 MoveEntry( pButton == &aMoveUpButton ); 3315 return 0; 3316 } 3317 3318 void SvxToolbarConfigPage::MoveEntry( bool bMoveUp ) 3319 { 3320 SvxConfigPage::MoveEntry( bMoveUp ); 3321 3322 // Apply change to currently selected toolbar 3323 SvxConfigEntry* pToolbar = GetTopLevelSelection(); 3324 if ( pToolbar ) 3325 ((ToolbarSaveInData*)GetSaveInData())->ApplyToolbar( pToolbar ); 3326 else 3327 { 3328 DBG_ERRORFILE( "SvxToolbarConfigPage::MoveEntry(): no entry" ); 3329 UpdateButtonStates(); 3330 } 3331 } 3332 3333 IMPL_LINK( SvxToolbarConfigPage, ToolbarSelectHdl, MenuButton *, pButton ) 3334 { 3335 sal_uInt16 nSelectionPos = aTopLevelListBox.GetSelectEntryPos(); 3336 3337 SvxConfigEntry* pToolbar = 3338 (SvxConfigEntry*)aTopLevelListBox.GetEntryData( nSelectionPos ); 3339 3340 ToolbarSaveInData* pSaveInData = (ToolbarSaveInData*) GetSaveInData(); 3341 3342 switch( pButton->GetCurItemId() ) 3343 { 3344 case ID_DELETE: 3345 { 3346 DeleteSelectedTopLevel(); 3347 UpdateButtonStates(); 3348 break; 3349 } 3350 case ID_RENAME: 3351 { 3352 String aNewName( stripHotKey( pToolbar->GetName() ) ); 3353 String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME ); 3354 3355 SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc ); 3356 pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_TOOLBAR ); 3357 pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_TOOLBAR ) ); 3358 3359 bool ret = pNameDialog->Execute(); 3360 3361 if ( ret == RET_OK ) 3362 { 3363 pNameDialog->GetName(aNewName); 3364 3365 pToolbar->SetName( aNewName ); 3366 pSaveInData->ApplyToolbar( pToolbar ); 3367 3368 // have to use remove and insert to change the name 3369 aTopLevelListBox.RemoveEntry( nSelectionPos ); 3370 nSelectionPos = 3371 aTopLevelListBox.InsertEntry( aNewName, nSelectionPos ); 3372 aTopLevelListBox.SetEntryData( nSelectionPos, pToolbar ); 3373 aTopLevelListBox.SelectEntryPos( nSelectionPos ); 3374 } 3375 3376 delete pNameDialog; 3377 3378 break; 3379 } 3380 case ID_DEFAULT_STYLE: 3381 { 3382 QueryBox qbox( this, 3383 CUI_RES( QBX_CONFIRM_RESTORE_DEFAULT ) ); 3384 3385 if ( qbox.Execute() == RET_YES ) 3386 { 3387 ToolbarSaveInData* pSaveInData_ = 3388 (ToolbarSaveInData*) GetSaveInData(); 3389 3390 pSaveInData_->RestoreToolbar( pToolbar ); 3391 3392 aTopLevelListBox.GetSelectHdl().Call( this ); 3393 } 3394 3395 break; 3396 } 3397 case ID_ICONS_ONLY: 3398 { 3399 pToolbar->SetStyle( 0 ); 3400 pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 0 ); 3401 3402 aTopLevelListBox.GetSelectHdl().Call( this ); 3403 3404 break; 3405 } 3406 case ID_TEXT_ONLY: 3407 { 3408 pToolbar->SetStyle( 1 ); 3409 pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 1 ); 3410 3411 aTopLevelListBox.GetSelectHdl().Call( this ); 3412 3413 break; 3414 } 3415 case ID_ICONS_AND_TEXT: 3416 { 3417 pToolbar->SetStyle( 2 ); 3418 pSaveInData->SetSystemStyle( m_xFrame, pToolbar->GetCommand(), 2 ); 3419 3420 aTopLevelListBox.GetSelectHdl().Call( this ); 3421 3422 break; 3423 } 3424 } 3425 return 1; 3426 } 3427 3428 IMPL_LINK( SvxToolbarConfigPage, EntrySelectHdl, MenuButton *, pButton ) 3429 { 3430 bool bNeedsApply = sal_False; 3431 3432 // get currently selected toolbar 3433 SvxConfigEntry* pToolbar = GetTopLevelSelection(); 3434 3435 switch( pButton->GetCurItemId() ) 3436 { 3437 case ID_RENAME: 3438 { 3439 SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry(); 3440 SvxConfigEntry* pEntry = 3441 (SvxConfigEntry*) pActEntry->GetUserData(); 3442 3443 String aNewName( stripHotKey( pEntry->GetName() ) ); 3444 String aDesc = CUI_RESSSTR( RID_SVXSTR_LABEL_NEW_NAME ); 3445 3446 SvxNameDialog* pNameDialog = new SvxNameDialog( this, aNewName, aDesc ); 3447 pNameDialog->SetHelpId( HID_SVX_CONFIG_RENAME_TOOLBAR_ITEM ); 3448 pNameDialog->SetText( CUI_RESSTR( RID_SVXSTR_RENAME_TOOLBAR ) ); 3449 3450 bool ret = pNameDialog->Execute(); 3451 3452 if ( ret == RET_OK ) { 3453 pNameDialog->GetName(aNewName); 3454 3455 pEntry->SetName( aNewName ); 3456 aContentsListBox->SetEntryText( pActEntry, aNewName ); 3457 3458 bNeedsApply = sal_True; 3459 } 3460 3461 delete pNameDialog; 3462 break; 3463 } 3464 case ID_DEFAULT_COMMAND: 3465 { 3466 SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry(); 3467 SvxConfigEntry* pEntry = 3468 (SvxConfigEntry*) pActEntry->GetUserData(); 3469 3470 sal_uInt16 nSelectionPos = 0; 3471 3472 // find position of entry within the list 3473 for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ ) 3474 { 3475 if ( aContentsListBox->GetEntry( 0, i ) == pActEntry ) 3476 { 3477 nSelectionPos = i; 3478 break; 3479 } 3480 } 3481 3482 ToolbarSaveInData* pSaveInData = 3483 (ToolbarSaveInData*) GetSaveInData(); 3484 3485 OUString aSystemName = 3486 pSaveInData->GetSystemUIName( pEntry->GetCommand() ); 3487 3488 if ( !pEntry->GetName().equals( aSystemName ) ) 3489 { 3490 pEntry->SetName( aSystemName ); 3491 aContentsListBox->SetEntryText( 3492 pActEntry, stripHotKey( aSystemName ) ); 3493 bNeedsApply = sal_True; 3494 } 3495 3496 uno::Sequence< OUString > aURLSeq( 1 ); 3497 aURLSeq[ 0 ] = pEntry->GetCommand(); 3498 3499 try 3500 { 3501 GetSaveInData()->GetImageManager()->removeImages( 3502 GetImageType(), aURLSeq ); 3503 3504 // reset backup in entry 3505 pEntry->SetBackupGraphic( 3506 uno::Reference< graphic::XGraphic >() ); 3507 3508 GetSaveInData()->PersistChanges( 3509 GetSaveInData()->GetImageManager() ); 3510 3511 aContentsListBox->GetModel()->Remove( pActEntry ); 3512 3513 SvLBoxEntry* pNewLBEntry = 3514 InsertEntryIntoUI( pEntry, nSelectionPos ); 3515 3516 aContentsListBox->SetCheckButtonState( pNewLBEntry, 3517 pEntry->IsVisible() ? 3518 SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); 3519 3520 aContentsListBox->Select( pNewLBEntry ); 3521 aContentsListBox->MakeVisible( pNewLBEntry ); 3522 3523 bNeedsApply = sal_True; 3524 } 3525 catch ( uno::Exception& ) 3526 { 3527 OSL_TRACE("Error restoring image"); 3528 } 3529 break; 3530 } 3531 case ID_BEGIN_GROUP: 3532 { 3533 SvxConfigEntry* pNewEntryData = new SvxConfigEntry; 3534 pNewEntryData->SetUserDefined( sal_True ); 3535 3536 SvLBoxEntry* pNewLBEntry = InsertEntry( pNewEntryData ); 3537 3538 aContentsListBox->SetCheckButtonState( 3539 pNewLBEntry, SV_BUTTON_TRISTATE ); 3540 3541 bNeedsApply = sal_True; 3542 break; 3543 } 3544 case ID_DELETE: 3545 { 3546 DeleteSelectedContent(); 3547 break; 3548 } 3549 case ID_ICON_ONLY: 3550 { 3551 break; 3552 } 3553 case ID_TEXT_ONLY: 3554 { 3555 break; 3556 } 3557 case ID_ICON_AND_TEXT: 3558 { 3559 break; 3560 } 3561 case ID_CHANGE_SYMBOL: 3562 { 3563 SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry(); 3564 SvxConfigEntry* pEntry = 3565 (SvxConfigEntry*) pActEntry->GetUserData(); 3566 3567 sal_uInt16 nSelectionPos = 0; 3568 3569 // find position of entry within the list 3570 for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ ) 3571 { 3572 if ( aContentsListBox->GetEntry( 0, i ) == pActEntry ) 3573 { 3574 nSelectionPos = i; 3575 break; 3576 } 3577 } 3578 3579 SvxIconSelectorDialog* pIconDialog = 3580 new SvxIconSelectorDialog( 0, 3581 GetSaveInData()->GetImageManager(), 3582 GetSaveInData()->GetParentImageManager() ); 3583 3584 bool ret = pIconDialog->Execute(); 3585 3586 if ( ret == RET_OK ) 3587 { 3588 uno::Reference< graphic::XGraphic > newgraphic = 3589 pIconDialog->GetSelectedIcon(); 3590 3591 if ( newgraphic.is() ) 3592 { 3593 uno::Sequence< uno::Reference< graphic::XGraphic > > 3594 aGraphicSeq( 1 ); 3595 3596 uno::Sequence< OUString > aURLSeq( 1 ); 3597 aURLSeq[ 0 ] = pEntry->GetCommand(); 3598 3599 if ( !pEntry->GetBackupGraphic().is() ) 3600 { 3601 uno::Reference< graphic::XGraphic > backup; 3602 backup = GetGraphic( 3603 GetSaveInData()->GetImageManager(), aURLSeq[ 0 ] ); 3604 3605 if ( backup.is() ) 3606 { 3607 pEntry->SetBackupGraphic( backup ); 3608 } 3609 } 3610 3611 aGraphicSeq[ 0 ] = newgraphic; 3612 try 3613 { 3614 GetSaveInData()->GetImageManager()->replaceImages( 3615 GetImageType(), aURLSeq, aGraphicSeq ); 3616 3617 Image aImage( newgraphic ); 3618 3619 aContentsListBox->GetModel()->Remove( pActEntry ); 3620 SvLBoxEntry* pNewLBEntry = 3621 InsertEntryIntoUI( pEntry, nSelectionPos ); 3622 3623 aContentsListBox->SetCheckButtonState( pNewLBEntry, 3624 pEntry->IsVisible() ? 3625 SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); 3626 3627 aContentsListBox->Select( pNewLBEntry ); 3628 aContentsListBox->MakeVisible( pNewLBEntry ); 3629 3630 GetSaveInData()->PersistChanges( 3631 GetSaveInData()->GetImageManager() ); 3632 } 3633 catch ( uno::Exception& ) 3634 { 3635 OSL_TRACE("Error replacing image"); 3636 } 3637 } 3638 } 3639 3640 delete pIconDialog; 3641 3642 break; 3643 } 3644 case ID_RESET_SYMBOL: 3645 { 3646 SvLBoxEntry* pActEntry = aContentsListBox->GetCurEntry(); 3647 SvxConfigEntry* pEntry = 3648 (SvxConfigEntry*) pActEntry->GetUserData(); 3649 3650 sal_uInt16 nSelectionPos = 0; 3651 3652 // find position of entry within the list 3653 for ( sal_uInt16 i = 0; i < aContentsListBox->GetEntryCount(); i++ ) 3654 { 3655 if ( aContentsListBox->GetEntry( 0, i ) == pActEntry ) 3656 { 3657 nSelectionPos = i; 3658 break; 3659 } 3660 } 3661 3662 uno::Reference< graphic::XGraphic > backup = 3663 pEntry->GetBackupGraphic(); 3664 3665 uno::Sequence< uno::Reference< graphic::XGraphic > > 3666 aGraphicSeq( 1 ); 3667 aGraphicSeq[ 0 ] = backup; 3668 3669 uno::Sequence< OUString > aURLSeq( 1 ); 3670 aURLSeq[ 0 ] = pEntry->GetCommand(); 3671 3672 try 3673 { 3674 GetSaveInData()->GetImageManager()->replaceImages( 3675 GetImageType(), aURLSeq, aGraphicSeq ); 3676 3677 Image aImage( backup ); 3678 aContentsListBox->GetModel()->Remove( pActEntry ); 3679 3680 SvLBoxEntry* pNewLBEntry = 3681 InsertEntryIntoUI( pEntry, nSelectionPos ); 3682 3683 aContentsListBox->SetCheckButtonState( pNewLBEntry, 3684 pEntry->IsVisible() ? 3685 SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); 3686 3687 aContentsListBox->Select( pNewLBEntry ); 3688 aContentsListBox->MakeVisible( pNewLBEntry ); 3689 3690 // reset backup in entry 3691 pEntry->SetBackupGraphic( 3692 uno::Reference< graphic::XGraphic >() ); 3693 3694 GetSaveInData()->PersistChanges( 3695 GetSaveInData()->GetImageManager() ); 3696 } 3697 catch ( uno::Exception& ) 3698 { 3699 OSL_TRACE("Error resetting image"); 3700 } 3701 break; 3702 } 3703 } 3704 3705 if ( bNeedsApply == sal_True ) 3706 { 3707 (( ToolbarSaveInData* ) GetSaveInData())->ApplyToolbar( pToolbar ); 3708 UpdateButtonStates(); 3709 } 3710 3711 return 1; 3712 } 3713 3714 void SvxToolbarConfigPage::Init() 3715 { 3716 // ensure that the UI is cleared before populating it 3717 aTopLevelListBox.Clear(); 3718 aContentsListBox->Clear(); 3719 3720 ReloadTopLevelListBox(); 3721 3722 sal_uInt16 nPos = 0; 3723 if ( m_aURLToSelect.getLength() != 0 ) 3724 { 3725 for ( sal_uInt16 i = 0 ; i < aTopLevelListBox.GetEntryCount(); i++ ) 3726 { 3727 SvxConfigEntry* pData = 3728 (SvxConfigEntry*) aTopLevelListBox.GetEntryData( i ); 3729 3730 if ( pData->GetCommand().equals( m_aURLToSelect ) ) 3731 { 3732 nPos = i; 3733 break; 3734 } 3735 } 3736 3737 // in future select the default toolbar: Standard 3738 m_aURLToSelect = OUString::createFromAscii( ITEM_TOOLBAR_URL ); 3739 m_aURLToSelect += OUString::createFromAscii( "standardbar" ); 3740 } 3741 3742 aTopLevelListBox.SelectEntryPos(nPos, sal_True); 3743 aTopLevelListBox.GetSelectHdl().Call(this); 3744 } 3745 3746 SaveInData* SvxToolbarConfigPage::CreateSaveInData( 3747 const uno::Reference< css::ui::XUIConfigurationManager >& xCfgMgr, 3748 const uno::Reference< css::ui::XUIConfigurationManager >& xParentCfgMgr, 3749 const OUString& aModuleId, 3750 bool bDocConfig ) 3751 { 3752 return static_cast< SaveInData* >( 3753 new ToolbarSaveInData( xCfgMgr, xParentCfgMgr, aModuleId, bDocConfig )); 3754 } 3755 3756 ToolbarSaveInData::ToolbarSaveInData( 3757 const uno::Reference < css::ui::XUIConfigurationManager >& xCfgMgr, 3758 const uno::Reference < css::ui::XUIConfigurationManager >& xParentCfgMgr, 3759 const OUString& aModuleId, 3760 bool docConfig ) : 3761 3762 SaveInData ( xCfgMgr, xParentCfgMgr, aModuleId, docConfig ), 3763 pRootEntry ( NULL ), 3764 m_aDescriptorContainer ( RTL_CONSTASCII_USTRINGPARAM( ITEM_DESCRIPTOR_CONTAINER ) ) 3765 3766 { 3767 // Initialize the m_xPersistentWindowState variable which is used 3768 // to get the default properties of system toolbars such as name 3769 uno::Reference< container::XNameAccess > xPWSS( 3770 m_xServiceManager->createInstance( 3771 OUString( RTL_CONSTASCII_USTRINGPARAM( 3772 "com.sun.star.ui.WindowStateConfiguration" ) ) ), 3773 uno::UNO_QUERY ); 3774 3775 if ( xPWSS.is() ) 3776 xPWSS->getByName( aModuleId ) >>= m_xPersistentWindowState; 3777 } 3778 3779 ToolbarSaveInData::~ToolbarSaveInData() 3780 { 3781 delete pRootEntry; 3782 } 3783 3784 void ToolbarSaveInData::SetSystemStyle( 3785 uno::Reference< frame::XFrame > xFrame, 3786 const OUString& rResourceURL, 3787 sal_Int32 nStyle ) 3788 { 3789 // change the style using the API 3790 SetSystemStyle( rResourceURL, nStyle ); 3791 3792 // this code is a temporary hack as the UI is not updating after 3793 // changing the toolbar style via the API 3794 uno::Reference< css::frame::XLayoutManager > xLayoutManager; 3795 Window *window = NULL; 3796 3797 uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY ); 3798 if ( xPropSet.is() ) 3799 { 3800 uno::Any a = xPropSet->getPropertyValue( 3801 OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ) ) ); 3802 a >>= xLayoutManager; 3803 } 3804 3805 if ( xLayoutManager.is() ) 3806 { 3807 uno::Reference< css::ui::XUIElement > xUIElement = 3808 xLayoutManager->getElement( rResourceURL ); 3809 3810 // check reference before we call getRealInterface. The layout manager 3811 // can only provide references for elements that have been created 3812 // before. It's possible that the current element is not available. 3813 uno::Reference< com::sun::star::awt::XWindow > xWindow; 3814 if ( xUIElement.is() ) 3815 xWindow = uno::Reference< com::sun::star::awt::XWindow >( 3816 xUIElement->getRealInterface(), uno::UNO_QUERY ); 3817 3818 window = VCLUnoHelper::GetWindow( xWindow ); 3819 } 3820 3821 if ( window != NULL && window->GetType() == WINDOW_TOOLBOX ) 3822 { 3823 ToolBox* toolbox = (ToolBox*)window; 3824 3825 if ( nStyle == 0 ) 3826 { 3827 toolbox->SetButtonType( BUTTON_SYMBOL ); 3828 } 3829 else if ( nStyle == 1 ) 3830 { 3831 toolbox->SetButtonType( BUTTON_TEXT ); 3832 } 3833 if ( nStyle == 2 ) 3834 { 3835 toolbox->SetButtonType( BUTTON_SYMBOLTEXT ); 3836 } 3837 } 3838 } 3839 3840 void ToolbarSaveInData::SetSystemStyle( 3841 const OUString& rResourceURL, 3842 sal_Int32 nStyle ) 3843 { 3844 if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 && 3845 m_xPersistentWindowState.is() && 3846 m_xPersistentWindowState->hasByName( rResourceURL ) ) 3847 { 3848 try 3849 { 3850 uno::Sequence< beans::PropertyValue > aProps; 3851 3852 uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) ); 3853 3854 if ( a >>= aProps ) 3855 { 3856 for ( sal_Int32 i = 0; i < aProps.getLength(); i++ ) 3857 { 3858 if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE) ) 3859 { 3860 aProps[ i ].Value = uno::makeAny( nStyle ); 3861 break; 3862 } 3863 } 3864 } 3865 3866 uno::Reference< container::XNameReplace > 3867 xNameReplace( m_xPersistentWindowState, uno::UNO_QUERY ); 3868 3869 xNameReplace->replaceByName( rResourceURL, uno::makeAny( aProps ) ); 3870 } 3871 catch ( uno::Exception& ) 3872 { 3873 // do nothing, a default value is returned 3874 OSL_TRACE("Exception setting toolbar style"); 3875 } 3876 } 3877 } 3878 3879 sal_Int32 ToolbarSaveInData::GetSystemStyle( const OUString& rResourceURL ) 3880 { 3881 sal_Int32 result = 0; 3882 3883 if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 && 3884 m_xPersistentWindowState.is() && 3885 m_xPersistentWindowState->hasByName( rResourceURL ) ) 3886 { 3887 try 3888 { 3889 uno::Sequence< beans::PropertyValue > aProps; 3890 uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) ); 3891 3892 if ( a >>= aProps ) 3893 { 3894 for ( sal_Int32 i = 0; i < aProps.getLength(); i++ ) 3895 { 3896 if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_STYLE) ) 3897 { 3898 aProps[i].Value >>= result; 3899 break; 3900 } 3901 } 3902 } 3903 } 3904 catch ( uno::Exception& ) 3905 { 3906 // do nothing, a default value is returned 3907 } 3908 } 3909 3910 return result; 3911 } 3912 3913 OUString ToolbarSaveInData::GetSystemUIName( const OUString& rResourceURL ) 3914 { 3915 OUString result; 3916 3917 if ( rResourceURL.indexOf( OUString::createFromAscii( "private" ) ) == 0 && 3918 m_xPersistentWindowState.is() && 3919 m_xPersistentWindowState->hasByName( rResourceURL ) ) 3920 { 3921 try 3922 { 3923 uno::Sequence< beans::PropertyValue > aProps; 3924 uno::Any a( m_xPersistentWindowState->getByName( rResourceURL ) ); 3925 3926 if ( a >>= aProps ) 3927 { 3928 for ( sal_Int32 i = 0; i < aProps.getLength(); i++ ) 3929 { 3930 if ( aProps[ i ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) ) 3931 { 3932 aProps[ i ].Value >>= result; 3933 } 3934 } 3935 } 3936 } 3937 catch ( uno::Exception& ) 3938 { 3939 // do nothing, an empty UIName will be returned 3940 } 3941 } 3942 3943 if ( rResourceURL.indexOf( OUString::createFromAscii( ".uno" ) ) == 0 && 3944 m_xCommandToLabelMap.is() && 3945 m_xCommandToLabelMap->hasByName( rResourceURL ) ) 3946 { 3947 uno::Any a; 3948 try 3949 { 3950 a = m_xCommandToLabelMap->getByName( rResourceURL ); 3951 3952 uno::Sequence< beans::PropertyValue > aPropSeq; 3953 if ( a >>= aPropSeq ) 3954 { 3955 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) 3956 { 3957 if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) ) 3958 { 3959 aPropSeq[i].Value >>= result; 3960 } 3961 } 3962 } 3963 } 3964 catch ( uno::Exception& ) 3965 { 3966 // not a system command name 3967 } 3968 } 3969 3970 return result; 3971 } 3972 3973 bool EntrySort( SvxConfigEntry* a, SvxConfigEntry* b ) 3974 { 3975 return a->GetName().compareTo( b->GetName() ) < 0; 3976 } 3977 3978 SvxEntries* ToolbarSaveInData::GetEntries() 3979 { 3980 typedef ::std::hash_map< ::rtl::OUString, 3981 bool, 3982 ::rtl::OUStringHash, 3983 ::std::equal_to< ::rtl::OUString > > ToolbarInfo; 3984 3985 ToolbarInfo aToolbarInfo; 3986 3987 if ( pRootEntry == NULL ) 3988 { 3989 3990 pRootEntry = new SvxConfigEntry( 3991 String::CreateFromAscii("MainToolbars"), String(), sal_True ); 3992 3993 uno::Sequence< uno::Sequence < beans::PropertyValue > > info = 3994 GetConfigManager()->getUIElementsInfo( 3995 css::ui::UIElementType::TOOLBAR ); 3996 3997 for ( sal_Int32 i = 0; i < info.getLength(); i++ ) 3998 { 3999 uno::Sequence< beans::PropertyValue > props = info[ i ]; 4000 4001 OUString url; 4002 OUString systemname; 4003 OUString uiname; 4004 4005 for ( sal_Int32 j = 0; j < props.getLength(); j++ ) 4006 { 4007 if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_RESOURCEURL) ) 4008 { 4009 props[ j ].Value >>= url; 4010 systemname = url.copy( url.lastIndexOf( '/' ) + 1 ); 4011 } 4012 else if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) ) 4013 { 4014 props[ j ].Value >>= uiname; 4015 } 4016 } 4017 4018 try 4019 { 4020 uno::Reference< container::XIndexAccess > xToolbarSettings = 4021 GetConfigManager()->getSettings( url, sal_False ); 4022 4023 if ( uiname.getLength() == 0 ) 4024 { 4025 // try to get the name from m_xPersistentWindowState 4026 uiname = GetSystemUIName( url ); 4027 4028 if ( uiname.getLength() == 0 ) 4029 { 4030 uiname = systemname; 4031 } 4032 } 4033 4034 SvxConfigEntry* pEntry = new SvxConfigEntry( 4035 uiname, url, sal_True ); 4036 4037 pEntry->SetMain( sal_True ); 4038 pEntry->SetStyle( GetSystemStyle( url ) ); 4039 4040 4041 // insert into hash_map to filter duplicates from the parent 4042 aToolbarInfo.insert( ToolbarInfo::value_type( systemname, true )); 4043 4044 OUString custom = OUString::createFromAscii(CUSTOM_TOOLBAR_STR); 4045 if ( systemname.indexOf( custom ) == 0 ) 4046 { 4047 pEntry->SetUserDefined( sal_True ); 4048 } 4049 else 4050 { 4051 pEntry->SetUserDefined( sal_False ); 4052 } 4053 4054 pRootEntry->GetEntries()->push_back( pEntry ); 4055 4056 LoadToolbar( xToolbarSettings, pEntry ); 4057 } 4058 catch ( container::NoSuchElementException& ) 4059 { 4060 // TODO, handle resourceURL with no settings 4061 } 4062 } 4063 4064 uno::Reference< css::ui::XUIConfigurationManager > xParentCfgMgr = GetParentConfigManager(); 4065 if ( xParentCfgMgr.is() ) 4066 { 4067 // Retrieve also the parent toolbars to make it possible 4068 // to configure module toolbars and save them into the document 4069 // config manager. 4070 uno::Sequence< uno::Sequence < beans::PropertyValue > > info_ = 4071 xParentCfgMgr->getUIElementsInfo( 4072 css::ui::UIElementType::TOOLBAR ); 4073 4074 for ( sal_Int32 i = 0; i < info_.getLength(); i++ ) 4075 { 4076 uno::Sequence< beans::PropertyValue > props = info_[ i ]; 4077 4078 OUString url; 4079 OUString systemname; 4080 OUString uiname; 4081 4082 for ( sal_Int32 j = 0; j < props.getLength(); j++ ) 4083 { 4084 if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_RESOURCEURL) ) 4085 { 4086 props[ j ].Value >>= url; 4087 systemname = url.copy( url.lastIndexOf( '/' ) + 1 ); 4088 } 4089 else if ( props[ j ].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) ) 4090 { 4091 props[ j ].Value >>= uiname; 4092 } 4093 } 4094 4095 // custom toolbars of the parent are not visible in the document layer 4096 OUString custom = OUString::createFromAscii(CUSTOM_TOOLBAR_STR); 4097 if ( systemname.indexOf( custom ) == 0 ) 4098 continue; 4099 4100 // check if toolbar is already in the document layer 4101 ToolbarInfo::const_iterator pIter = aToolbarInfo.find( systemname ); 4102 if ( pIter == aToolbarInfo.end() ) 4103 { 4104 aToolbarInfo.insert( ToolbarInfo::value_type( systemname, true )); 4105 4106 try 4107 { 4108 uno::Reference< container::XIndexAccess > xToolbarSettings = 4109 xParentCfgMgr->getSettings( url, sal_False ); 4110 4111 if ( uiname.getLength() == 0 ) 4112 { 4113 // try to get the name from m_xPersistentWindowState 4114 uiname = GetSystemUIName( url ); 4115 4116 if ( uiname.getLength() == 0 ) 4117 { 4118 uiname = systemname; 4119 } 4120 } 4121 4122 SvxConfigEntry* pEntry = new SvxConfigEntry( 4123 uiname, url, sal_True, sal_True ); 4124 4125 pEntry->SetMain( sal_True ); 4126 pEntry->SetStyle( GetSystemStyle( url ) ); 4127 4128 if ( systemname.indexOf( custom ) == 0 ) 4129 { 4130 pEntry->SetUserDefined( sal_True ); 4131 } 4132 else 4133 { 4134 pEntry->SetUserDefined( sal_False ); 4135 } 4136 4137 pRootEntry->GetEntries()->push_back( pEntry ); 4138 4139 LoadToolbar( xToolbarSettings, pEntry ); 4140 } 4141 catch ( container::NoSuchElementException& ) 4142 { 4143 // TODO, handle resourceURL with no settings 4144 } 4145 } 4146 } 4147 } 4148 4149 std::sort( GetEntries()->begin(), GetEntries()->end(), EntrySort ); 4150 } 4151 4152 return pRootEntry->GetEntries(); 4153 } 4154 4155 void 4156 ToolbarSaveInData::SetEntries( SvxEntries* pNewEntries ) 4157 { 4158 // delete old menu hierarchy first 4159 if ( pRootEntry != NULL && pRootEntry->GetEntries() != NULL ) 4160 { 4161 delete pRootEntry->GetEntries(); 4162 } 4163 4164 // now set new menu hierarchy 4165 pRootEntry->SetEntries( pNewEntries ); 4166 } 4167 4168 bool 4169 ToolbarSaveInData::HasURL( const OUString& rURL ) 4170 { 4171 SvxEntries::const_iterator iter = GetEntries()->begin(); 4172 SvxEntries::const_iterator end = GetEntries()->end(); 4173 4174 while ( iter != end ) 4175 { 4176 SvxConfigEntry* pEntry = *iter; 4177 4178 if ( pEntry->GetCommand().equals( rURL ) ) 4179 { 4180 if ( pEntry->IsParentData() ) 4181 return sal_False; 4182 else 4183 return sal_True; 4184 } 4185 4186 iter++; 4187 } 4188 return sal_False; 4189 } 4190 4191 bool ToolbarSaveInData::HasSettings() 4192 { 4193 // return true if there is at least one toolbar entry 4194 if ( GetEntries()->size() > 0 ) 4195 { 4196 return sal_True; 4197 } 4198 return sal_False; 4199 } 4200 4201 void ToolbarSaveInData::Reset() 4202 { 4203 SvxEntries::const_iterator toolbars = GetEntries()->begin(); 4204 SvxEntries::const_iterator end = GetEntries()->end(); 4205 4206 // reset each toolbar by calling removeSettings for it's toolbar URL 4207 for ( ; toolbars != end; toolbars++ ) 4208 { 4209 SvxConfigEntry* pToolbar = *toolbars; 4210 4211 try 4212 { 4213 OUString url = pToolbar->GetCommand(); 4214 GetConfigManager()->removeSettings( url ); 4215 } 4216 catch ( uno::Exception& ) 4217 { 4218 // error occured removing the settings 4219 // TODO - add error dialog in future? 4220 } 4221 } 4222 4223 // persist changes to toolbar storage 4224 PersistChanges( GetConfigManager() ); 4225 4226 // now delete the root SvxConfigEntry the next call to GetEntries() 4227 // causes it to be reinitialised 4228 delete pRootEntry; 4229 pRootEntry = NULL; 4230 4231 // reset all icons to default 4232 try 4233 { 4234 GetImageManager()->reset(); 4235 PersistChanges( GetImageManager() ); 4236 } 4237 catch ( uno::Exception& ) 4238 { 4239 OSL_TRACE("Error resetting all icons when resetting toolbars"); 4240 } 4241 } 4242 4243 bool ToolbarSaveInData::Apply() 4244 { 4245 // toolbar changes are instantly applied 4246 return sal_False; 4247 } 4248 4249 void ToolbarSaveInData::ApplyToolbar( 4250 uno::Reference< container::XIndexContainer >& rToolbarBar, 4251 uno::Reference< lang::XSingleComponentFactory >& rFactory, 4252 SvxConfigEntry* pToolbarData ) 4253 { 4254 SvxEntries::const_iterator iter = pToolbarData->GetEntries()->begin(); 4255 SvxEntries::const_iterator end = pToolbarData->GetEntries()->end(); 4256 4257 for ( ; iter != end; iter++ ) 4258 { 4259 SvxConfigEntry* pEntry = *iter; 4260 4261 if ( pEntry->IsPopup() ) 4262 { 4263 uno::Sequence< beans::PropertyValue > aPropValueSeq = 4264 ConvertToolbarEntry( m_xCommandToLabelMap, pEntry ); 4265 4266 uno::Reference< container::XIndexContainer > xSubMenuBar( 4267 rFactory->createInstanceWithContext( m_xComponentContext ), 4268 uno::UNO_QUERY ); 4269 4270 sal_Int32 nIndex = aPropValueSeq.getLength(); 4271 aPropValueSeq.realloc( nIndex + 1 ); 4272 aPropValueSeq[nIndex].Name = m_aDescriptorContainer; 4273 aPropValueSeq[nIndex].Value <<= xSubMenuBar; 4274 rToolbarBar->insertByIndex( 4275 rToolbarBar->getCount(), uno::makeAny( aPropValueSeq )); 4276 4277 ApplyToolbar( xSubMenuBar, rFactory, pEntry ); 4278 } 4279 else if ( pEntry->IsSeparator() ) 4280 { 4281 rToolbarBar->insertByIndex( 4282 rToolbarBar->getCount(), uno::makeAny( m_aSeparatorSeq )); 4283 } 4284 else 4285 { 4286 uno::Sequence< beans::PropertyValue > aPropValueSeq = 4287 ConvertToolbarEntry( m_xCommandToLabelMap, pEntry ); 4288 4289 rToolbarBar->insertByIndex( 4290 rToolbarBar->getCount(), uno::makeAny( aPropValueSeq )); 4291 } 4292 } 4293 } 4294 4295 void ToolbarSaveInData::ApplyToolbar( SvxConfigEntry* pToolbar ) 4296 { 4297 // Apply new toolbar structure to our settings container 4298 uno::Reference< container::XIndexAccess > xSettings( 4299 GetConfigManager()->createSettings(), uno::UNO_QUERY ); 4300 4301 uno::Reference< container::XIndexContainer > xIndexContainer ( 4302 xSettings, uno::UNO_QUERY ); 4303 4304 uno::Reference< lang::XSingleComponentFactory > xFactory ( 4305 xSettings, uno::UNO_QUERY ); 4306 4307 ApplyToolbar( xIndexContainer, xFactory, pToolbar ); 4308 4309 uno::Reference< beans::XPropertySet > xProps( 4310 xSettings, uno::UNO_QUERY ); 4311 4312 if ( pToolbar->IsUserDefined() ) 4313 { 4314 xProps->setPropertyValue( 4315 OUString::createFromAscii( ITEM_DESCRIPTOR_UINAME ), 4316 uno::makeAny( OUString( pToolbar->GetName() ) ) ); 4317 } 4318 4319 try 4320 { 4321 if ( GetConfigManager()->hasSettings( pToolbar->GetCommand() ) ) 4322 { 4323 GetConfigManager()->replaceSettings( 4324 pToolbar->GetCommand(), xSettings ); 4325 } 4326 else 4327 { 4328 GetConfigManager()->insertSettings( 4329 pToolbar->GetCommand(), xSettings ); 4330 if ( pToolbar->IsParentData() ) 4331 pToolbar->SetParentData( false ); 4332 } 4333 } 4334 catch ( container::NoSuchElementException& ) 4335 { 4336 OSL_TRACE("caught container::NoSuchElementException saving settings"); 4337 } 4338 catch ( com::sun::star::io::IOException& ) 4339 { 4340 OSL_TRACE("caught IOException saving settings"); 4341 } 4342 catch ( com::sun::star::uno::Exception& ) 4343 { 4344 OSL_TRACE("caught some other exception saving settings"); 4345 } 4346 4347 PersistChanges( GetConfigManager() ); 4348 } 4349 4350 void ToolbarSaveInData::CreateToolbar( SvxConfigEntry* pToolbar ) 4351 { 4352 // show the new toolbar in the UI also 4353 uno::Reference< container::XIndexAccess > 4354 xSettings( GetConfigManager()->createSettings(), uno::UNO_QUERY ); 4355 4356 uno::Reference< container::XIndexContainer > 4357 xIndexContainer ( xSettings, uno::UNO_QUERY ); 4358 4359 uno::Reference< beans::XPropertySet > 4360 xPropertySet( xSettings, uno::UNO_QUERY ); 4361 4362 xPropertySet->setPropertyValue( 4363 OUString::createFromAscii( ITEM_DESCRIPTOR_UINAME ), 4364 uno::makeAny( pToolbar->GetName() ) ); 4365 4366 try 4367 { 4368 GetConfigManager()->insertSettings( pToolbar->GetCommand(), xSettings ); 4369 } 4370 catch ( container::ElementExistException& ) 4371 { 4372 OSL_TRACE("caught ElementExistsException saving settings"); 4373 } 4374 catch ( com::sun::star::lang::IllegalArgumentException& ) 4375 { 4376 OSL_TRACE("caught IOException saving settings"); 4377 } 4378 catch ( com::sun::star::lang::IllegalAccessException& ) 4379 { 4380 OSL_TRACE("caught IOException saving settings"); 4381 } 4382 catch ( com::sun::star::uno::Exception& ) 4383 { 4384 OSL_TRACE("caught some other exception saving settings"); 4385 } 4386 4387 GetEntries()->push_back( pToolbar ); 4388 4389 PersistChanges( GetConfigManager() ); 4390 } 4391 4392 void ToolbarSaveInData::RemoveToolbar( SvxConfigEntry* pToolbar ) 4393 { 4394 try 4395 { 4396 OUString url = pToolbar->GetCommand(); 4397 GetConfigManager()->removeSettings( url ); 4398 RemoveEntry( GetEntries(), pToolbar ); 4399 delete pToolbar; 4400 4401 PersistChanges( GetConfigManager() ); 4402 4403 // remove the persistent window state data 4404 css::uno::Reference< css::container::XNameContainer > xNameContainer( 4405 m_xPersistentWindowState, css::uno::UNO_QUERY_THROW ); 4406 4407 xNameContainer->removeByName( url ); 4408 } 4409 catch ( uno::Exception& ) 4410 { 4411 // error occured removing the settings 4412 } 4413 } 4414 4415 void ToolbarSaveInData::RestoreToolbar( SvxConfigEntry* pToolbar ) 4416 { 4417 OUString url = pToolbar->GetCommand(); 4418 4419 // Restore of toolbar is done by removing it from 4420 // it's configuration manager and then getting it again 4421 bool bParentToolbar = pToolbar->IsParentData(); 4422 4423 // Cannot restore parent toolbar 4424 if ( bParentToolbar ) 4425 return; 4426 4427 try 4428 { 4429 GetConfigManager()->removeSettings( url ); 4430 pToolbar->GetEntries()->clear(); 4431 PersistChanges( GetConfigManager() ); 4432 } 4433 catch ( uno::Exception& ) 4434 { 4435 // if an error occurs removing the settings then just return 4436 return; 4437 } 4438 4439 // Now reload the toolbar settings 4440 try 4441 { 4442 uno::Reference< container::XIndexAccess > xToolbarSettings; 4443 if ( IsDocConfig() ) 4444 { 4445 xToolbarSettings = GetParentConfigManager()->getSettings( url, sal_False ); 4446 pToolbar->SetParentData( true ); 4447 } 4448 else 4449 xToolbarSettings = GetConfigManager()->getSettings( url, sal_False ); 4450 4451 LoadToolbar( xToolbarSettings, pToolbar ); 4452 4453 // After reloading, ensure that the icon is reset of each entry 4454 // in the toolbar 4455 SvxEntries::const_iterator iter = pToolbar->GetEntries()->begin(); 4456 uno::Sequence< OUString > aURLSeq( 1 ); 4457 for ( ; iter != pToolbar->GetEntries()->end(); iter++ ) 4458 { 4459 SvxConfigEntry* pEntry = *iter; 4460 aURLSeq[ 0 ] = pEntry->GetCommand(); 4461 4462 try 4463 { 4464 GetImageManager()->removeImages( GetImageType(), aURLSeq ); 4465 } 4466 catch ( uno::Exception& ) 4467 { 4468 OSL_TRACE("Error restoring icon when resetting toolbar"); 4469 } 4470 } 4471 PersistChanges( GetImageManager() ); 4472 } 4473 catch ( container::NoSuchElementException& ) 4474 { 4475 // cannot find the resource URL after removing it 4476 // so no entry will appear in the toolbar list 4477 } 4478 } 4479 4480 bool ToolbarSaveInData::LoadToolbar( 4481 const uno::Reference< container::XIndexAccess >& xToolbarSettings, 4482 SvxConfigEntry* pParentData ) 4483 { 4484 SvxEntries* pEntries = pParentData->GetEntries(); 4485 4486 for ( sal_Int32 nIndex = 0; nIndex < xToolbarSettings->getCount(); nIndex++ ) 4487 { 4488 uno::Reference< container::XIndexAccess > xSubMenu; 4489 OUString aCommandURL; 4490 OUString aLabel; 4491 bool bIsUserDefined = sal_True; 4492 sal_Bool bIsVisible; 4493 sal_Int32 nStyle; 4494 4495 sal_uInt16 nType( css::ui::ItemType::DEFAULT ); 4496 4497 bool bItem = GetToolbarItemData( xToolbarSettings, nIndex, aCommandURL, 4498 aLabel, nType, bIsVisible, nStyle, xSubMenu ); 4499 4500 if ( bItem ) 4501 { 4502 if ( nType == css::ui::ItemType::DEFAULT ) 4503 { 4504 uno::Any a; 4505 try 4506 { 4507 a = m_xCommandToLabelMap->getByName( aCommandURL ); 4508 bIsUserDefined = sal_False; 4509 } 4510 catch ( container::NoSuchElementException& ) 4511 { 4512 bIsUserDefined = sal_True; 4513 } 4514 4515 // If custom label not set retrieve it from the command 4516 // to info service 4517 if ( aLabel.equals( OUString() ) ) 4518 { 4519 uno::Sequence< beans::PropertyValue > aPropSeq; 4520 if ( a >>= aPropSeq ) 4521 { 4522 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) 4523 { 4524 if ( aPropSeq[i].Name.equalsAscii( ITEM_DESCRIPTOR_LABEL ) ) 4525 { 4526 aPropSeq[i].Value >>= aLabel; 4527 break; 4528 } 4529 } 4530 } 4531 } 4532 4533 if ( xSubMenu.is() ) 4534 { 4535 SvxConfigEntry* pEntry = new SvxConfigEntry( 4536 aLabel, aCommandURL, sal_True ); 4537 4538 pEntry->SetUserDefined( bIsUserDefined ); 4539 pEntry->SetVisible( bIsVisible ); 4540 4541 pEntries->push_back( pEntry ); 4542 4543 LoadToolbar( xSubMenu, pEntry ); 4544 } 4545 else 4546 { 4547 SvxConfigEntry* pEntry = new SvxConfigEntry( 4548 aLabel, aCommandURL, sal_False ); 4549 pEntry->SetUserDefined( bIsUserDefined ); 4550 pEntry->SetVisible( bIsVisible ); 4551 pEntry->SetStyle( nStyle ); 4552 pEntries->push_back( pEntry ); 4553 } 4554 } 4555 else 4556 { 4557 SvxConfigEntry* pEntry = new SvxConfigEntry; 4558 pEntry->SetUserDefined( bIsUserDefined ); 4559 pEntries->push_back( pEntry ); 4560 } 4561 } 4562 } 4563 4564 return true; 4565 } 4566 4567 IMPL_LINK( SvxToolbarConfigPage, SelectToolbarEntry, Control *, pBox ) 4568 { 4569 (void)pBox; 4570 UpdateButtonStates(); 4571 return 1; 4572 } 4573 4574 void SvxToolbarConfigPage::UpdateButtonStates() 4575 { 4576 PopupMenu* pPopup = aModifyCommandButton.GetPopupMenu(); 4577 pPopup->EnableItem( ID_RENAME, sal_False ); 4578 pPopup->EnableItem( ID_DELETE, sal_False ); 4579 pPopup->EnableItem( ID_BEGIN_GROUP, sal_False ); 4580 pPopup->EnableItem( ID_DEFAULT_COMMAND, sal_False ); 4581 pPopup->EnableItem( ID_ICON_ONLY, sal_False ); 4582 pPopup->EnableItem( ID_ICON_AND_TEXT, sal_False ); 4583 pPopup->EnableItem( ID_TEXT_ONLY, sal_False ); 4584 pPopup->EnableItem( ID_CHANGE_SYMBOL, sal_False ); 4585 pPopup->EnableItem( ID_RESET_SYMBOL, sal_False ); 4586 4587 aDescriptionField.Clear(); 4588 4589 SvLBoxEntry* selection = aContentsListBox->GetCurEntry(); 4590 if ( aContentsListBox->GetEntryCount() == 0 || selection == NULL ) 4591 { 4592 return; 4593 } 4594 4595 SvxConfigEntry* pEntryData = (SvxConfigEntry*) selection->GetUserData(); 4596 if ( pEntryData->IsSeparator() ) 4597 pPopup->EnableItem( ID_DELETE, sal_True ); 4598 else 4599 { 4600 pPopup->EnableItem( ID_BEGIN_GROUP, sal_True ); 4601 pPopup->EnableItem( ID_DELETE, sal_True ); 4602 pPopup->EnableItem( ID_RENAME, sal_True ); 4603 pPopup->EnableItem( ID_ICON_ONLY, sal_True ); 4604 pPopup->EnableItem( ID_ICON_AND_TEXT, sal_True ); 4605 pPopup->EnableItem( ID_TEXT_ONLY, sal_True ); 4606 pPopup->EnableItem( ID_CHANGE_SYMBOL, sal_True ); 4607 4608 if ( !pEntryData->IsUserDefined() ) 4609 pPopup->EnableItem( ID_DEFAULT_COMMAND, sal_True ); 4610 4611 if ( pEntryData->IsIconModified() ) 4612 pPopup->EnableItem( ID_RESET_SYMBOL, sal_True ); 4613 4614 aDescriptionField.SetNewText( pEntryData->GetHelpText() ); 4615 } 4616 } 4617 4618 short SvxToolbarConfigPage::QueryReset() 4619 { 4620 String msg = 4621 String( CUI_RES( RID_SVXSTR_CONFIRM_TOOLBAR_RESET ) ); 4622 4623 String saveInName = aSaveInListBox.GetEntry( 4624 aSaveInListBox.GetSelectEntryPos() ); 4625 4626 OUString label = replaceSaveInName( msg, saveInName ); 4627 4628 QueryBox qbox( this, WB_YES_NO, label ); 4629 4630 return qbox.Execute(); 4631 } 4632 4633 IMPL_LINK( SvxToolbarConfigPage, SelectToolbar, ListBox *, pBox ) 4634 { 4635 (void)pBox; 4636 4637 aContentsListBox->Clear(); 4638 4639 SvxConfigEntry* pToolbar = GetTopLevelSelection(); 4640 if ( pToolbar == NULL ) 4641 { 4642 aModifyTopLevelButton.Enable( sal_False ); 4643 aModifyCommandButton.Enable( sal_False ); 4644 aAddCommandsButton.Enable( sal_False ); 4645 4646 return 0; 4647 } 4648 4649 aModifyTopLevelButton.Enable( sal_True ); 4650 aModifyCommandButton.Enable( sal_True ); 4651 aAddCommandsButton.Enable( sal_True ); 4652 4653 PopupMenu* pPopup = aModifyTopLevelButton.GetPopupMenu(); 4654 4655 pPopup->EnableItem( ID_DELETE, pToolbar->IsDeletable() ); 4656 pPopup->EnableItem( ID_RENAME, pToolbar->IsRenamable() ); 4657 pPopup->EnableItem( ID_DEFAULT_STYLE, !pToolbar->IsRenamable() ); 4658 4659 switch( pToolbar->GetStyle() ) 4660 { 4661 case 0: 4662 { 4663 pPopup->CheckItem( ID_ICONS_ONLY ); 4664 break; 4665 } 4666 case 1: 4667 { 4668 pPopup->CheckItem( ID_TEXT_ONLY ); 4669 break; 4670 } 4671 case 2: 4672 { 4673 pPopup->CheckItem( ID_ICONS_AND_TEXT ); 4674 break; 4675 } 4676 } 4677 4678 SvxEntries* pEntries = pToolbar->GetEntries(); 4679 SvxEntries::const_iterator iter = pEntries->begin(); 4680 4681 for ( ; iter != pEntries->end(); iter++ ) 4682 { 4683 SvxConfigEntry* pEntry = *iter; 4684 4685 SvLBoxEntry* pNewLBEntry = InsertEntryIntoUI( pEntry ); 4686 4687 if (pEntry->IsBinding()) 4688 { 4689 aContentsListBox->SetCheckButtonState( pNewLBEntry, 4690 pEntry->IsVisible() ? SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); 4691 } 4692 else 4693 { 4694 aContentsListBox->SetCheckButtonState( 4695 pNewLBEntry, SV_BUTTON_TRISTATE ); 4696 } 4697 } 4698 4699 UpdateButtonStates(); 4700 4701 return 0; 4702 } 4703 4704 IMPL_LINK( SvxToolbarConfigPage, NewToolbarHdl, Button *, pButton ) 4705 { 4706 (void)pButton; 4707 4708 String prefix = 4709 String( CUI_RES( RID_SVXSTR_NEW_TOOLBAR ) ); 4710 4711 OUString aNewName = 4712 generateCustomName( prefix, GetSaveInData()->GetEntries() ); 4713 4714 OUString aNewURL = 4715 generateCustomURL( GetSaveInData()->GetEntries() ); 4716 4717 SvxNewToolbarDialog* pNameDialog = new SvxNewToolbarDialog( 0, aNewName ); 4718 4719 sal_uInt16 nInsertPos; 4720 for ( sal_uInt16 i = 0 ; i < aSaveInListBox.GetEntryCount(); i++ ) 4721 { 4722 SaveInData* pData = 4723 (SaveInData*) aSaveInListBox.GetEntryData( i ); 4724 4725 nInsertPos = pNameDialog->aSaveInListBox.InsertEntry( 4726 aSaveInListBox.GetEntry( i ) ); 4727 4728 pNameDialog->aSaveInListBox.SetEntryData( nInsertPos, pData ); 4729 } 4730 4731 pNameDialog->aSaveInListBox.SelectEntryPos( 4732 aSaveInListBox.GetSelectEntryPos(), sal_True ); 4733 4734 bool ret = pNameDialog->Execute(); 4735 if ( ret == RET_OK ) 4736 { 4737 pNameDialog->GetName( aNewName ); 4738 4739 nInsertPos = pNameDialog->aSaveInListBox.GetSelectEntryPos(); 4740 4741 ToolbarSaveInData* pData = (ToolbarSaveInData*) 4742 pNameDialog->aSaveInListBox.GetEntryData( nInsertPos ); 4743 4744 if ( GetSaveInData() != pData ) 4745 { 4746 aSaveInListBox.SelectEntryPos( nInsertPos, sal_True ); 4747 aSaveInListBox.GetSelectHdl().Call(this); 4748 } 4749 4750 SvxConfigEntry* pToolbar = 4751 new SvxConfigEntry( aNewName, aNewURL, sal_True ); 4752 4753 pToolbar->SetUserDefined( sal_True ); 4754 pToolbar->SetMain( sal_True ); 4755 4756 pData->CreateToolbar( pToolbar ); 4757 4758 nInsertPos = aTopLevelListBox.InsertEntry( pToolbar->GetName() ); 4759 aTopLevelListBox.SetEntryData( nInsertPos, pToolbar ); 4760 aTopLevelListBox.SelectEntryPos( nInsertPos, sal_True ); 4761 aTopLevelListBox.GetSelectHdl().Call(this); 4762 4763 pData->SetModified( sal_True ); 4764 } 4765 4766 delete pNameDialog; 4767 4768 return 0; 4769 } 4770 4771 IMPL_LINK( SvxToolbarConfigPage, AddCommandsHdl, Button *, pButton ) 4772 { 4773 (void)pButton; 4774 4775 if ( pSelectorDlg == NULL ) 4776 { 4777 // Create Script Selector which shows slot commands 4778 pSelectorDlg = new SvxScriptSelectorDialog( this, sal_True, m_xFrame ); 4779 4780 // Position the Script Selector over the Add button so it is 4781 // beside the menu contents list and does not obscure it 4782 pSelectorDlg->SetPosPixel( aAddCommandsButton.GetPosPixel() ); 4783 4784 pSelectorDlg->SetAddHdl( 4785 LINK( this, SvxToolbarConfigPage, AddFunctionHdl ) ); 4786 } 4787 4788 pSelectorDlg->SetImageProvider( 4789 static_cast< ImageProvider* >( GetSaveInData() ) ); 4790 4791 pSelectorDlg->Show(); 4792 return 1; 4793 } 4794 4795 IMPL_LINK( SvxToolbarConfigPage, AddFunctionHdl, 4796 SvxScriptSelectorDialog *, pDialog ) 4797 { 4798 (void)pDialog; 4799 4800 AddFunction(); 4801 4802 return 0; 4803 } 4804 4805 SvLBoxEntry* SvxToolbarConfigPage::AddFunction( 4806 SvLBoxEntry* pTarget, bool bFront, bool bAllowDuplicates ) 4807 { 4808 SvLBoxEntry* pNewLBEntry = 4809 SvxConfigPage::AddFunction( pTarget, bFront, bAllowDuplicates ); 4810 4811 SvxConfigEntry* pEntry = (SvxConfigEntry*) pNewLBEntry->GetUserData(); 4812 4813 if ( pEntry->IsBinding() ) 4814 { 4815 pEntry->SetVisible( sal_True ); 4816 aContentsListBox->SetCheckButtonState( 4817 pNewLBEntry, SV_BUTTON_CHECKED ); 4818 } 4819 else 4820 { 4821 aContentsListBox->SetCheckButtonState( 4822 pNewLBEntry, SV_BUTTON_TRISTATE ); 4823 } 4824 4825 // get currently selected toolbar and apply change 4826 SvxConfigEntry* pToolbar = GetTopLevelSelection(); 4827 4828 if ( pToolbar != NULL ) 4829 { 4830 ( ( ToolbarSaveInData* ) GetSaveInData() )->ApplyToolbar( pToolbar ); 4831 } 4832 4833 return pNewLBEntry; 4834 } 4835 4836 // ----------------------------------------------------------------------- 4837 4838 SvxToolbarEntriesListBox::SvxToolbarEntriesListBox( 4839 Window* pParent, const ResId& aResId ) 4840 : 4841 SvxMenuEntriesListBox( pParent, aResId ), 4842 pPage( ( SvxToolbarConfigPage* ) pParent ) 4843 { 4844 m_pButtonData = new SvLBoxButtonData( this ); 4845 BuildCheckBoxButtonImages( m_pButtonData ); 4846 EnableCheckButton( m_pButtonData ); 4847 4848 m_bHiContrastMode = GetSettings().GetStyleSettings().GetHighContrastMode(); 4849 } 4850 4851 // -------------------------------------------------------- 4852 4853 SvxToolbarEntriesListBox::~SvxToolbarEntriesListBox() 4854 { 4855 delete m_pButtonData; 4856 } 4857 4858 // -------------------------------------------------------- 4859 4860 void SvxToolbarEntriesListBox::BuildCheckBoxButtonImages( SvLBoxButtonData* pData ) 4861 { 4862 // Build checkbox images according to the current application 4863 // settings. This is necessary to be able to have correct colors 4864 // in all color modes, like high contrast. 4865 const AllSettings& rSettings = Application::GetSettings(); 4866 4867 VirtualDevice aDev; 4868 Size aSize( 26, 20 ); 4869 4870 aDev.SetOutputSizePixel( aSize ); 4871 4872 Image aImage = GetSizedImage( aDev, aSize, 4873 CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_DEFAULT )); 4874 4875 // Fill button data struct with new images 4876 pData->aBmps[SV_BMP_UNCHECKED] = aImage; 4877 pData->aBmps[SV_BMP_CHECKED] = GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_CHECKED )); 4878 pData->aBmps[SV_BMP_HICHECKED] = GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_CHECKED | BUTTON_DRAW_PRESSED )); 4879 pData->aBmps[SV_BMP_HIUNCHECKED] = GetSizedImage( aDev, aSize, CheckBox::GetCheckImage( rSettings, BUTTON_DRAW_DEFAULT | BUTTON_DRAW_PRESSED)); 4880 pData->aBmps[SV_BMP_TRISTATE] = GetSizedImage( aDev, aSize, Image() ); // Use tristate bitmaps to have no checkbox for separator entries 4881 pData->aBmps[SV_BMP_HITRISTATE] = GetSizedImage( aDev, aSize, Image() ); 4882 4883 // Get image size 4884 m_aCheckBoxImageSizePixel = aImage.GetSizePixel(); 4885 } 4886 4887 Image SvxToolbarEntriesListBox::GetSizedImage( 4888 VirtualDevice& aDev, const Size& aNewSize, const Image& aImage ) 4889 { 4890 // Create new checkbox images for treelistbox. They must have a 4891 // decent width to have a clear column for the visibility checkbox. 4892 4893 // Standard transparent color is light magenta as is won't be 4894 // used for other things 4895 Color aFillColor( COL_LIGHTMAGENTA ); 4896 4897 // Position image at the center of (width-2),(height) rectangle. 4898 // We need 2 pixels to have a bigger border to the next button image 4899 sal_uInt16 nPosX = std::max( (sal_uInt16) (((( aNewSize.Width() - 2 ) - aImage.GetSizePixel().Width() ) / 2 ) - 1), (sal_uInt16) 0 ); 4900 sal_uInt16 nPosY = std::max( (sal_uInt16) (((( aNewSize.Height() - 2 ) - aImage.GetSizePixel().Height() ) / 2 ) + 1), (sal_uInt16) 0 ); 4901 Point aPos( nPosX > 0 ? nPosX : 0, nPosY > 0 ? nPosY : 0 ); 4902 aDev.SetFillColor( aFillColor ); 4903 aDev.SetLineColor( aFillColor ); 4904 aDev.DrawRect( Rectangle( Point(), aNewSize )); 4905 aDev.DrawImage( aPos, aImage ); 4906 4907 // Draw separator line 2 pixels left from the right border 4908 Color aLineColor = GetDisplayBackground().GetColor().IsDark() ? Color( COL_WHITE ) : Color( COL_BLACK ); 4909 aDev.SetLineColor( aLineColor ); 4910 aDev.DrawLine( Point( aNewSize.Width()-3, 0 ), Point( aNewSize.Width()-3, aNewSize.Height()-1 )); 4911 4912 // Create new image that uses the fillcolor as transparent 4913 return Image( aDev.GetBitmap( Point(), aNewSize ), aFillColor ); 4914 } 4915 4916 void SvxToolbarEntriesListBox::DataChanged( const DataChangedEvent& rDCEvt ) 4917 { 4918 SvTreeListBox::DataChanged( rDCEvt ); 4919 4920 if (( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && 4921 ( rDCEvt.GetFlags() & SETTINGS_STYLE )) 4922 { 4923 // We have to reset all images because we change to/from high contrast mode 4924 m_bHiContrastMode = GetSettings().GetStyleSettings().GetHighContrastMode(); 4925 4926 BuildCheckBoxButtonImages( m_pButtonData ); 4927 Invalidate(); 4928 } 4929 } 4930 4931 // -------------------------------------------------------- 4932 4933 void SvxToolbarEntriesListBox::ChangeVisibility( SvLBoxEntry* pEntry ) 4934 { 4935 if ( pEntry != NULL ) 4936 { 4937 SvxConfigEntry* pEntryData = 4938 (SvxConfigEntry*) pEntry->GetUserData(); 4939 4940 if ( pEntryData->IsBinding() ) 4941 { 4942 pEntryData->SetVisible( !pEntryData->IsVisible() ); 4943 4944 SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection(); 4945 4946 ToolbarSaveInData* pToolbarSaveInData = ( ToolbarSaveInData* ) 4947 pPage->GetSaveInData(); 4948 4949 pToolbarSaveInData->ApplyToolbar( pToolbar ); 4950 4951 SetCheckButtonState( pEntry, pEntryData->IsVisible() ? 4952 SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); 4953 } 4954 } 4955 } 4956 4957 void SvxToolbarEntriesListBox::CheckButtonHdl() 4958 { 4959 ChangeVisibility( GetHdlEntry() ); 4960 } 4961 4962 void SvxToolbarEntriesListBox::KeyInput( const KeyEvent& rKeyEvent ) 4963 { 4964 // space key will change visibility of toolbar items 4965 if ( rKeyEvent.GetKeyCode() == KEY_SPACE ) 4966 { 4967 ChangeVisibility( GetCurEntry() ); 4968 } 4969 else 4970 { 4971 // pass on to superclass 4972 SvxMenuEntriesListBox::KeyInput( rKeyEvent ); 4973 } 4974 } 4975 4976 sal_Bool SvxToolbarEntriesListBox::NotifyMoving( 4977 SvLBoxEntry* pTarget, SvLBoxEntry* pSource, 4978 SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos) 4979 { 4980 bool result = SvxMenuEntriesListBox::NotifyMoving( 4981 pTarget, pSource, rpNewParent, rNewChildPos ); 4982 4983 if ( result == sal_True ) 4984 { 4985 // Instant Apply changes to UI 4986 SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection(); 4987 if ( pToolbar != NULL ) 4988 { 4989 ToolbarSaveInData* pSaveInData = 4990 ( ToolbarSaveInData*) pPage->GetSaveInData(); 4991 pSaveInData->ApplyToolbar( pToolbar ); 4992 } 4993 } 4994 4995 return result; 4996 } 4997 4998 sal_Bool SvxToolbarEntriesListBox::NotifyCopying( 4999 SvLBoxEntry* pTarget, 5000 SvLBoxEntry* pSource, 5001 SvLBoxEntry*& rpNewParent, 5002 sal_uLong& rNewChildPos) 5003 { 5004 (void)pSource; 5005 (void)rpNewParent; 5006 (void)rNewChildPos; 5007 5008 if ( !m_bIsInternalDrag ) 5009 { 5010 // if the target is NULL then add function to the start of the list 5011 ((SvxToolbarConfigPage*)pPage)->AddFunction( pTarget, pTarget == NULL ); 5012 5013 // Instant Apply changes to UI 5014 SvxConfigEntry* pToolbar = pPage->GetTopLevelSelection(); 5015 if ( pToolbar != NULL ) 5016 { 5017 ToolbarSaveInData* pSaveInData = 5018 ( ToolbarSaveInData*) pPage->GetSaveInData(); 5019 pSaveInData->ApplyToolbar( pToolbar ); 5020 } 5021 5022 // AddFunction already adds the listbox entry so return FALSE 5023 // to stop another listbox entry being added 5024 return sal_False; 5025 } 5026 5027 // Copying is only allowed from external controls, not within the listbox 5028 return sal_False; 5029 } 5030 5031 SvxNewToolbarDialog::SvxNewToolbarDialog( 5032 Window* pWindow, const String& rName ) 5033 : 5034 ModalDialog ( pWindow, CUI_RES( MD_NEW_TOOLBAR ) ), 5035 aFtDescription ( this, CUI_RES( FT_NAME ) ), 5036 aEdtName ( this, CUI_RES( EDT_STRING ) ), 5037 aSaveInText ( this, CUI_RES( TXT_SAVEIN ) ), 5038 aBtnOK ( this, CUI_RES( BTN_OK ) ), 5039 aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), 5040 aBtnHelp ( this, CUI_RES( BTN_HELP ) ), 5041 aSaveInListBox ( this, CUI_RES( LB_SAVEIN ) ) 5042 { 5043 FreeResource(); 5044 5045 aEdtName.SetText( rName ); 5046 aEdtName.SetSelection(Selection(SELECTION_MIN, SELECTION_MAX)); 5047 ModifyHdl(&aEdtName); 5048 aEdtName.SetModifyHdl(LINK(this, SvxNewToolbarDialog, ModifyHdl)); 5049 } 5050 5051 IMPL_LINK(SvxNewToolbarDialog, ModifyHdl, Edit*, pEdit) 5052 { 5053 (void)pEdit; 5054 5055 if(aCheckNameHdl.IsSet()) 5056 aBtnOK.Enable(aCheckNameHdl.Call(this) > 0); 5057 5058 return 0; 5059 } 5060 5061 /******************************************************************************* 5062 * 5063 * The SvxIconSelectorDialog class 5064 * 5065 *******************************************************************************/ 5066 SvxIconSelectorDialog::SvxIconSelectorDialog( Window *pWindow, 5067 const uno::Reference< css::ui::XImageManager >& rXImageManager, 5068 const uno::Reference< css::ui::XImageManager >& rXParentImageManager ) 5069 : 5070 ModalDialog ( pWindow, CUI_RES( MD_ICONSELECTOR ) ), 5071 aFtDescription ( this, CUI_RES( FT_SYMBOLS ) ), 5072 aTbSymbol ( this, CUI_RES( TB_SYMBOLS ) ), 5073 aFtNote ( this, CUI_RES( FT_NOTE ) ), 5074 aBtnOK ( this, CUI_RES( BTN_OK ) ), 5075 aBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), 5076 aBtnHelp ( this, CUI_RES( BTN_HELP ) ), 5077 aBtnImport ( this, CUI_RES( BTN_IMPORT ) ), 5078 aBtnDelete ( this, CUI_RES( BTN_DELETE ) ), 5079 aFlSeparator ( this, CUI_RES( FL_SEPARATOR ) ), 5080 m_nNextId ( 0 ), 5081 m_xImageManager ( rXImageManager ), 5082 m_xParentImageManager( rXParentImageManager ) 5083 { 5084 FreeResource(); 5085 5086 typedef ::std::hash_map< ::rtl::OUString, 5087 bool, 5088 ::rtl::OUStringHash, 5089 ::std::equal_to< ::rtl::OUString > > ImageInfo; 5090 5091 aTbSymbol.SetPageScroll( sal_True ); 5092 5093 bool bLargeIcons = GetImageType() & css::ui::ImageType::SIZE_LARGE; 5094 m_nExpectedSize = bLargeIcons ? 26 : 16; 5095 5096 if ( m_nExpectedSize != 16 ) 5097 { 5098 aFtNote.SetText( replaceSixteen( aFtNote.GetText(), m_nExpectedSize ) ); 5099 } 5100 5101 uno::Reference< lang::XMultiServiceFactory > xServiceManager = 5102 ::comphelper::getProcessServiceFactory(); 5103 5104 if ( xServiceManager.is() ) 5105 { 5106 m_xGraphProvider = uno::Reference< graphic::XGraphicProvider >( 5107 xServiceManager->createInstance( 5108 ::rtl::OUString::createFromAscii( 5109 "com.sun.star.graphic.GraphicProvider" ) ), 5110 uno::UNO_QUERY ); 5111 } 5112 5113 if ( !m_xGraphProvider.is() ) 5114 { 5115 aBtnImport.Enable( sal_False ); 5116 } 5117 5118 uno::Reference< beans::XPropertySet > xPropSet( 5119 xServiceManager->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.util.PathSettings" ) ), 5120 uno::UNO_QUERY ); 5121 5122 uno::Any aAny = xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfig" ) ) ); 5123 5124 ::rtl::OUString aDirectory; 5125 5126 aAny >>= aDirectory; 5127 5128 sal_Int32 aCount = aDirectory.getLength(); 5129 5130 if ( aCount > 0 ) 5131 { 5132 sal_Unicode aChar = aDirectory[ aCount-1 ]; 5133 if ( aChar != '/') 5134 { 5135 aDirectory += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ); 5136 } 5137 } 5138 else 5139 { 5140 aBtnImport.Enable( sal_False ); 5141 } 5142 5143 aDirectory += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "soffice.cfg/import" ) ); 5144 5145 uno::Reference< lang::XSingleServiceFactory > xStorageFactory( 5146 xServiceManager->createInstance( 5147 ::rtl::OUString::createFromAscii( "com.sun.star.embed.FileSystemStorageFactory" )), 5148 uno::UNO_QUERY ); 5149 5150 uno::Sequence< uno::Any > aArgs( 2 ); 5151 aArgs[ 0 ] <<= aDirectory; 5152 aArgs[ 1 ] <<= com::sun::star::embed::ElementModes::READWRITE; 5153 5154 uno::Reference< com::sun::star::embed::XStorage > xStorage( 5155 xStorageFactory->createInstanceWithArguments( aArgs ), uno::UNO_QUERY ); 5156 5157 uno::Sequence< uno::Any > aProp( 2 ); 5158 beans::PropertyValue aPropValue; 5159 5160 aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserConfigStorage" ) ); 5161 aPropValue.Value <<= xStorage; 5162 aProp[ 0 ] <<= aPropValue; 5163 5164 aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ) ); 5165 aPropValue.Value <<= com::sun::star::embed::ElementModes::READWRITE; 5166 aProp[ 1 ] <<= aPropValue; 5167 5168 m_xImportedImageManager = uno::Reference< com::sun::star::ui::XImageManager >( 5169 xServiceManager->createInstanceWithArguments( 5170 ::rtl::OUString::createFromAscii( "com.sun.star.ui.ImageManager" ), aProp ), 5171 uno::UNO_QUERY ); 5172 5173 ImageInfo mImageInfo; 5174 uno::Sequence< OUString > names; 5175 if ( m_xImportedImageManager.is() ) 5176 { 5177 names = m_xImportedImageManager->getAllImageNames( GetImageType() ); 5178 for ( sal_Int32 n = 0; n < names.getLength(); n++ ) 5179 mImageInfo.insert( ImageInfo::value_type( names[n], false )); 5180 } 5181 sal_uInt16 nId = 1; 5182 ImageInfo::const_iterator pConstIter = mImageInfo.begin(); 5183 uno::Sequence< OUString > name( 1 ); 5184 while ( pConstIter != mImageInfo.end() ) 5185 { 5186 name[ 0 ] = pConstIter->first; 5187 uno::Sequence< uno::Reference< graphic::XGraphic> > graphics = m_xImportedImageManager->getImages( GetImageType(), name ); 5188 if ( graphics.getLength() > 0 ) 5189 { 5190 Image img = Image( graphics[ 0 ] ); 5191 aTbSymbol.InsertItem( nId, img, pConstIter->first ); 5192 5193 graphics[ 0 ]->acquire(); 5194 5195 aTbSymbol.SetItemData( 5196 nId, static_cast< void * > ( graphics[ 0 ].get() ) ); 5197 5198 ++nId; 5199 } 5200 ++pConstIter; 5201 } 5202 5203 ImageInfo aImageInfo; 5204 5205 if ( m_xParentImageManager.is() ) 5206 { 5207 names = m_xParentImageManager->getAllImageNames( GetImageType() ); 5208 for ( sal_Int32 n = 0; n < names.getLength(); n++ ) 5209 aImageInfo.insert( ImageInfo::value_type( names[n], false )); 5210 } 5211 5212 names = m_xImageManager->getAllImageNames( GetImageType() ); 5213 for ( sal_Int32 n = 0; n < names.getLength(); n++ ) 5214 { 5215 ImageInfo::iterator pIter = aImageInfo.find( names[n] ); 5216 if ( pIter != aImageInfo.end() ) 5217 pIter->second = true; 5218 else 5219 aImageInfo.insert( ImageInfo::value_type( names[n], true )); 5220 } 5221 5222 // large growth factor, expecting many entries 5223 pConstIter = aImageInfo.begin(); 5224 while ( pConstIter != aImageInfo.end() ) 5225 { 5226 name[ 0 ] = pConstIter->first; 5227 5228 uno::Sequence< uno::Reference< graphic::XGraphic> > graphics; 5229 try 5230 { 5231 if ( pConstIter->second ) 5232 graphics = m_xImageManager->getImages( GetImageType(), name ); 5233 else 5234 graphics = m_xParentImageManager->getImages( GetImageType(), name ); 5235 } 5236 catch ( uno::Exception& ) 5237 { 5238 // can't get sequence for this name so it will not be 5239 // added to the list 5240 } 5241 5242 if ( graphics.getLength() > 0 ) 5243 { 5244 Image img = Image( graphics[ 0 ] ); 5245 aTbSymbol.InsertItem( nId, img, pConstIter->first ); 5246 5247 uno::Reference< graphic::XGraphic > xGraphic = graphics[ 0 ]; 5248 5249 if ( xGraphic.is() ) 5250 xGraphic->acquire(); 5251 5252 aTbSymbol.SetItemData( 5253 nId, static_cast< void * > ( xGraphic.get() ) ); 5254 5255 ++nId; 5256 } 5257 5258 ++pConstIter; 5259 } 5260 5261 aBtnDelete.Enable( sal_False ); 5262 aTbSymbol.SetSelectHdl( LINK(this, SvxIconSelectorDialog, SelectHdl) ); 5263 aBtnImport.SetClickHdl( LINK(this, SvxIconSelectorDialog, ImportHdl) ); 5264 aBtnDelete.SetClickHdl( LINK(this, SvxIconSelectorDialog, DeleteHdl) ); 5265 5266 m_nNextId = aTbSymbol.GetItemCount()+1; 5267 } 5268 5269 SvxIconSelectorDialog::~SvxIconSelectorDialog() 5270 { 5271 sal_uInt16 nCount = aTbSymbol.GetItemCount(); 5272 5273 for (sal_uInt16 n = 0; n < nCount; n++ ) 5274 { 5275 sal_uInt16 nId = aTbSymbol.GetItemId(n); 5276 5277 uno::XInterface* xi = static_cast< uno::XInterface* >( 5278 aTbSymbol.GetItemData( nId ) ); 5279 5280 if ( xi != NULL ) 5281 { 5282 xi->release(); 5283 } 5284 } 5285 } 5286 5287 uno::Reference< graphic::XGraphic> SvxIconSelectorDialog::GetSelectedIcon() 5288 { 5289 uno::Reference< graphic::XGraphic > result; 5290 5291 sal_uInt16 nId; 5292 for ( sal_uInt16 n = 0; n < aTbSymbol.GetItemCount(); n++ ) 5293 { 5294 nId = aTbSymbol.GetItemId( n ); 5295 if ( aTbSymbol.IsItemChecked( nId ) ) 5296 { 5297 result = uno::Reference< graphic::XGraphic >( 5298 reinterpret_cast< graphic::XGraphic* >( 5299 aTbSymbol.GetItemData( nId ) ) ); 5300 } 5301 } 5302 5303 return result; 5304 } 5305 5306 IMPL_LINK( SvxIconSelectorDialog, SelectHdl, ToolBox *, pToolBox ) 5307 { 5308 (void)pToolBox; 5309 5310 sal_uInt16 nCount = aTbSymbol.GetItemCount(); 5311 5312 for (sal_uInt16 n = 0; n < nCount; n++ ) 5313 { 5314 sal_uInt16 nId = aTbSymbol.GetItemId( n ); 5315 5316 if ( aTbSymbol.IsItemChecked( nId ) ) 5317 { 5318 aTbSymbol.CheckItem( nId, sal_False ); 5319 } 5320 } 5321 5322 sal_uInt16 nId = aTbSymbol.GetCurItemId(); 5323 aTbSymbol.CheckItem( nId ); 5324 5325 ::rtl::OUString aSelImageText = aTbSymbol.GetItemText( nId ); 5326 if ( m_xImportedImageManager->hasImage( GetImageType(), aSelImageText ) ) 5327 { 5328 aBtnDelete.Enable( sal_True ); 5329 } 5330 else 5331 { 5332 aBtnDelete.Enable( sal_False ); 5333 } 5334 5335 return 0; 5336 } 5337 5338 IMPL_LINK( SvxIconSelectorDialog, ImportHdl, PushButton *, pButton ) 5339 { 5340 (void)pButton; 5341 5342 sfx2::FileDialogHelper aImportDialog( 5343 css::ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW, 5344 SFXWB_GRAPHIC | SFXWB_MULTISELECTION ); 5345 5346 // disable the link checkbox in the dialog 5347 uno::Reference< css::ui::dialogs::XFilePickerControlAccess > 5348 xController( aImportDialog.GetFilePicker(), uno::UNO_QUERY); 5349 if ( xController.is() ) 5350 { 5351 xController->enableControl( 5352 css::ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_LINK, 5353 sal_False); 5354 } 5355 5356 aImportDialog.SetCurrentFilter( 5357 String::CreateFromAscii( "PNG - Portable Network Graphic" ) ); 5358 5359 if ( ERRCODE_NONE == aImportDialog.Execute() ) 5360 { 5361 uno::Sequence< OUString > paths = aImportDialog.GetMPath(); 5362 ImportGraphics ( paths ); 5363 } 5364 5365 return 0; 5366 } 5367 5368 IMPL_LINK( SvxIconSelectorDialog, DeleteHdl, PushButton *, pButton ) 5369 { 5370 (void)pButton; 5371 5372 OUString message = String( CUI_RES( RID_SVXSTR_DELETE_ICON_CONFIRM ) ); 5373 bool ret = WarningBox( this, WinBits(WB_OK_CANCEL), message ).Execute(); 5374 5375 if ( ret == RET_OK ) 5376 { 5377 sal_uInt16 nCount = aTbSymbol.GetItemCount(); 5378 5379 for (sal_uInt16 n = 0; n < nCount; n++ ) 5380 { 5381 sal_uInt16 nId = aTbSymbol.GetItemId( n ); 5382 5383 if ( aTbSymbol.IsItemChecked( nId ) ) 5384 { 5385 ::rtl::OUString aSelImageText = aTbSymbol.GetItemText( nId ); 5386 uno::Sequence< OUString > URLs(1); 5387 URLs[0] = aSelImageText; 5388 aTbSymbol.RemoveItem( aTbSymbol.GetItemPos( nId ) ); 5389 m_xImportedImageManager->removeImages( GetImageType(), URLs ); 5390 uno::Reference< css::ui::XUIConfigurationPersistence > 5391 xConfigPersistence( m_xImportedImageManager, uno::UNO_QUERY ); 5392 if ( xConfigPersistence.is() && xConfigPersistence->isModified() ) 5393 { 5394 xConfigPersistence->store(); 5395 } 5396 break; 5397 } 5398 } 5399 } 5400 return 0; 5401 } 5402 5403 bool SvxIconSelectorDialog::ReplaceGraphicItem( 5404 const ::rtl::OUString& aURL ) 5405 { 5406 uno::Sequence< OUString > URLs(1); 5407 uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 ); 5408 uno::Reference< css::ui::XUIConfigurationPersistence > 5409 xConfigPer( m_xImportedImageManager, uno::UNO_QUERY ); 5410 5411 uno::Reference< graphic::XGraphic > xGraphic; 5412 uno::Sequence< beans::PropertyValue > aMediaProps( 1 ); 5413 aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL"); 5414 aMediaProps[0].Value <<= aURL; 5415 5416 com::sun::star::awt::Size aSize; 5417 bool bOK = sal_False; 5418 try 5419 { 5420 xGraphic = m_xGraphProvider->queryGraphic( aMediaProps ); 5421 5422 uno::Reference< beans::XPropertySet > props = 5423 m_xGraphProvider->queryGraphicDescriptor( aMediaProps ); 5424 uno::Any a = props->getPropertyValue( 5425 OUString::createFromAscii("SizePixel") ); 5426 a >>= aSize; 5427 if (0 == aSize.Width || 0 == aSize.Height) 5428 return sal_False; 5429 else 5430 bOK = sal_True; 5431 } 5432 catch ( uno::Exception& ) 5433 { 5434 return false; 5435 } 5436 5437 bool bResult( false ); 5438 sal_uInt16 nCount = aTbSymbol.GetItemCount(); 5439 for (sal_uInt16 n = 0; n < nCount; n++ ) 5440 { 5441 sal_uInt16 nId = aTbSymbol.GetItemId( n ); 5442 5443 if ( OUString( aTbSymbol.GetItemText( nId ) ) == aURL ) 5444 { 5445 try 5446 { 5447 // replace/insert image with provided URL 5448 aTbSymbol.RemoveItem( aTbSymbol.GetItemPos( nId ) ); 5449 aMediaProps[0].Value <<= aURL; 5450 5451 Image aImage( xGraphic ); 5452 if ( bOK && ((aSize.Width != m_nExpectedSize) || (aSize.Height != m_nExpectedSize)) ) 5453 { 5454 BitmapEx aBitmap = aImage.GetBitmapEx(); 5455 BitmapEx aBitmapex = AutoScaleBitmap(aBitmap, m_nExpectedSize); 5456 aImage = Image( aBitmapex); 5457 } 5458 aTbSymbol.InsertItem( nId,aImage, aURL, 0, 0 ); //modify 5459 5460 xGraphic = aImage.GetXGraphic(); 5461 5462 URLs[0] = aURL; 5463 aImportGraph[ 0 ] = xGraphic; 5464 m_xImportedImageManager->replaceImages( GetImageType(), URLs, aImportGraph ); 5465 xConfigPer->store(); 5466 5467 bResult = true; 5468 break; 5469 } 5470 catch ( ::com::sun::star::uno::Exception& ) 5471 { 5472 break; 5473 } 5474 } 5475 } 5476 5477 return bResult; 5478 } 5479 5480 void SvxIconSelectorDialog::ImportGraphics( 5481 const uno::Sequence< OUString >& rPaths ) 5482 { 5483 uno::Sequence< OUString > rejected( rPaths.getLength() ); 5484 sal_Int32 rejectedCount = 0; 5485 5486 sal_uInt16 ret = 0; 5487 sal_Int32 aIndex; 5488 OUString aIconName; 5489 uno::Sequence< OUString > URLs(1); 5490 uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 ); 5491 uno::Sequence< beans::PropertyValue > aMediaProps( 1 ); 5492 aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL"); 5493 uno::Reference< css::ui::XUIConfigurationPersistence > 5494 xConfigPer( m_xImportedImageManager, uno::UNO_QUERY ); 5495 5496 if ( rPaths.getLength() == 1 ) 5497 { 5498 if ( m_xImportedImageManager->hasImage( GetImageType(), rPaths[0] ) ) 5499 { 5500 aIndex = rPaths[0].lastIndexOf( '/' ); 5501 aIconName = rPaths[0].copy( aIndex+1 ); 5502 ret = SvxIconReplacementDialog( this, aIconName ).ShowDialog(); 5503 if ( ret == 2 ) 5504 { 5505 ReplaceGraphicItem( rPaths[0] ); 5506 } 5507 } 5508 else 5509 { 5510 if ( ImportGraphic( rPaths[0] ) == sal_False ) 5511 { 5512 rejected[0] = rPaths[0]; 5513 rejectedCount = 1; 5514 } 5515 } 5516 } 5517 else 5518 { 5519 ::rtl::OUString aSourcePath( rPaths[0] ); 5520 if ( rPaths[0].lastIndexOf( '/' ) != rPaths[0].getLength() -1 ) 5521 aSourcePath = rPaths[0] + ::rtl::OUString::createFromAscii( "/" ); 5522 5523 for ( sal_Int32 i = 1; i < rPaths.getLength(); i++ ) 5524 { 5525 ::rtl::OUString aPath = aSourcePath + rPaths[i]; 5526 if ( m_xImportedImageManager->hasImage( GetImageType(), aPath ) ) 5527 { 5528 aIndex = rPaths[i].lastIndexOf( '/' ); 5529 aIconName = rPaths[i].copy( aIndex+1 ); 5530 ret = SvxIconReplacementDialog( this, aIconName, sal_True ).ShowDialog(); 5531 if ( ret == 2 ) 5532 { 5533 ReplaceGraphicItem( aPath ); 5534 } 5535 else if ( ret == 5 ) 5536 { 5537 for ( sal_Int32 k = i; k < rPaths.getLength(); k++ ) 5538 { 5539 aPath = aSourcePath + rPaths[k]; 5540 bool bHasReplaced = ReplaceGraphicItem( aPath ); 5541 5542 if ( !bHasReplaced ) 5543 { 5544 bool result = ImportGraphic( aPath ); 5545 if ( result == sal_False ) 5546 { 5547 rejected[ rejectedCount ] = rPaths[i]; 5548 rejectedCount++; 5549 } 5550 } 5551 } 5552 break; 5553 } 5554 } 5555 else 5556 { 5557 bool result = ImportGraphic( aSourcePath + rPaths[i] ); 5558 if ( result == sal_False ) 5559 { 5560 rejected[ rejectedCount ] = rPaths[i]; 5561 rejectedCount++; 5562 } 5563 } 5564 } 5565 } 5566 5567 if ( rejectedCount != 0 ) 5568 { 5569 OUString message =OUString::createFromAscii(""); 5570 OUString newLine = OUString::createFromAscii("\n"); 5571 rtl::OUString fPath = OUString::createFromAscii(""); 5572 if (rejectedCount > 1) 5573 fPath = rPaths[0].copy(8) + ::rtl::OUString::createFromAscii( "/" ); 5574 for ( sal_Int32 i = 0; i < rejectedCount; i++ ) 5575 { 5576 message += fPath + rejected[i]; 5577 message += newLine; 5578 } 5579 5580 SvxIconChangeDialog aDialog(this, message); 5581 aDialog.Execute(); 5582 } 5583 } 5584 5585 bool SvxIconSelectorDialog::ImportGraphic( const OUString& aURL ) 5586 { 5587 bool result = sal_False; 5588 5589 sal_uInt16 nId = m_nNextId; 5590 ++m_nNextId; 5591 5592 uno::Sequence< beans::PropertyValue > aMediaProps( 1 ); 5593 aMediaProps[0].Name = ::rtl::OUString::createFromAscii("URL"); 5594 5595 uno::Reference< graphic::XGraphic > xGraphic; 5596 com::sun::star::awt::Size aSize; 5597 bool bOK = sal_True; 5598 aMediaProps[0].Value <<= aURL; 5599 try 5600 { 5601 uno::Reference< beans::XPropertySet > props = 5602 m_xGraphProvider->queryGraphicDescriptor( aMediaProps ); 5603 5604 uno::Any a = props->getPropertyValue( 5605 OUString::createFromAscii("SizePixel") ); 5606 5607 xGraphic = m_xGraphProvider->queryGraphic( aMediaProps ); 5608 if ( xGraphic.is() ) 5609 { 5610 a >>= aSize; 5611 if ( 0 == aSize.Width || 0 == aSize.Height ) 5612 bOK = sal_False; 5613 5614 Image aImage( xGraphic ); 5615 5616 if ( bOK && ((aSize.Width != m_nExpectedSize) || (aSize.Height != m_nExpectedSize)) ) 5617 { 5618 BitmapEx aBitmap = aImage.GetBitmapEx(); 5619 BitmapEx aBitmapex = AutoScaleBitmap(aBitmap, m_nExpectedSize); 5620 aImage = Image( aBitmapex); 5621 } 5622 if ( bOK && !!aImage ) 5623 { 5624 aTbSymbol.InsertItem( nId, aImage, aURL, 0, 0 ); 5625 5626 xGraphic = aImage.GetXGraphic(); 5627 xGraphic->acquire(); 5628 5629 aTbSymbol.SetItemData( 5630 nId, static_cast< void * > ( xGraphic.get() ) ); 5631 uno::Sequence< OUString > aImportURL( 1 ); 5632 aImportURL[ 0 ] = aURL; 5633 uno::Sequence< uno::Reference<graphic::XGraphic > > aImportGraph( 1 ); 5634 aImportGraph[ 0 ] = xGraphic; 5635 m_xImportedImageManager->insertImages( GetImageType(), aImportURL, aImportGraph ); 5636 uno::Reference< css::ui::XUIConfigurationPersistence > 5637 xConfigPersistence( m_xImportedImageManager, uno::UNO_QUERY ); 5638 5639 if ( xConfigPersistence.is() && xConfigPersistence->isModified() ) 5640 { 5641 xConfigPersistence->store(); 5642 } 5643 5644 result = sal_True; 5645 } 5646 else 5647 { 5648 OSL_TRACE("could not create Image from XGraphic"); 5649 } 5650 } 5651 else 5652 { 5653 OSL_TRACE("could not get query XGraphic"); 5654 } 5655 } 5656 catch( uno::Exception& e ) 5657 { 5658 OSL_TRACE("Caught exception importing XGraphic: %s", PRTSTR(e.Message)); 5659 } 5660 return result; 5661 } 5662 5663 /******************************************************************************* 5664 * 5665 * The SvxIconReplacementDialog class 5666 * 5667 *******************************************************************************/ 5668 SvxIconReplacementDialog :: SvxIconReplacementDialog( 5669 Window *pWindow, const rtl::OUString& aMessage, bool /*bYestoAll*/ ) 5670 : 5671 MessBox( pWindow, WB_DEF_YES, String( CUI_RES( RID_SVXSTR_REPLACE_ICON_CONFIRM ) ), String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) ) ) 5672 5673 { 5674 SetImage( WarningBox::GetStandardImage() ); 5675 SetMessText( ReplaceIconName( aMessage ) ); 5676 RemoveButton( 1 ); 5677 AddButton( BUTTON_YES, 2, 0 ); 5678 AddButton( String( CUI_RES( RID_SVXSTR_YESTOALL ) ), 5, 0 ); 5679 AddButton( BUTTON_NO, 3, 0 ); 5680 AddButton( BUTTON_CANCEL, 4, 0 ); 5681 } 5682 5683 SvxIconReplacementDialog :: SvxIconReplacementDialog( 5684 Window *pWindow, const rtl::OUString& aMessage ) 5685 : 5686 MessBox( pWindow, WB_YES_NO_CANCEL, String( CUI_RES( RID_SVXSTR_REPLACE_ICON_CONFIRM ) ), String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) ) ) 5687 { 5688 SetImage( WarningBox::GetStandardImage() ); 5689 SetMessText( ReplaceIconName( aMessage )); 5690 } 5691 5692 rtl::OUString SvxIconReplacementDialog :: ReplaceIconName( const OUString& rMessage ) 5693 { 5694 rtl::OUString name; 5695 rtl::OUString message = String( CUI_RES( RID_SVXSTR_REPLACE_ICON_WARNING ) ); 5696 rtl::OUString placeholder = OUString::createFromAscii( "%ICONNAME" ); 5697 sal_Int32 pos = message.indexOf( placeholder ); 5698 if ( pos != -1 ) 5699 { 5700 name = message.replaceAt( 5701 pos, placeholder.getLength(), rMessage ); 5702 } 5703 return name; 5704 } 5705 5706 sal_uInt16 SvxIconReplacementDialog :: ShowDialog() 5707 { 5708 this->Execute(); 5709 return ( this->GetCurButtonId() ); 5710 } 5711 /******************************************************************************* 5712 * 5713 * The SvxIconChangeDialog class added for issue83555 5714 * 5715 *******************************************************************************/ 5716 SvxIconChangeDialog::SvxIconChangeDialog( 5717 Window *pWindow, const rtl::OUString& aMessage) 5718 : 5719 ModalDialog ( pWindow, CUI_RES( MD_ICONCHANGE ) ), 5720 aFImageInfo (this, CUI_RES( FI_INFO ) ), 5721 aBtnOK (this, CUI_RES(MD_BTN_OK)), 5722 aDescriptionLabel (this, CUI_RES(FTCHGE_DESCRIPTION)), 5723 aLineEditDescription (this, CUI_RES(EDT_ADDR)) 5724 { 5725 FreeResource(); 5726 aFImageInfo.SetImage(InfoBox::GetStandardImage()); 5727 aLineEditDescription.SetControlBackground( GetSettings().GetStyleSettings().GetDialogColor() ); 5728 aLineEditDescription.SetAutoScroll( sal_True ); 5729 aLineEditDescription.EnableCursor( sal_False ); 5730 aLineEditDescription.SetText(aMessage); 5731 } 5732 5733 BitmapEx SvxIconSelectorDialog::AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize) 5734 { 5735 Point aEmptyPoint(0,0); 5736 sal_Int32 imgNewWidth = 0; 5737 sal_Int32 imgNewHeight = 0; 5738 double imgposX = 0; 5739 double imgposY = 0; 5740 BitmapEx aRet = aBitmap; 5741 double imgOldWidth = aRet.GetSizePixel().Width(); 5742 double imgOldHeight =aRet.GetSizePixel().Height(); 5743 5744 Size aScaledSize; 5745 if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize) 5746 { 5747 if (imgOldWidth >= imgOldHeight) 5748 { 5749 imgNewWidth = aStandardSize; 5750 imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5); 5751 imgposX = 0; 5752 imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5; 5753 } 5754 else 5755 { 5756 imgNewHeight = aStandardSize; 5757 imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5); 5758 imgposY = 0; 5759 imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5; 5760 } 5761 5762 aScaledSize = Size( imgNewWidth, imgNewHeight ); 5763 aRet.Scale( aScaledSize, BMP_SCALE_INTERPOLATE ); 5764 } 5765 else 5766 { 5767 imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5; 5768 imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5; 5769 } 5770 5771 Size aBmpSize = aRet.GetSizePixel(); 5772 Size aStdSize( aStandardSize, aStandardSize ); 5773 Rectangle aRect(aEmptyPoint, aStdSize ); 5774 5775 VirtualDevice aVirDevice( *Application::GetDefaultDevice(), 0, 1 ); 5776 aVirDevice.SetOutputSizePixel( aStdSize ); 5777 aVirDevice.SetFillColor( COL_TRANSPARENT ); 5778 aVirDevice.SetLineColor( COL_TRANSPARENT ); 5779 5780 //draw a rect into virDevice 5781 aVirDevice.DrawRect( aRect ); 5782 Point aPointPixel( (long)imgposX, (long)imgposY ); 5783 aVirDevice.DrawBitmapEx( aPointPixel, aRet ); 5784 aRet = aVirDevice.GetBitmapEx( aEmptyPoint, aStdSize ); 5785 5786 return aRet; 5787 } 5788