Line data Source code
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 :
21 : #include "ToolBarManager.hxx"
22 :
23 : #include "DrawViewShell.hxx"
24 : #include "EventMultiplexer.hxx"
25 : #include "ViewShellBase.hxx"
26 : #include "ViewShellManager.hxx"
27 : #include <com/sun/star/beans/XPropertySet.hpp>
28 : #include <com/sun/star/frame/XLayoutManager.hpp>
29 : #include <com/sun/star/ui/UIElementType.hpp>
30 :
31 : #include <cppuhelper/implbase1.hxx>
32 : #include <osl/mutex.hxx>
33 : #include <rtl/ref.hxx>
34 : #include <sfx2/app.hxx>
35 : #include <sfx2/docfile.hxx>
36 : #include <sfx2/objsh.hxx>
37 : #include <sfx2/request.hxx>
38 : #include <sfx2/viewfrm.hxx>
39 : #include <svl/eitem.hxx>
40 : #include <svx/dialogs.hrc>
41 : #include <svx/extrusionbar.hxx>
42 : #include <svx/fontworkbar.hxx>
43 : #include <toolkit/helper/vclunohelper.hxx>
44 : #include <tools/link.hxx>
45 :
46 : #include <map>
47 : #include <vector>
48 :
49 : using namespace ::com::sun::star;
50 : using namespace ::com::sun::star::uno;
51 :
52 : namespace {
53 :
54 : using namespace sd;
55 :
56 : class ToolBarRules;
57 :
58 : /** Lock of the frame::XLayoutManager.
59 : */
60 : class LayouterLock
61 : {
62 : public:
63 : LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter);
64 : ~LayouterLock (void);
65 : private:
66 : Reference<frame::XLayoutManager> mxLayouter;
67 : };
68 :
69 :
70 : typedef ::std::vector<OUString> NameList;
71 :
72 : /** Store a list of tool bars for each of the tool bar groups. From
73 : this the list of requested tool bars is built.
74 : */
75 0 : class ToolBarList
76 : {
77 : public:
78 : ToolBarList (void);
79 :
80 : void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup);
81 : void AddToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const OUString& rsName);
82 : bool RemoveToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const OUString& rsName);
83 :
84 : void GetToolBarsToActivate (NameList& rToolBars) const;
85 : void GetToolBarsToDeactivate (NameList& rToolBars) const;
86 :
87 : void MarkToolBarAsActive (const OUString& rsName);
88 : void MarkToolBarAsNotActive (const OUString& rsName);
89 : void MarkAllToolBarsAsNotActive (void);
90 :
91 : private:
92 : typedef ::std::map<sd::ToolBarManager::ToolBarGroup,NameList> Groups;
93 : Groups maGroups;
94 : NameList maActiveToolBars;
95 :
96 : void MakeRequestedToolBarList (NameList& rToolBars) const;
97 : };
98 :
99 :
100 :
101 :
102 : /** Manage tool bars that are implemented as sub shells of a view shell.
103 : The typical procedure of updating the sub shells of a view shell is to
104 : rebuild a list of sub shells that the caller would like to have active.
105 : The methods ClearGroup() and AddShellId() allow the caller to do that. A
106 : final call to UpdateShells() activates the requested shells that are not
107 : active and deactivates the active shells that are not requested .
108 :
109 : This is done by maintaining two lists. One (the current list)
110 : reflects the current state. The other (the requested list) contains the
111 : currently requested shells. UpdateShells() makes the requested
112 : list the current list and clears the current list.
113 :
114 : Each shell belongs to one group. Different groups can be modified
115 : separately.
116 : */
117 0 : class ToolBarShellList
118 : {
119 : public:
120 : /** Create a new object with an empty current list and an empty
121 : requested list.
122 : */
123 : ToolBarShellList (void);
124 :
125 : /** Remove all shells from a group. Calling this method should normally
126 : not be necessary because after the construction or after a call to
127 : UpdateShells() the requested list is empty.
128 : @param eGroup
129 : The group to clear. Shells in other groups are not modified.
130 : */
131 : void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup);
132 :
133 : /** Add a shell. When the specified shell has alreadt been requested
134 : for another group then it is moved to this group.
135 : @param eGroup
136 : The group to which to add the shell.
137 : @param nId
138 : The id of the shell to add.
139 : */
140 : void AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId);
141 :
142 : /** Releasing all shells means that the given ToolBarRules object is
143 : informed that every shell mananged by the called ToolBarShellList is
144 : about to be removed and that the associated framework tool bars can
145 : be removed as well. The caller still has to call UpdateShells().
146 : */
147 : void ReleaseAllShells (ToolBarRules& rRules);
148 :
149 : /** The requested list is made the current list by activating all
150 : shells in the requested list and by deactivating the shells in the
151 : current list that are not in the requested list.
152 : @param pMainViewShell
153 : The shells that are activated or deactivated are sub shells of
154 : this view shell.
155 : @param rManager
156 : This ViewShellManager is used to activate or deactivate shells.
157 : */
158 : void UpdateShells (
159 : const ::boost::shared_ptr<ViewShell>& rpMainViewShell,
160 : const ::boost::shared_ptr<ViewShellManager>& rpManager);
161 :
162 : private:
163 : class ShellDescriptor
164 : {public:
165 : ShellDescriptor (ShellId nId,sd::ToolBarManager::ToolBarGroup eGroup);
166 : ShellId mnId;
167 : sd::ToolBarManager::ToolBarGroup meGroup;
168 0 : friend bool operator<(const ShellDescriptor& r1, const ShellDescriptor& r2)
169 0 : { return r1.mnId < r2.mnId; }
170 : };
171 :
172 : /** The requested list of tool bar shells that will be active after the
173 : next call to UpdateShells().
174 : */
175 : typedef ::std::set<ShellDescriptor> GroupedShellList;
176 : GroupedShellList maNewList;
177 :
178 : /** The list of tool bar shells that are currently on the shell stack.
179 : Using a GroupedShellList is not strictly necessary but it makes
180 : things easier and does not waste too much memory.
181 : */
182 : GroupedShellList maCurrentList;
183 : };
184 :
185 :
186 :
187 :
188 : /** This class concentrates the knowledge about when to show what tool bars
189 : in one place.
190 : */
191 0 : class ToolBarRules
192 : {
193 : public:
194 : ToolBarRules (
195 : const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager,
196 : const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager);
197 :
198 : /** This method calls MainViewShellChanged() and SelectionHasChanged()
199 : for the current main view shell and its view.
200 : */
201 : void Update (ViewShellBase& rBase);
202 :
203 : /** Reset all tool bars in all groups and add tool bars and tool bar
204 : shells to the TBG_PERMANENT group for the specified ViewShell type.
205 : */
206 : void MainViewShellChanged (ViewShell::ShellType nShellType);
207 :
208 : /** Reset all tool bars in all groups and add tool bars and tool bar
209 : shells to the TBG_PERMANENT group for the specified ViewShell.
210 : */
211 : void MainViewShellChanged (const ViewShell& rMainViewShell);
212 :
213 : /** Reset all tool bars in the TBG_FUNCTION group and add tool bars and tool bar
214 : shells to this group for the current selection.
215 : */
216 : void SelectionHasChanged (
217 : const ::sd::ViewShell& rViewShell,
218 : const SdrView& rView);
219 :
220 : /** Add a tool bar for the specified tool bar shell.
221 : */
222 : void SubShellAdded (
223 : ::sd::ToolBarManager::ToolBarGroup eGroup,
224 : sd::ShellId nShellId);
225 :
226 : /** Remove a tool bar for the specified tool bar shell.
227 : */
228 : void SubShellRemoved (
229 : ::sd::ToolBarManager::ToolBarGroup eGroup,
230 : sd::ShellId nShellId);
231 :
232 : private:
233 : ::boost::shared_ptr<ToolBarManager> mpToolBarManager;
234 : ::boost::shared_ptr<ViewShellManager> mpViewShellManager;
235 : };
236 :
237 : } // end of anonymous namespace
238 :
239 :
240 :
241 :
242 : namespace sd {
243 :
244 : //===== ToolBarManager::Implementation ========================================
245 :
246 : class ToolBarManager::Implementation
247 : {
248 : public:
249 : /** This constructor takes three arguments even though the
250 : ToolBarManager could be taken from the ViewShellBase. This is so to
251 : state explicitly which information has to be present when this
252 : constructor is called. The ViewShellBase may not have been fully
253 : initialized at this point and must not be asked for this values.
254 : */
255 : Implementation (
256 : ViewShellBase& rBase,
257 : const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
258 : const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager,
259 : const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager);
260 : ~Implementation (void);
261 :
262 : void SetValid (bool bValid);
263 :
264 : void ResetToolBars (ToolBarGroup eGroup);
265 : void ResetAllToolBars (void);
266 : void AddToolBar (ToolBarGroup eGroup, const OUString& rsToolBarName);
267 : void AddToolBarShell (ToolBarGroup eGroup, ShellId nToolBarId);
268 : void RemoveToolBar (ToolBarGroup eGroup, const OUString& rsToolBarName);
269 :
270 : /** Release all tool bar shells and the associated framework tool bars.
271 : Typically called when the main view shell is being replaced by
272 : another, all tool bar shells are released. In that process the
273 : shells are destroyed anyway and without calling this method they
274 : would still be referenced.
275 : */
276 : void ReleaseAllToolBarShells (void);
277 :
278 : void ToolBarsDestroyed(void);
279 :
280 : void RequestUpdate (void);
281 :
282 : void PreUpdate (void);
283 : void PostUpdate (void);
284 : /** Tell the XLayoutManager about the tool bars that we would like to be
285 : shown.
286 : @param rpLayouterLock
287 : This typically is the mpSynchronousLayouterLock that is used in
288 : this method and that is either released at its end or assigned
289 : to mpAsynchronousLock in order to be unlocked later.
290 : */
291 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
292 : void Update (::std::auto_ptr<LayouterLock> pLayouterLock);
293 : SAL_WNODEPRECATED_DECLARATIONS_POP
294 :
295 : class UpdateLockImplementation
296 : {
297 : public:
298 0 : UpdateLockImplementation (Implementation& rImplementation)
299 0 : : mrImplementation(rImplementation) { mrImplementation.LockUpdate(); }
300 0 : ~UpdateLockImplementation (void) { mrImplementation.UnlockUpdate(); }
301 : private:
302 : Implementation& mrImplementation;
303 : };
304 :
305 : void LockViewShellManager (void);
306 : void LockUpdate (void);
307 : void UnlockUpdate (void);
308 :
309 : ToolBarRules& GetToolBarRules (void);
310 :
311 : private:
312 : const static OUString msToolBarResourcePrefix;
313 :
314 : mutable ::osl::Mutex maMutex;
315 : ViewShellBase& mrBase;
316 : ::boost::shared_ptr<sd::tools::EventMultiplexer> mpEventMultiplexer;
317 : bool mbIsValid;
318 : ToolBarList maToolBarList;
319 : ToolBarShellList maToolBarShellList;
320 : Reference<frame::XLayoutManager> mxLayouter;
321 : sal_Int32 mnLockCount;
322 : bool mbPreUpdatePending;
323 : bool mbPostUpdatePending;
324 : /** The layouter locks manage the locking of the XLayoutManager. The
325 : lock() and unlock() functions are not called directly because the
326 : (final) unlocking is usually done asynchronously *after* the
327 : list of requested toolbars is updated.
328 : */
329 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
330 : ::std::auto_ptr<LayouterLock> mpSynchronousLayouterLock;
331 : ::std::auto_ptr<LayouterLock> mpAsynchronousLayouterLock;
332 : ::std::auto_ptr<ViewShellManager::UpdateLock> mpViewShellManagerLock;
333 : SAL_WNODEPRECATED_DECLARATIONS_POP
334 : sal_uLong mnPendingUpdateCall;
335 : sal_uLong mnPendingSetValidCall;
336 : ToolBarRules maToolBarRules;
337 :
338 : OUString GetToolBarResourceName (const OUString& rsBaseName) const;
339 : bool CheckPlugInMode (const OUString& rsName) const;
340 :
341 : DECL_LINK(UpdateCallback, void *);
342 : DECL_LINK(EventMultiplexerCallback, sd::tools::EventMultiplexerEvent*);
343 : DECL_LINK(SetValidCallback,void*);
344 : };
345 :
346 :
347 :
348 : //===== ToolBarManager ========================================================
349 :
350 0 : const OUString ToolBarManager::msToolBar("toolbar");
351 0 : const OUString ToolBarManager::msOptionsToolBar("optionsbar");
352 0 : const OUString ToolBarManager::msCommonTaskToolBar("commontaskbar");
353 0 : const OUString ToolBarManager::msViewerToolBar("viewerbar");
354 0 : const OUString ToolBarManager::msSlideSorterToolBar("slideviewtoolbar");
355 0 : const OUString ToolBarManager::msSlideSorterObjectBar("slideviewobjectbar");
356 0 : const OUString ToolBarManager::msOutlineToolBar("outlinetoolbar");
357 0 : const OUString ToolBarManager::msMasterViewToolBar("masterviewtoolbar");
358 0 : const OUString ToolBarManager::msDrawingObjectToolBar("drawingobjectbar");
359 0 : const OUString ToolBarManager::msGluePointsToolBar("gluepointsobjectbar");
360 0 : const OUString ToolBarManager::msTextObjectBar("textobjectbar");
361 0 : const OUString ToolBarManager::msBezierObjectBar("bezierobjectbar");
362 0 : const OUString ToolBarManager::msGraphicObjectBar("graphicobjectbar");
363 0 : const OUString ToolBarManager::msMediaObjectBar("mediaobjectbar");
364 0 : const OUString ToolBarManager::msTableObjectBar("tableobjectbar");
365 :
366 :
367 0 : ::boost::shared_ptr<ToolBarManager> ToolBarManager::Create (
368 : ViewShellBase& rBase,
369 : const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
370 : const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager)
371 : {
372 0 : ::boost::shared_ptr<ToolBarManager> pManager (new ToolBarManager());
373 0 : pManager->mpImpl.reset(
374 0 : new Implementation(rBase,rpMultiplexer,rpViewShellManager,pManager));
375 0 : return pManager;
376 : }
377 :
378 :
379 :
380 :
381 0 : ToolBarManager::ToolBarManager (void)
382 0 : : mpImpl()
383 : {
384 0 : }
385 :
386 :
387 :
388 :
389 0 : ToolBarManager::~ToolBarManager (void)
390 : {
391 0 : }
392 :
393 :
394 :
395 :
396 0 : void ToolBarManager::Shutdown (void)
397 : {
398 0 : if (mpImpl.get() != NULL)
399 0 : mpImpl.reset();
400 0 : }
401 :
402 :
403 :
404 :
405 0 : void ToolBarManager::ResetToolBars (ToolBarGroup eGroup)
406 : {
407 0 : if (mpImpl.get() != NULL)
408 : {
409 0 : UpdateLock aLock (shared_from_this());
410 0 : mpImpl->ResetToolBars(eGroup);
411 : }
412 0 : }
413 :
414 :
415 :
416 :
417 0 : void ToolBarManager::ResetAllToolBars (void)
418 : {
419 0 : if (mpImpl.get() != NULL)
420 : {
421 0 : UpdateLock aLock (shared_from_this());
422 0 : mpImpl->ResetAllToolBars();
423 : }
424 0 : }
425 :
426 :
427 :
428 :
429 0 : void ToolBarManager::AddToolBar (
430 : ToolBarGroup eGroup,
431 : const OUString& rsToolBarName)
432 : {
433 0 : if (mpImpl.get() != NULL)
434 : {
435 0 : UpdateLock aLock (shared_from_this());
436 0 : mpImpl->AddToolBar(eGroup,rsToolBarName);
437 : }
438 0 : }
439 :
440 :
441 :
442 :
443 0 : void ToolBarManager::AddToolBarShell (
444 : ToolBarGroup eGroup,
445 : ShellId nToolBarId)
446 : {
447 0 : if (mpImpl.get() != NULL)
448 : {
449 0 : UpdateLock aLock (shared_from_this());
450 0 : mpImpl->AddToolBarShell(eGroup,nToolBarId);
451 : }
452 0 : }
453 :
454 :
455 :
456 :
457 0 : void ToolBarManager::RemoveToolBar (
458 : ToolBarGroup eGroup,
459 : const OUString& rsToolBarName)
460 : {
461 0 : if (mpImpl.get() != NULL)
462 : {
463 0 : UpdateLock aLock (shared_from_this());
464 0 : mpImpl->RemoveToolBar(eGroup,rsToolBarName);
465 : }
466 0 : }
467 :
468 :
469 :
470 :
471 0 : void ToolBarManager::SetToolBar (
472 : ToolBarGroup eGroup,
473 : const OUString& rsToolBarName)
474 : {
475 0 : if (mpImpl.get() != NULL)
476 : {
477 0 : UpdateLock aLock (shared_from_this());
478 0 : mpImpl->ResetToolBars(eGroup);
479 0 : mpImpl->AddToolBar(eGroup,rsToolBarName);
480 : }
481 0 : }
482 :
483 :
484 :
485 :
486 0 : void ToolBarManager::SetToolBarShell (
487 : ToolBarGroup eGroup,
488 : ShellId nToolBarId)
489 : {
490 0 : if (mpImpl.get() != NULL)
491 : {
492 0 : UpdateLock aLock (shared_from_this());
493 0 : mpImpl->ResetToolBars(eGroup);
494 0 : mpImpl->AddToolBarShell(eGroup,nToolBarId);
495 : }
496 0 : }
497 :
498 :
499 :
500 :
501 0 : void ToolBarManager::PreUpdate (void)
502 : {
503 0 : if (mpImpl.get()!=NULL)
504 0 : mpImpl->PreUpdate();
505 0 : }
506 :
507 :
508 :
509 :
510 0 : void ToolBarManager::RequestUpdate (void)
511 : {
512 0 : if (mpImpl.get()!=NULL)
513 0 : mpImpl->RequestUpdate();
514 0 : }
515 :
516 :
517 :
518 :
519 0 : void ToolBarManager::LockViewShellManager (void)
520 : {
521 0 : if (mpImpl.get() != NULL)
522 0 : mpImpl->LockViewShellManager();
523 0 : }
524 :
525 :
526 :
527 :
528 0 : void ToolBarManager::LockUpdate (void)
529 : {
530 0 : if (mpImpl.get()!=NULL)
531 0 : mpImpl->LockUpdate();
532 0 : }
533 :
534 :
535 :
536 :
537 0 : void ToolBarManager::UnlockUpdate (void)
538 : {
539 0 : if (mpImpl.get()!=NULL)
540 0 : mpImpl->UnlockUpdate();
541 0 : }
542 :
543 :
544 :
545 :
546 0 : void ToolBarManager::MainViewShellChanged (ViewShell::ShellType nShellType)
547 : {
548 0 : if (mpImpl.get() != NULL)
549 : {
550 0 : mpImpl->ReleaseAllToolBarShells();
551 0 : mpImpl->GetToolBarRules().MainViewShellChanged(nShellType);
552 : }
553 0 : }
554 :
555 :
556 :
557 :
558 0 : void ToolBarManager::MainViewShellChanged (const ViewShell& rMainViewShell)
559 : {
560 0 : if (mpImpl.get() != NULL)
561 : {
562 0 : mpImpl->ReleaseAllToolBarShells();
563 0 : mpImpl->GetToolBarRules().MainViewShellChanged(rMainViewShell);
564 : }
565 0 : }
566 :
567 :
568 :
569 :
570 0 : void ToolBarManager::SelectionHasChanged (
571 : const ViewShell& rViewShell,
572 : const SdrView& rView)
573 : {
574 0 : if (mpImpl.get() != NULL)
575 0 : mpImpl->GetToolBarRules().SelectionHasChanged(rViewShell,rView);
576 0 : }
577 :
578 :
579 0 : void ToolBarManager::ToolBarsDestroyed(void)
580 : {
581 0 : if (mpImpl.get() != NULL)
582 0 : mpImpl->ToolBarsDestroyed();
583 0 : }
584 :
585 :
586 : //===== ToolBarManager::Implementation =======================================
587 :
588 0 : const OUString ToolBarManager::Implementation::msToolBarResourcePrefix("private:resource/toolbar/");
589 :
590 0 : ToolBarManager::Implementation::Implementation (
591 : ViewShellBase& rBase,
592 : const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
593 : const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager,
594 : const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager)
595 : : maMutex(),
596 : mrBase(rBase),
597 : mpEventMultiplexer(rpMultiplexer),
598 : mbIsValid(false),
599 : maToolBarList(),
600 : maToolBarShellList(),
601 : mxLayouter(NULL),
602 : mnLockCount(0),
603 : mbPreUpdatePending(false),
604 : mbPostUpdatePending(false),
605 : mpSynchronousLayouterLock(),
606 : mpAsynchronousLayouterLock(),
607 : mpViewShellManagerLock(),
608 : mnPendingUpdateCall(0),
609 : mnPendingSetValidCall(0),
610 0 : maToolBarRules(rpToolBarManager,rpViewShellManager)
611 : {
612 0 : Link aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback));
613 : mpEventMultiplexer->AddEventListener(
614 : aLink,
615 : tools::EventMultiplexerEvent::EID_CONTROLLER_ATTACHED
616 : | tools::EventMultiplexerEvent::EID_CONTROLLER_DETACHED
617 0 : | tools::EventMultiplexerEvent::EID_PANE_MANAGER_DYING);
618 0 : }
619 :
620 :
621 :
622 : /** The order of statements is important.
623 : First unregister listeners, which may post user events.
624 : Then remove pending user events.
625 : */
626 0 : ToolBarManager::Implementation::~Implementation (void)
627 : {
628 : // Unregister at broadcasters.
629 0 : Link aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback));
630 0 : mpEventMultiplexer->RemoveEventListener(aLink);
631 :
632 : // Abort pending user calls.
633 0 : if (mnPendingUpdateCall != 0)
634 0 : Application::RemoveUserEvent(mnPendingUpdateCall);
635 0 : if (mnPendingSetValidCall != 0)
636 0 : Application::RemoveUserEvent(mnPendingSetValidCall);
637 0 : }
638 :
639 :
640 0 : void ToolBarManager::Implementation::ToolBarsDestroyed(void)
641 : {
642 0 : maToolBarList.MarkAllToolBarsAsNotActive();
643 0 : }
644 :
645 :
646 0 : void ToolBarManager::Implementation::SetValid (bool bValid)
647 : {
648 0 : ::osl::MutexGuard aGuard(maMutex);
649 :
650 0 : if (mbIsValid != bValid)
651 : {
652 0 : UpdateLockImplementation aUpdateLock (*this);
653 :
654 0 : mbIsValid = bValid;
655 0 : if (mbIsValid)
656 : {
657 0 : Reference<frame::XFrame> xFrame;
658 0 : if (mrBase.GetViewFrame() != NULL)
659 0 : xFrame = mrBase.GetViewFrame()->GetFrame().GetFrameInterface();
660 : try
661 : {
662 0 : Reference<beans::XPropertySet> xFrameProperties (xFrame, UNO_QUERY_THROW);
663 0 : Any aValue (xFrameProperties->getPropertyValue("LayoutManager"));
664 0 : aValue >>= mxLayouter;
665 : }
666 0 : catch (const RuntimeException&)
667 : {
668 : }
669 :
670 0 : GetToolBarRules().Update(mrBase);
671 : }
672 : else
673 : {
674 0 : ResetAllToolBars();
675 0 : mxLayouter = NULL;
676 0 : }
677 0 : }
678 0 : }
679 :
680 :
681 :
682 :
683 0 : void ToolBarManager::Implementation::ResetToolBars (ToolBarGroup eGroup)
684 : {
685 0 : ::osl::MutexGuard aGuard(maMutex);
686 :
687 0 : maToolBarList.ClearGroup(eGroup);
688 0 : maToolBarShellList.ClearGroup(eGroup);
689 :
690 0 : mbPreUpdatePending = true;
691 0 : }
692 :
693 :
694 :
695 :
696 0 : void ToolBarManager::Implementation::ResetAllToolBars (void)
697 : {
698 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": resetting all tool bars");
699 0 : for (int i=TBG__FIRST; i<=TBG__LAST; ++i)
700 0 : ResetToolBars((ToolBarGroup)i);
701 0 : }
702 :
703 :
704 :
705 :
706 0 : void ToolBarManager::Implementation::AddToolBar (
707 : ToolBarGroup eGroup,
708 : const OUString& rsToolBarName)
709 : {
710 0 : ::osl::MutexGuard aGuard(maMutex);
711 :
712 0 : if (CheckPlugInMode(rsToolBarName))
713 : {
714 0 : maToolBarList.AddToolBar(eGroup,rsToolBarName);
715 :
716 0 : mbPostUpdatePending = true;
717 0 : if (mnLockCount == 0)
718 0 : PostUpdate();
719 0 : }
720 0 : }
721 :
722 :
723 :
724 :
725 0 : void ToolBarManager::Implementation::RemoveToolBar (
726 : ToolBarGroup eGroup,
727 : const OUString& rsToolBarName)
728 : {
729 0 : ::osl::MutexGuard aGuard(maMutex);
730 :
731 0 : if (maToolBarList.RemoveToolBar(eGroup,rsToolBarName))
732 : {
733 0 : mbPreUpdatePending = true;
734 0 : if (mnLockCount == 0)
735 0 : PreUpdate();
736 0 : }
737 0 : }
738 :
739 :
740 :
741 :
742 0 : void ToolBarManager::Implementation::AddToolBarShell (
743 : ToolBarGroup eGroup,
744 : ShellId nToolBarId)
745 : {
746 0 : ViewShell* pMainViewShell = mrBase.GetMainViewShell().get();
747 0 : if (pMainViewShell != NULL)
748 : {
749 0 : maToolBarShellList.AddShellId(eGroup,nToolBarId);
750 0 : GetToolBarRules().SubShellAdded(eGroup, nToolBarId);
751 : }
752 0 : }
753 :
754 :
755 :
756 :
757 0 : void ToolBarManager::Implementation::ReleaseAllToolBarShells (void)
758 : {
759 0 : maToolBarShellList.ReleaseAllShells(GetToolBarRules());
760 0 : maToolBarShellList.UpdateShells(mrBase.GetMainViewShell(), mrBase.GetViewShellManager());
761 0 : }
762 :
763 :
764 :
765 :
766 0 : void ToolBarManager::Implementation::RequestUpdate (void)
767 : {
768 0 : if (mnPendingUpdateCall == 0)
769 : {
770 : mnPendingUpdateCall = Application::PostUserEvent(
771 0 : LINK(this,ToolBarManager::Implementation,UpdateCallback));
772 : }
773 0 : }
774 :
775 :
776 :
777 :
778 0 : void ToolBarManager::Implementation::PreUpdate (void)
779 : {
780 0 : ::osl::MutexGuard aGuard(maMutex);
781 :
782 0 : if (mbIsValid
783 0 : && mbPreUpdatePending
784 0 : && mxLayouter.is())
785 : {
786 0 : mbPreUpdatePending = false;
787 :
788 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ToolBarManager::PreUpdate [");
789 :
790 : // Get the list of tool bars that are not used anymore and are to be
791 : // deactivated.
792 0 : NameList aToolBars;
793 0 : maToolBarList.GetToolBarsToDeactivate(aToolBars);
794 :
795 : // Turn off the tool bars.
796 0 : NameList::const_iterator iToolBar;
797 0 : for (iToolBar=aToolBars.begin(); iToolBar!=aToolBars.end(); ++iToolBar)
798 : {
799 0 : OUString sFullName (GetToolBarResourceName(*iToolBar));
800 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": turning off tool bar " <<
801 : OUStringToOString(sFullName, RTL_TEXTENCODING_UTF8).getStr());
802 0 : mxLayouter->destroyElement(sFullName);
803 0 : maToolBarList.MarkToolBarAsNotActive(*iToolBar);
804 0 : }
805 :
806 0 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ToolBarManager::PreUpdate ]");
807 0 : }
808 0 : }
809 :
810 :
811 :
812 :
813 0 : void ToolBarManager::Implementation::PostUpdate (void)
814 : {
815 0 : ::osl::MutexGuard aGuard(maMutex);
816 :
817 0 : if (mbIsValid
818 0 : && mbPostUpdatePending
819 0 : && mxLayouter.is())
820 : {
821 0 : mbPostUpdatePending = false;
822 :
823 : // Create the list of requested tool bars.
824 0 : NameList aToolBars;
825 0 : maToolBarList.GetToolBarsToActivate(aToolBars);
826 :
827 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ToolBarManager::PostUpdate [");
828 :
829 : // Turn on the tool bars that are visible in the new context.
830 0 : NameList::const_iterator iToolBar;
831 0 : for (iToolBar=aToolBars.begin(); iToolBar!=aToolBars.end(); ++iToolBar)
832 : {
833 0 : OUString sFullName (GetToolBarResourceName(*iToolBar));
834 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": turning on tool bar " <<
835 : OUStringToOString(sFullName, RTL_TEXTENCODING_UTF8).getStr());
836 0 : mxLayouter->requestElement(sFullName);
837 0 : maToolBarList.MarkToolBarAsActive(*iToolBar);
838 0 : }
839 :
840 0 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ToolBarManager::PostUpdate ]");
841 0 : }
842 0 : }
843 :
844 :
845 :
846 :
847 0 : void ToolBarManager::Implementation::LockViewShellManager (void)
848 : {
849 0 : if (mpViewShellManagerLock.get() == NULL)
850 : mpViewShellManagerLock.reset(
851 0 : new ViewShellManager::UpdateLock(mrBase.GetViewShellManager()));
852 0 : }
853 :
854 :
855 :
856 :
857 0 : void ToolBarManager::Implementation::LockUpdate (void)
858 : {
859 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": LockUpdate " << mnLockCount);
860 0 : ::osl::MutexGuard aGuard(maMutex);
861 :
862 : DBG_ASSERT(mnLockCount<100, "ToolBarManager lock count unusually high");
863 0 : if (mnLockCount == 0)
864 : {
865 : OSL_ASSERT(mpSynchronousLayouterLock.get()==NULL);
866 :
867 0 : mpSynchronousLayouterLock.reset(new LayouterLock(mxLayouter));
868 : }
869 0 : ++mnLockCount;
870 0 : }
871 :
872 :
873 :
874 :
875 0 : void ToolBarManager::Implementation::UnlockUpdate (void)
876 : {
877 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": UnlockUpdate " << mnLockCount);
878 0 : ::osl::MutexGuard aGuard(maMutex);
879 :
880 : OSL_ASSERT(mnLockCount>0);
881 0 : --mnLockCount;
882 0 : if (mnLockCount == 0)
883 : {
884 0 : Update(mpSynchronousLayouterLock);
885 0 : }
886 0 : }
887 :
888 :
889 :
890 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
891 0 : void ToolBarManager::Implementation::Update (
892 : ::std::auto_ptr<LayouterLock> pLocalLayouterLock)
893 : {
894 : // When the lock is released and there are pending changes to the set of
895 : // tool bars then update this set now.
896 0 : if (mnLockCount == 0)
897 : {
898 : // During ceation of ViewShellBase we may have the situation that
899 : // the controller has already been created and attached to the frame
900 : // but that the ToolBarManager has not yet completed its
901 : // initialization (by initializing the mxLayouter member.) We do
902 : // this here so that we do not have to wait for the next Update()
903 : // call to show the tool bars.
904 0 : if (mnPendingSetValidCall != 0)
905 : {
906 0 : Application::RemoveUserEvent(mnPendingSetValidCall);
907 0 : mnPendingSetValidCall = 0;
908 0 : SetValid(true);
909 : }
910 :
911 0 : if (mbIsValid && mxLayouter.is() && (mbPreUpdatePending || mbPostUpdatePending))
912 : {
913 : // 1) Release UNO tool bars that are not longer used. Do this
914 : // now so that they are not updated when the SFX shell stack is
915 : // modified.
916 0 : if (mbPreUpdatePending)
917 0 : PreUpdate();
918 :
919 : // 2) Update the requested shells that represent tool bar
920 : // functionality. Those that are not used anymore are
921 : // deactivated now. Those that are missing are activated in the
922 : // next step together with the view shells.
923 0 : if (mpViewShellManagerLock.get() == NULL)
924 : mpViewShellManagerLock.reset(
925 0 : new ViewShellManager::UpdateLock(mrBase.GetViewShellManager()));
926 : maToolBarShellList.UpdateShells(
927 : mrBase.GetMainViewShell(),
928 0 : mrBase.GetViewShellManager());
929 :
930 : // 3) Unlock the ViewShellManager::UpdateLock. This updates the
931 : // shell stack. We have to be carfull here. The deletion of
932 : // the lock may end in a synchronous call to LockUpdate(). When
933 : // at this time the lock has been deleted but the auto_ptr has
934 : // not yet been reset then the lock is deleted a second time.
935 0 : ViewShellManager::UpdateLock* pLock = mpViewShellManagerLock.release();
936 0 : delete pLock;
937 :
938 : // 4) Make the UNO tool bars visible. The outstanding call to
939 : // PostUpdate() is done via PostUserEvent() so that it is
940 : // guaranteed to be executed when the SFX shell stack has been
941 : // updated (under the assumption that our lock to the
942 : // ViewShellManager was the only one open. If that is not the
943 : // case then all should still be well but not as fast.)
944 :
945 : // Note that the lock count may have been increased since
946 : // entering this method. In that case one of the next
947 : // UnlockUpdate() calls will post the UpdateCallback.
948 0 : if (mnPendingUpdateCall==0 && mnLockCount==0)
949 : {
950 0 : mpAsynchronousLayouterLock = pLocalLayouterLock;
951 : mnPendingUpdateCall = Application::PostUserEvent(
952 0 : LINK(this,ToolBarManager::Implementation,UpdateCallback));
953 : }
954 : }
955 : else
956 : {
957 : //do this in two steps, first clear mpViewShellManagerLock to be NULL
958 0 : ViewShellManager::UpdateLock* pLock = mpViewShellManagerLock.release();
959 : //now delete the lock so reentry to this method triggered by this
960 : //delete will encounter an empty mpViewShellManagerLock
961 0 : delete pLock;
962 0 : pLocalLayouterLock.reset();
963 : }
964 : }
965 0 : }
966 : SAL_WNODEPRECATED_DECLARATIONS_POP
967 :
968 :
969 :
970 :
971 0 : ToolBarRules& ToolBarManager::Implementation::GetToolBarRules (void)
972 : {
973 0 : return maToolBarRules;
974 : }
975 :
976 :
977 :
978 :
979 0 : IMPL_LINK_NOARG(ToolBarManager::Implementation, UpdateCallback)
980 : {
981 0 : mnPendingUpdateCall = 0;
982 0 : if (mnLockCount == 0)
983 : {
984 0 : if (mbPreUpdatePending)
985 0 : PreUpdate();
986 0 : if (mbPostUpdatePending)
987 0 : PostUpdate();
988 0 : if (mbIsValid && mxLayouter.is())
989 0 : mpAsynchronousLayouterLock.reset();
990 : }
991 0 : return 0;
992 : }
993 :
994 :
995 :
996 :
997 0 : IMPL_LINK(ToolBarManager::Implementation,EventMultiplexerCallback,
998 : sd::tools::EventMultiplexerEvent*,pEvent)
999 : {
1000 0 : if (pEvent != NULL)
1001 : {
1002 0 : switch (pEvent->meEventId)
1003 : {
1004 : case tools::EventMultiplexerEvent::EID_CONTROLLER_ATTACHED:
1005 0 : if (mnPendingSetValidCall == 0)
1006 : mnPendingSetValidCall
1007 0 : = Application::PostUserEvent(LINK(this,Implementation,SetValidCallback));
1008 0 : break;
1009 :
1010 : case tools::EventMultiplexerEvent::EID_CONTROLLER_DETACHED:
1011 0 : SetValid(false);
1012 0 : break;
1013 :
1014 : case tools::EventMultiplexerEvent::EID_PANE_MANAGER_DYING:
1015 0 : SetValid(false);
1016 0 : break;
1017 : }
1018 : }
1019 0 : return 0;
1020 : }
1021 :
1022 :
1023 :
1024 :
1025 0 : IMPL_LINK_NOARG(ToolBarManager::Implementation, SetValidCallback)
1026 : {
1027 0 : mnPendingSetValidCall = 0;
1028 0 : SetValid(true);
1029 0 : return 0;
1030 : }
1031 :
1032 :
1033 :
1034 :
1035 :
1036 0 : OUString ToolBarManager::Implementation::GetToolBarResourceName (
1037 : const OUString& rsBaseName) const
1038 : {
1039 0 : OUString sToolBarName (msToolBarResourcePrefix);
1040 0 : sToolBarName += rsBaseName;
1041 0 : return sToolBarName;
1042 : }
1043 :
1044 :
1045 :
1046 :
1047 0 : bool ToolBarManager::Implementation::CheckPlugInMode (const OUString& rsName) const
1048 : {
1049 0 : bool bValid (false);
1050 :
1051 : // Determine the plug in mode.
1052 0 : bool bIsPlugInMode (false);
1053 : do
1054 : {
1055 0 : SfxObjectShell* pObjectShell = mrBase.GetObjectShell();
1056 0 : if (pObjectShell == NULL)
1057 0 : break;
1058 :
1059 0 : SfxMedium* pMedium = pObjectShell->GetMedium();
1060 0 : if (pMedium == NULL)
1061 0 : break;
1062 :
1063 0 : SFX_ITEMSET_ARG(pMedium->GetItemSet(),pViewOnlyItem,SfxBoolItem,SID_VIEWONLY,false);
1064 0 : if (pViewOnlyItem == NULL)
1065 0 : break;
1066 :
1067 0 : bIsPlugInMode = pViewOnlyItem->GetValue();
1068 : }
1069 : while (false);
1070 :
1071 0 : if (rsName.equals(msViewerToolBar))
1072 0 : bValid = bIsPlugInMode;
1073 : else
1074 0 : bValid = ! bIsPlugInMode;
1075 :
1076 0 : return bValid;
1077 : }
1078 :
1079 :
1080 :
1081 :
1082 : } // end of namespace sd
1083 :
1084 :
1085 :
1086 :
1087 : namespace {
1088 :
1089 : using namespace ::sd;
1090 :
1091 : //===== LayouterLock ==========================================================
1092 :
1093 0 : LayouterLock::LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter)
1094 0 : : mxLayouter(rxLayouter)
1095 : {
1096 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": LayouterLock " << (mxLayouter.is() ? 1 :0));
1097 0 : if (mxLayouter.is())
1098 0 : mxLayouter->lock();
1099 0 : }
1100 :
1101 :
1102 :
1103 :
1104 0 : LayouterLock::~LayouterLock (void)
1105 : {
1106 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ~LayouterLock " << (mxLayouter.is() ? 1 :0));
1107 0 : if (mxLayouter.is())
1108 0 : mxLayouter->unlock();
1109 0 : }
1110 :
1111 :
1112 :
1113 :
1114 : //===== ToolBarRules ==========================================================
1115 :
1116 0 : ToolBarRules::ToolBarRules (
1117 : const ::boost::shared_ptr<sd::ToolBarManager>& rpToolBarManager,
1118 : const ::boost::shared_ptr<sd::ViewShellManager>& rpViewShellManager)
1119 : : mpToolBarManager(rpToolBarManager),
1120 0 : mpViewShellManager(rpViewShellManager)
1121 : {
1122 0 : }
1123 :
1124 :
1125 :
1126 :
1127 0 : void ToolBarRules::Update (ViewShellBase& rBase)
1128 : {
1129 0 : ViewShell* pMainViewShell = rBase.GetMainViewShell().get();
1130 0 : if (pMainViewShell != NULL)
1131 : {
1132 0 : MainViewShellChanged(pMainViewShell->GetShellType());
1133 0 : if (pMainViewShell->GetView())
1134 0 : SelectionHasChanged (*pMainViewShell, *pMainViewShell->GetView());
1135 : }
1136 : else
1137 0 : MainViewShellChanged(ViewShell::ST_NONE);
1138 0 : }
1139 :
1140 :
1141 :
1142 :
1143 0 : void ToolBarRules::MainViewShellChanged (ViewShell::ShellType nShellType)
1144 : {
1145 0 : ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
1146 0 : ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
1147 :
1148 0 : mpToolBarManager->ResetAllToolBars();
1149 :
1150 0 : switch(nShellType)
1151 : {
1152 : case ::sd::ViewShell::ST_IMPRESS:
1153 : case ::sd::ViewShell::ST_NOTES:
1154 : case ::sd::ViewShell::ST_HANDOUT:
1155 : mpToolBarManager->AddToolBar(
1156 : ToolBarManager::TBG_PERMANENT,
1157 0 : ToolBarManager::msToolBar);
1158 : mpToolBarManager->AddToolBar(
1159 : ToolBarManager::TBG_PERMANENT,
1160 0 : ToolBarManager::msOptionsToolBar);
1161 : mpToolBarManager->AddToolBar(
1162 : ToolBarManager::TBG_PERMANENT,
1163 0 : ToolBarManager::msCommonTaskToolBar);
1164 : mpToolBarManager->AddToolBar(
1165 : ToolBarManager::TBG_PERMANENT,
1166 0 : ToolBarManager::msViewerToolBar);
1167 0 : break;
1168 :
1169 : case ::sd::ViewShell::ST_DRAW:
1170 : mpToolBarManager->AddToolBar(
1171 : ToolBarManager::TBG_PERMANENT,
1172 0 : ToolBarManager::msToolBar);
1173 : mpToolBarManager->AddToolBar(
1174 : ToolBarManager::TBG_PERMANENT,
1175 0 : ToolBarManager::msOptionsToolBar);
1176 : mpToolBarManager->AddToolBar(
1177 : ToolBarManager::TBG_PERMANENT,
1178 0 : ToolBarManager::msViewerToolBar);
1179 0 : break;
1180 :
1181 : case ViewShell::ST_OUTLINE:
1182 : mpToolBarManager->AddToolBar(
1183 : ToolBarManager::TBG_PERMANENT,
1184 0 : ToolBarManager::msOutlineToolBar);
1185 : mpToolBarManager->AddToolBar(
1186 : ToolBarManager::TBG_PERMANENT,
1187 0 : ToolBarManager::msViewerToolBar);
1188 : mpToolBarManager->AddToolBarShell(
1189 0 : ToolBarManager::TBG_PERMANENT, RID_DRAW_TEXT_TOOLBOX);
1190 0 : break;
1191 :
1192 : case ViewShell::ST_SLIDE_SORTER:
1193 : mpToolBarManager->AddToolBar(
1194 : ToolBarManager::TBG_PERMANENT,
1195 0 : ToolBarManager::msViewerToolBar);
1196 : mpToolBarManager->AddToolBar(
1197 : ToolBarManager::TBG_PERMANENT,
1198 0 : ToolBarManager::msSlideSorterToolBar);
1199 : mpToolBarManager->AddToolBar(
1200 : ToolBarManager::TBG_PERMANENT,
1201 0 : ToolBarManager::msSlideSorterObjectBar);
1202 0 : break;
1203 :
1204 : case ViewShell::ST_NONE:
1205 : case ViewShell::ST_PRESENTATION:
1206 : case ViewShell::ST_SIDEBAR:
1207 : default:
1208 0 : break;
1209 0 : }
1210 0 : }
1211 :
1212 :
1213 :
1214 :
1215 0 : void ToolBarRules::MainViewShellChanged (const ViewShell& rMainViewShell)
1216 : {
1217 0 : ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
1218 0 : ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
1219 :
1220 0 : MainViewShellChanged(rMainViewShell.GetShellType());
1221 0 : switch(rMainViewShell.GetShellType())
1222 : {
1223 : case ::sd::ViewShell::ST_IMPRESS:
1224 : case ::sd::ViewShell::ST_DRAW:
1225 : case ::sd::ViewShell::ST_NOTES:
1226 : {
1227 : const DrawViewShell* pDrawViewShell
1228 0 : = dynamic_cast<const DrawViewShell*>(&rMainViewShell);
1229 0 : if (pDrawViewShell != NULL)
1230 0 : if (pDrawViewShell->GetEditMode() == EM_MASTERPAGE)
1231 : mpToolBarManager->AddToolBar(
1232 : ToolBarManager::TBG_MASTER_MODE,
1233 0 : ToolBarManager::msMasterViewToolBar);
1234 0 : break;
1235 : }
1236 :
1237 : default:
1238 0 : break;
1239 0 : }
1240 0 : }
1241 :
1242 :
1243 :
1244 :
1245 0 : void ToolBarRules::SelectionHasChanged (
1246 : const ::sd::ViewShell& rViewShell,
1247 : const SdrView& rView)
1248 : {
1249 0 : ::sd::ToolBarManager::UpdateLock aLock (mpToolBarManager);
1250 0 : mpToolBarManager->LockViewShellManager();
1251 0 : bool bTextEdit = rView.IsTextEdit();
1252 :
1253 0 : mpToolBarManager->ResetToolBars(ToolBarManager::TBG_FUNCTION);
1254 :
1255 0 : switch (rView.GetContext())
1256 : {
1257 : case SDRCONTEXT_GRAPHIC:
1258 0 : if( !bTextEdit )
1259 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_GRAF_TOOLBOX);
1260 0 : break;
1261 :
1262 : case SDRCONTEXT_MEDIA:
1263 0 : if( !bTextEdit )
1264 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_MEDIA_TOOLBOX);
1265 0 : break;
1266 :
1267 : case SDRCONTEXT_TABLE:
1268 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX);
1269 0 : bTextEdit = true;
1270 0 : break;
1271 :
1272 : case SDRCONTEXT_STANDARD:
1273 : default:
1274 0 : if( !bTextEdit )
1275 : {
1276 0 : switch(rViewShell.GetShellType())
1277 : {
1278 : case ::sd::ViewShell::ST_IMPRESS:
1279 : case ::sd::ViewShell::ST_DRAW:
1280 : case ::sd::ViewShell::ST_NOTES:
1281 : case ::sd::ViewShell::ST_HANDOUT:
1282 : mpToolBarManager->SetToolBar(
1283 : ToolBarManager::TBG_FUNCTION,
1284 0 : ToolBarManager::msDrawingObjectToolBar);
1285 0 : break;
1286 : default:
1287 0 : break;
1288 : }
1289 0 : break;
1290 : }
1291 : }
1292 :
1293 0 : if( bTextEdit )
1294 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TEXT_TOOLBOX);
1295 :
1296 0 : SdrView* pView = &const_cast<SdrView&>(rView);
1297 : // Check if the extrusion tool bar and the fontwork tool bar have to
1298 : // be activated.
1299 0 : if (svx::checkForSelectedCustomShapes(pView, true /* bOnlyExtruded */ ))
1300 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_EXTRUSION_BAR);
1301 0 : sal_uInt32 nCheckStatus = 0;
1302 0 : if (svx::checkForSelectedFontWork(pView, nCheckStatus))
1303 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_FONTWORK_BAR);
1304 :
1305 : // Switch on additional context-sensitive tool bars.
1306 0 : if (rView.GetContext() == SDRCONTEXT_POINTEDIT)
1307 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_BEZIER_TOOLBOX);
1308 0 : }
1309 :
1310 :
1311 :
1312 :
1313 0 : void ToolBarRules::SubShellAdded (
1314 : ::sd::ToolBarManager::ToolBarGroup eGroup,
1315 : sd::ShellId nShellId)
1316 : {
1317 : // For some tool bar shells (those defined in sd) we have to add the
1318 : // actual tool bar here.
1319 0 : switch (nShellId)
1320 : {
1321 : case RID_DRAW_GRAF_TOOLBOX:
1322 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1323 0 : break;
1324 :
1325 : case RID_DRAW_MEDIA_TOOLBOX:
1326 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1327 0 : break;
1328 :
1329 : case RID_DRAW_TEXT_TOOLBOX:
1330 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTextObjectBar);
1331 0 : break;
1332 :
1333 : case RID_BEZIER_TOOLBOX:
1334 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1335 0 : break;
1336 :
1337 : case RID_DRAW_TABLE_TOOLBOX:
1338 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTableObjectBar);
1339 0 : break;
1340 : }
1341 0 : }
1342 :
1343 :
1344 :
1345 :
1346 0 : void ToolBarRules::SubShellRemoved (
1347 : ::sd::ToolBarManager::ToolBarGroup eGroup,
1348 : sd::ShellId nShellId)
1349 : {
1350 : // For some tool bar shells (those defined in sd) we have to add the
1351 : // actual tool bar here.
1352 0 : switch (nShellId)
1353 : {
1354 : case RID_DRAW_GRAF_TOOLBOX:
1355 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1356 0 : break;
1357 :
1358 : case RID_DRAW_MEDIA_TOOLBOX:
1359 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1360 0 : break;
1361 :
1362 : case RID_DRAW_TEXT_TOOLBOX:
1363 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTextObjectBar);
1364 0 : break;
1365 :
1366 : case RID_BEZIER_TOOLBOX:
1367 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1368 0 : break;
1369 :
1370 : case RID_DRAW_TABLE_TOOLBOX:
1371 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTableObjectBar);
1372 0 : break;
1373 : }
1374 0 : }
1375 :
1376 :
1377 :
1378 :
1379 : //===== ToolBarList ===========================================================
1380 :
1381 0 : ToolBarList::ToolBarList (void)
1382 : : maGroups(),
1383 0 : maActiveToolBars()
1384 : {
1385 0 : }
1386 :
1387 :
1388 :
1389 :
1390 0 : void ToolBarList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1391 : {
1392 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1393 0 : if (iGroup != maGroups.end())
1394 : {
1395 0 : if ( ! iGroup->second.empty())
1396 : {
1397 0 : iGroup->second.clear();
1398 : }
1399 : }
1400 0 : }
1401 :
1402 :
1403 :
1404 :
1405 0 : void ToolBarList::AddToolBar (
1406 : sd::ToolBarManager::ToolBarGroup eGroup,
1407 : const OUString& rsName)
1408 : {
1409 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1410 0 : if (iGroup == maGroups.end())
1411 0 : iGroup = maGroups.insert(Groups::value_type(eGroup,NameList())).first;
1412 :
1413 0 : if (iGroup != maGroups.end())
1414 : {
1415 : NameList::const_iterator iBar (
1416 0 : ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName));
1417 0 : if (iBar == iGroup->second.end())
1418 : {
1419 0 : iGroup->second.push_back(rsName);
1420 : }
1421 : }
1422 0 : }
1423 :
1424 :
1425 :
1426 :
1427 0 : bool ToolBarList::RemoveToolBar (
1428 : sd::ToolBarManager::ToolBarGroup eGroup,
1429 : const OUString& rsName)
1430 : {
1431 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1432 0 : if (iGroup != maGroups.end())
1433 : {
1434 : NameList::iterator iBar (
1435 0 : ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName));
1436 0 : if (iBar != iGroup->second.end())
1437 : {
1438 0 : iGroup->second.erase(iBar);
1439 0 : return true;
1440 : }
1441 : }
1442 0 : return false;
1443 : }
1444 :
1445 :
1446 :
1447 :
1448 0 : void ToolBarList::MakeRequestedToolBarList (NameList& rRequestedToolBars) const
1449 : {
1450 0 : for (int i=sd::ToolBarManager::TBG__FIRST; i<=sd::ToolBarManager::TBG__LAST; ++i)
1451 : {
1452 0 : ::sd::ToolBarManager::ToolBarGroup eGroup = (::sd::ToolBarManager::ToolBarGroup)i;
1453 0 : Groups::const_iterator iGroup (maGroups.find(eGroup));
1454 0 : if (iGroup != maGroups.end())
1455 : ::std::copy(
1456 0 : iGroup->second.begin(),
1457 0 : iGroup->second.end(),
1458 0 : ::std::inserter(rRequestedToolBars,rRequestedToolBars.end()));
1459 : }
1460 0 : }
1461 :
1462 :
1463 :
1464 :
1465 0 : void ToolBarList::GetToolBarsToActivate (NameList& rToolBars) const
1466 : {
1467 0 : NameList aRequestedToolBars;
1468 0 : MakeRequestedToolBarList(aRequestedToolBars);
1469 :
1470 0 : NameList::const_iterator iToolBar;
1471 0 : for (iToolBar=aRequestedToolBars.begin(); iToolBar!=aRequestedToolBars.end(); ++iToolBar)
1472 : {
1473 0 : if (::std::find(maActiveToolBars.begin(),maActiveToolBars.end(),*iToolBar)
1474 0 : == maActiveToolBars.end())
1475 : {
1476 0 : rToolBars.push_back(*iToolBar);
1477 : }
1478 0 : }
1479 0 : }
1480 :
1481 :
1482 :
1483 :
1484 0 : void ToolBarList::GetToolBarsToDeactivate (NameList& rToolBars) const
1485 : {
1486 0 : NameList aRequestedToolBars;
1487 0 : MakeRequestedToolBarList(aRequestedToolBars);
1488 :
1489 0 : NameList::const_iterator iToolBar;
1490 0 : for (iToolBar=maActiveToolBars.begin(); iToolBar!=maActiveToolBars.end(); ++iToolBar)
1491 : {
1492 0 : if (::std::find(aRequestedToolBars.begin(),aRequestedToolBars.end(),*iToolBar)
1493 0 : == aRequestedToolBars.end())
1494 : {
1495 0 : rToolBars.push_back(*iToolBar);
1496 : }
1497 0 : }
1498 0 : }
1499 :
1500 :
1501 :
1502 :
1503 0 : void ToolBarList::MarkToolBarAsActive (const OUString& rsName)
1504 : {
1505 0 : maActiveToolBars.push_back(rsName);
1506 0 : }
1507 :
1508 :
1509 :
1510 :
1511 0 : void ToolBarList::MarkToolBarAsNotActive (const OUString& rsName)
1512 : {
1513 : maActiveToolBars.erase(
1514 0 : ::std::find(maActiveToolBars.begin(),maActiveToolBars.end(), rsName));
1515 0 : }
1516 :
1517 :
1518 :
1519 :
1520 0 : void ToolBarList::MarkAllToolBarsAsNotActive (void)
1521 : {
1522 0 : maActiveToolBars.clear();
1523 0 : }
1524 :
1525 :
1526 :
1527 :
1528 : //===== ToolBarShellList ======================================================
1529 :
1530 0 : ToolBarShellList::ShellDescriptor::ShellDescriptor (
1531 : ShellId nId,
1532 : sd::ToolBarManager::ToolBarGroup eGroup)
1533 : : mnId(nId),
1534 0 : meGroup(eGroup)
1535 : {
1536 0 : }
1537 :
1538 :
1539 :
1540 :
1541 0 : ToolBarShellList::ToolBarShellList (void)
1542 : : maNewList()
1543 0 : , maCurrentList()
1544 : {
1545 0 : }
1546 :
1547 :
1548 :
1549 :
1550 0 : void ToolBarShellList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1551 : {
1552 : // In every loop we erase the first member of the specified group.
1553 : // Because that invalidates the iterator another loop is started after
1554 : // that. The loop is left only when no member of the group is found and
1555 : // no element is erased
1556 : bool bLoop;
1557 0 : do
1558 : {
1559 0 : bLoop = false;
1560 :
1561 0 : GroupedShellList::iterator iDescriptor;
1562 0 : for (iDescriptor=maNewList.begin(); iDescriptor!=maNewList.end(); ++iDescriptor)
1563 0 : if (iDescriptor->meGroup == eGroup)
1564 : {
1565 0 : maNewList.erase(iDescriptor);
1566 : // Erasing the descriptor invalidated the iterator so we
1567 : // have to exit the for loop and start anew to search for
1568 : // further elements of the group.
1569 0 : bLoop = true;
1570 0 : break;
1571 : }
1572 : }
1573 : while (bLoop);
1574 0 : }
1575 :
1576 :
1577 :
1578 :
1579 0 : void ToolBarShellList::AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId)
1580 : {
1581 : // Make sure that the shell is not added twice (and possibly in
1582 : // different groups.)
1583 0 : ShellDescriptor aDescriptor (nId,eGroup);
1584 0 : GroupedShellList::iterator iDescriptor (maNewList.find(aDescriptor));
1585 0 : if (iDescriptor != maNewList.end())
1586 : {
1587 : // The shell is already requested.
1588 0 : if (iDescriptor->meGroup != eGroup)
1589 : {
1590 : // It is now being requested for another group.
1591 : // (Is this an error?)
1592 : // Move it to that group.
1593 0 : maNewList.erase(iDescriptor);
1594 0 : maNewList.insert(aDescriptor);
1595 : }
1596 : // else nothing to do.
1597 : }
1598 : else
1599 0 : maNewList.insert(aDescriptor);
1600 0 : }
1601 :
1602 :
1603 :
1604 :
1605 0 : void ToolBarShellList::ReleaseAllShells (ToolBarRules& rRules)
1606 : {
1607 : // Release the currently active tool bars.
1608 0 : GroupedShellList aList (maCurrentList);
1609 0 : GroupedShellList::iterator iDescriptor;
1610 0 : for (iDescriptor=aList.begin(); iDescriptor!=aList.end(); ++iDescriptor)
1611 : {
1612 0 : rRules.SubShellRemoved(iDescriptor->meGroup, iDescriptor->mnId);
1613 : }
1614 :
1615 : // Clear the list of requested tool bars.
1616 0 : maNewList.clear();
1617 0 : }
1618 :
1619 :
1620 :
1621 :
1622 0 : void ToolBarShellList::UpdateShells (
1623 : const ::boost::shared_ptr<ViewShell>& rpMainViewShell,
1624 : const ::boost::shared_ptr<ViewShellManager>& rpManager)
1625 : {
1626 0 : if (rpMainViewShell.get() != NULL)
1627 : {
1628 0 : GroupedShellList aList;
1629 :
1630 : // Deactivate shells that are in maCurrentList, but not in
1631 : // maNewList.
1632 : ::std::set_difference(maCurrentList.begin(), maCurrentList.end(),
1633 : maNewList.begin(), maNewList.end(),
1634 0 : std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1635 0 : for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell)
1636 : {
1637 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": deactivating tool bar shell " << iShell->mnId);
1638 0 : rpManager->DeactivateSubShell(*rpMainViewShell, iShell->mnId);
1639 : }
1640 :
1641 : // Activate shells that are in maNewList, but not in
1642 : // maCurrentList.
1643 0 : aList.clear();
1644 : ::std::set_difference(maNewList.begin(), maNewList.end(),
1645 : maCurrentList.begin(), maCurrentList.end(),
1646 0 : std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1647 0 : for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell)
1648 : {
1649 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": activating tool bar shell " << iShell->mnId);
1650 0 : rpManager->ActivateSubShell(*rpMainViewShell, iShell->mnId);
1651 : }
1652 :
1653 : // The maNewList now refelects the current state and thus is made
1654 : // maCurrentList.
1655 0 : maCurrentList = maNewList;
1656 : }
1657 0 : }
1658 :
1659 :
1660 :
1661 :
1662 0 : } // end of anonymous namespace
1663 :
1664 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
