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