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/unohlp.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<rtl::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 ::rtl::OUString& rsName);
82 : bool RemoveToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const ::rtl::OUString& rsName);
83 :
84 : void GetToolBarsToActivate (NameList& rToolBars) const;
85 : void GetToolBarsToDeactivate (NameList& rToolBars) const;
86 :
87 : void MarkToolBarAsActive (const ::rtl::OUString& rsName);
88 : void MarkToolBarAsNotActive (const ::rtl::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 : seperately.
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 ::rtl::OUString& rsToolBarName);
267 : void AddToolBarShell (ToolBarGroup eGroup, ShellId nToolBarId);
268 : void RemoveToolBar (ToolBarGroup eGroup, const ::rtl::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 whithout 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 ::rtl::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 : ::rtl::OUString GetToolBarResourceName (const ::rtl::OUString& rsBaseName) const;
339 : bool CheckPlugInMode (const ::rtl::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 3 : const ::rtl::OUString ToolBarManager::msToolBar("toolbar");
351 3 : const ::rtl::OUString ToolBarManager::msOptionsToolBar("optionsbar");
352 3 : const ::rtl::OUString ToolBarManager::msCommonTaskToolBar("commontaskbar");
353 3 : const ::rtl::OUString ToolBarManager::msViewerToolBar("viewerbar");
354 3 : const ::rtl::OUString ToolBarManager::msSlideSorterToolBar("slideviewtoolbar");
355 3 : const ::rtl::OUString ToolBarManager::msSlideSorterObjectBar("slideviewobjectbar");
356 3 : const ::rtl::OUString ToolBarManager::msOutlineToolBar("outlinetoolbar");
357 3 : const ::rtl::OUString ToolBarManager::msMasterViewToolBar("masterviewtoolbar");
358 3 : const ::rtl::OUString ToolBarManager::msDrawingObjectToolBar("drawingobjectbar");
359 3 : const ::rtl::OUString ToolBarManager::msGluePointsToolBar("gluepointsobjectbar");
360 3 : const ::rtl::OUString ToolBarManager::msTextObjectBar("textobjectbar");
361 3 : const ::rtl::OUString ToolBarManager::msBezierObjectBar("bezierobjectbar");
362 3 : const ::rtl::OUString ToolBarManager::msGraphicObjectBar("graphicobjectbar");
363 3 : const ::rtl::OUString ToolBarManager::msMediaObjectBar("mediaobjectbar");
364 3 : const ::rtl::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 ::rtl::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 ::rtl::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 ::rtl::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 3 : const ::rtl::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 ::rtl::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 ::rtl::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 : && 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 : ::rtl::OUString sFullName (GetToolBarResourceName(*iToolBar));
800 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": turning off tool bar " <<
801 : ::rtl::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 : && 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 : ::rtl::OUString sFullName (GetToolBarResourceName(*iToolBar));
834 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": turning on tool bar " <<
835 : ::rtl::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 0 : mpViewShellManagerLock.reset();
958 0 : pLocalLayouterLock.reset();
959 : }
960 : }
961 0 : }
962 : SAL_WNODEPRECATED_DECLARATIONS_POP
963 :
964 :
965 :
966 :
967 0 : ToolBarRules& ToolBarManager::Implementation::GetToolBarRules (void)
968 : {
969 0 : return maToolBarRules;
970 : }
971 :
972 :
973 :
974 :
975 0 : IMPL_LINK_NOARG(ToolBarManager::Implementation, UpdateCallback)
976 : {
977 0 : mnPendingUpdateCall = 0;
978 0 : if (mnLockCount == 0)
979 : {
980 0 : if (mbPreUpdatePending)
981 0 : PreUpdate();
982 0 : if (mbPostUpdatePending)
983 0 : PostUpdate();
984 0 : if (mbIsValid && mxLayouter.is())
985 0 : mpAsynchronousLayouterLock.reset();
986 : }
987 0 : return 0;
988 : }
989 :
990 :
991 :
992 :
993 0 : IMPL_LINK(ToolBarManager::Implementation,EventMultiplexerCallback,
994 : sd::tools::EventMultiplexerEvent*,pEvent)
995 : {
996 0 : if (pEvent != NULL)
997 : {
998 0 : switch (pEvent->meEventId)
999 : {
1000 : case tools::EventMultiplexerEvent::EID_CONTROLLER_ATTACHED:
1001 0 : if (mnPendingSetValidCall == 0)
1002 : mnPendingSetValidCall
1003 0 : = Application::PostUserEvent(LINK(this,Implementation,SetValidCallback));
1004 0 : break;
1005 :
1006 : case tools::EventMultiplexerEvent::EID_CONTROLLER_DETACHED:
1007 0 : SetValid(false);
1008 0 : break;
1009 :
1010 : case tools::EventMultiplexerEvent::EID_PANE_MANAGER_DYING:
1011 0 : SetValid(false);
1012 0 : break;
1013 : }
1014 : }
1015 0 : return 0;
1016 : }
1017 :
1018 :
1019 :
1020 :
1021 0 : IMPL_LINK_NOARG(ToolBarManager::Implementation, SetValidCallback)
1022 : {
1023 0 : mnPendingSetValidCall = 0;
1024 0 : SetValid(true);
1025 0 : return 0;
1026 : }
1027 :
1028 :
1029 :
1030 :
1031 :
1032 0 : ::rtl::OUString ToolBarManager::Implementation::GetToolBarResourceName (
1033 : const ::rtl::OUString& rsBaseName) const
1034 : {
1035 0 : ::rtl::OUString sToolBarName (msToolBarResourcePrefix);
1036 0 : sToolBarName += rsBaseName;
1037 0 : return sToolBarName;
1038 : }
1039 :
1040 :
1041 :
1042 :
1043 0 : bool ToolBarManager::Implementation::CheckPlugInMode (const ::rtl::OUString& rsName) const
1044 : {
1045 0 : bool bValid (false);
1046 :
1047 : // Determine the plug in mode.
1048 0 : bool bIsPlugInMode (false);
1049 : do
1050 : {
1051 0 : SfxObjectShell* pObjectShell = mrBase.GetObjectShell();
1052 0 : if (pObjectShell == NULL)
1053 0 : break;
1054 :
1055 0 : SfxMedium* pMedium = pObjectShell->GetMedium();
1056 0 : if (pMedium == NULL)
1057 0 : break;
1058 :
1059 0 : SFX_ITEMSET_ARG(pMedium->GetItemSet(),pViewOnlyItem,SfxBoolItem,SID_VIEWONLY,sal_False);
1060 0 : if (pViewOnlyItem == NULL)
1061 0 : break;
1062 :
1063 0 : bIsPlugInMode = pViewOnlyItem->GetValue();
1064 : }
1065 : while (false);
1066 :
1067 0 : if (rsName.equals(msViewerToolBar))
1068 0 : bValid = bIsPlugInMode;
1069 : else
1070 0 : bValid = ! bIsPlugInMode;
1071 :
1072 0 : return bValid;
1073 : }
1074 :
1075 :
1076 :
1077 :
1078 : } // end of namespace sd
1079 :
1080 :
1081 :
1082 :
1083 : namespace {
1084 :
1085 : using namespace ::sd;
1086 :
1087 : //===== LayouterLock ==========================================================
1088 :
1089 0 : LayouterLock::LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter)
1090 0 : : mxLayouter(rxLayouter)
1091 : {
1092 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": LayouterLock " << (mxLayouter.is() ? 1 :0));
1093 0 : if (mxLayouter.is())
1094 0 : mxLayouter->lock();
1095 0 : }
1096 :
1097 :
1098 :
1099 :
1100 0 : LayouterLock::~LayouterLock (void)
1101 : {
1102 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": ~LayouterLock " << (mxLayouter.is() ? 1 :0));
1103 0 : if (mxLayouter.is())
1104 0 : mxLayouter->unlock();
1105 0 : }
1106 :
1107 :
1108 :
1109 :
1110 : //===== ToolBarRules ==========================================================
1111 :
1112 0 : ToolBarRules::ToolBarRules (
1113 : const ::boost::shared_ptr<sd::ToolBarManager>& rpToolBarManager,
1114 : const ::boost::shared_ptr<sd::ViewShellManager>& rpViewShellManager)
1115 : : mpToolBarManager(rpToolBarManager),
1116 0 : mpViewShellManager(rpViewShellManager)
1117 : {
1118 0 : }
1119 :
1120 :
1121 :
1122 :
1123 0 : void ToolBarRules::Update (ViewShellBase& rBase)
1124 : {
1125 0 : ViewShell* pMainViewShell = rBase.GetMainViewShell().get();
1126 0 : if (pMainViewShell != NULL)
1127 : {
1128 0 : MainViewShellChanged(pMainViewShell->GetShellType());
1129 0 : if (pMainViewShell->GetView())
1130 0 : SelectionHasChanged (*pMainViewShell, *pMainViewShell->GetView());
1131 : }
1132 : else
1133 0 : MainViewShellChanged(ViewShell::ST_NONE);
1134 0 : }
1135 :
1136 :
1137 :
1138 :
1139 0 : void ToolBarRules::MainViewShellChanged (ViewShell::ShellType nShellType)
1140 : {
1141 0 : ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
1142 0 : ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
1143 :
1144 0 : mpToolBarManager->ResetAllToolBars();
1145 :
1146 0 : switch(nShellType)
1147 : {
1148 : case ::sd::ViewShell::ST_IMPRESS:
1149 : case ::sd::ViewShell::ST_NOTES:
1150 : case ::sd::ViewShell::ST_HANDOUT:
1151 : mpToolBarManager->AddToolBar(
1152 : ToolBarManager::TBG_PERMANENT,
1153 0 : ToolBarManager::msToolBar);
1154 : mpToolBarManager->AddToolBar(
1155 : ToolBarManager::TBG_PERMANENT,
1156 0 : ToolBarManager::msOptionsToolBar);
1157 : mpToolBarManager->AddToolBar(
1158 : ToolBarManager::TBG_PERMANENT,
1159 0 : ToolBarManager::msCommonTaskToolBar);
1160 : mpToolBarManager->AddToolBar(
1161 : ToolBarManager::TBG_PERMANENT,
1162 0 : ToolBarManager::msViewerToolBar);
1163 0 : break;
1164 :
1165 : case ::sd::ViewShell::ST_DRAW:
1166 : mpToolBarManager->AddToolBar(
1167 : ToolBarManager::TBG_PERMANENT,
1168 0 : ToolBarManager::msToolBar);
1169 : mpToolBarManager->AddToolBar(
1170 : ToolBarManager::TBG_PERMANENT,
1171 0 : ToolBarManager::msOptionsToolBar);
1172 : mpToolBarManager->AddToolBar(
1173 : ToolBarManager::TBG_PERMANENT,
1174 0 : ToolBarManager::msViewerToolBar);
1175 0 : break;
1176 :
1177 : case ViewShell::ST_OUTLINE:
1178 : mpToolBarManager->AddToolBar(
1179 : ToolBarManager::TBG_PERMANENT,
1180 0 : ToolBarManager::msOutlineToolBar);
1181 : mpToolBarManager->AddToolBar(
1182 : ToolBarManager::TBG_PERMANENT,
1183 0 : ToolBarManager::msViewerToolBar);
1184 : mpToolBarManager->AddToolBarShell(
1185 0 : ToolBarManager::TBG_PERMANENT, RID_DRAW_TEXT_TOOLBOX);
1186 0 : break;
1187 :
1188 : case ViewShell::ST_SLIDE_SORTER:
1189 : mpToolBarManager->AddToolBar(
1190 : ToolBarManager::TBG_PERMANENT,
1191 0 : ToolBarManager::msViewerToolBar);
1192 : mpToolBarManager->AddToolBar(
1193 : ToolBarManager::TBG_PERMANENT,
1194 0 : ToolBarManager::msSlideSorterToolBar);
1195 : mpToolBarManager->AddToolBar(
1196 : ToolBarManager::TBG_PERMANENT,
1197 0 : ToolBarManager::msSlideSorterObjectBar);
1198 0 : break;
1199 :
1200 : case ViewShell::ST_NONE:
1201 : case ViewShell::ST_PRESENTATION:
1202 : case ViewShell::ST_TASK_PANE:
1203 : default:
1204 0 : break;
1205 0 : }
1206 0 : }
1207 :
1208 :
1209 :
1210 :
1211 0 : void ToolBarRules::MainViewShellChanged (const ViewShell& rMainViewShell)
1212 : {
1213 0 : ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
1214 0 : ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
1215 :
1216 0 : MainViewShellChanged(rMainViewShell.GetShellType());
1217 0 : switch(rMainViewShell.GetShellType())
1218 : {
1219 : case ::sd::ViewShell::ST_IMPRESS:
1220 : case ::sd::ViewShell::ST_DRAW:
1221 : case ::sd::ViewShell::ST_NOTES:
1222 : {
1223 : const DrawViewShell* pDrawViewShell
1224 0 : = dynamic_cast<const DrawViewShell*>(&rMainViewShell);
1225 0 : if (pDrawViewShell != NULL)
1226 0 : if (pDrawViewShell->GetEditMode() == EM_MASTERPAGE)
1227 : mpToolBarManager->AddToolBar(
1228 : ToolBarManager::TBG_MASTER_MODE,
1229 0 : ToolBarManager::msMasterViewToolBar);
1230 0 : break;
1231 : }
1232 :
1233 : default:
1234 0 : break;
1235 0 : }
1236 0 : }
1237 :
1238 :
1239 :
1240 :
1241 0 : void ToolBarRules::SelectionHasChanged (
1242 : const ::sd::ViewShell& rViewShell,
1243 : const SdrView& rView)
1244 : {
1245 0 : ::sd::ToolBarManager::UpdateLock aLock (mpToolBarManager);
1246 0 : mpToolBarManager->LockViewShellManager();
1247 0 : bool bTextEdit = rView.IsTextEdit();
1248 :
1249 0 : mpToolBarManager->ResetToolBars(ToolBarManager::TBG_FUNCTION);
1250 :
1251 0 : switch (rView.GetContext())
1252 : {
1253 : case SDRCONTEXT_GRAPHIC:
1254 0 : if( !bTextEdit )
1255 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_GRAF_TOOLBOX);
1256 0 : break;
1257 :
1258 : case SDRCONTEXT_MEDIA:
1259 0 : if( !bTextEdit )
1260 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_MEDIA_TOOLBOX);
1261 0 : break;
1262 :
1263 : case SDRCONTEXT_TABLE:
1264 0 : mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX);
1265 0 : bTextEdit = true;
1266 0 : break;
1267 :
1268 : case SDRCONTEXT_STANDARD:
1269 : default:
1270 0 : if( !bTextEdit )
1271 : {
1272 0 : switch(rViewShell.GetShellType())
1273 : {
1274 : case ::sd::ViewShell::ST_IMPRESS:
1275 : case ::sd::ViewShell::ST_DRAW:
1276 : case ::sd::ViewShell::ST_NOTES:
1277 : case ::sd::ViewShell::ST_HANDOUT:
1278 : mpToolBarManager->SetToolBar(
1279 : ToolBarManager::TBG_FUNCTION,
1280 0 : ToolBarManager::msDrawingObjectToolBar);
1281 0 : break;
1282 : default:
1283 0 : break;
1284 : }
1285 0 : break;
1286 : }
1287 : }
1288 :
1289 0 : if( bTextEdit )
1290 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TEXT_TOOLBOX);
1291 :
1292 0 : SdrView* pView = &const_cast<SdrView&>(rView);
1293 : // Check if the extrusion tool bar and the fontwork tool bar have to
1294 : // be activated.
1295 0 : if (svx::checkForSelectedCustomShapes(pView, true /* bOnlyExtruded */ ))
1296 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_EXTRUSION_BAR);
1297 0 : sal_uInt32 nCheckStatus = 0;
1298 0 : if (svx::checkForSelectedFontWork(pView, nCheckStatus))
1299 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_FONTWORK_BAR);
1300 :
1301 : // Switch on additional context-sensitive tool bars.
1302 0 : if (rView.GetContext() == SDRCONTEXT_POINTEDIT)
1303 0 : mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_BEZIER_TOOLBOX);
1304 0 : }
1305 :
1306 :
1307 :
1308 :
1309 0 : void ToolBarRules::SubShellAdded (
1310 : ::sd::ToolBarManager::ToolBarGroup eGroup,
1311 : sd::ShellId nShellId)
1312 : {
1313 : // For some tool bar shells (those defined in sd) we have to add the
1314 : // actual tool bar here.
1315 0 : switch (nShellId)
1316 : {
1317 : case RID_DRAW_GRAF_TOOLBOX:
1318 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1319 0 : break;
1320 :
1321 : case RID_DRAW_MEDIA_TOOLBOX:
1322 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1323 0 : break;
1324 :
1325 : case RID_DRAW_TEXT_TOOLBOX:
1326 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTextObjectBar);
1327 0 : break;
1328 :
1329 : case RID_BEZIER_TOOLBOX:
1330 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1331 0 : break;
1332 :
1333 : case RID_DRAW_TABLE_TOOLBOX:
1334 0 : mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTableObjectBar);
1335 0 : break;
1336 : }
1337 0 : }
1338 :
1339 :
1340 :
1341 :
1342 0 : void ToolBarRules::SubShellRemoved (
1343 : ::sd::ToolBarManager::ToolBarGroup eGroup,
1344 : sd::ShellId nShellId)
1345 : {
1346 : // For some tool bar shells (those defined in sd) we have to add the
1347 : // actual tool bar here.
1348 0 : switch (nShellId)
1349 : {
1350 : case RID_DRAW_GRAF_TOOLBOX:
1351 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1352 0 : break;
1353 :
1354 : case RID_DRAW_MEDIA_TOOLBOX:
1355 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1356 0 : break;
1357 :
1358 : case RID_DRAW_TEXT_TOOLBOX:
1359 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTextObjectBar);
1360 0 : break;
1361 :
1362 : case RID_BEZIER_TOOLBOX:
1363 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1364 0 : break;
1365 :
1366 : case RID_DRAW_TABLE_TOOLBOX:
1367 0 : mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTableObjectBar);
1368 0 : break;
1369 : }
1370 0 : }
1371 :
1372 :
1373 :
1374 :
1375 : //===== ToolBarList ===========================================================
1376 :
1377 0 : ToolBarList::ToolBarList (void)
1378 : : maGroups(),
1379 0 : maActiveToolBars()
1380 : {
1381 0 : }
1382 :
1383 :
1384 :
1385 :
1386 0 : void ToolBarList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1387 : {
1388 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1389 0 : if (iGroup != maGroups.end())
1390 : {
1391 0 : if ( ! iGroup->second.empty())
1392 : {
1393 0 : iGroup->second.clear();
1394 : }
1395 : }
1396 0 : }
1397 :
1398 :
1399 :
1400 :
1401 0 : void ToolBarList::AddToolBar (
1402 : sd::ToolBarManager::ToolBarGroup eGroup,
1403 : const ::rtl::OUString& rsName)
1404 : {
1405 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1406 0 : if (iGroup == maGroups.end())
1407 0 : iGroup = maGroups.insert(Groups::value_type(eGroup,NameList())).first;
1408 :
1409 0 : if (iGroup != maGroups.end())
1410 : {
1411 : NameList::const_iterator iBar (
1412 0 : ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName));
1413 0 : if (iBar == iGroup->second.end())
1414 : {
1415 0 : iGroup->second.push_back(rsName);
1416 : }
1417 : }
1418 0 : }
1419 :
1420 :
1421 :
1422 :
1423 0 : bool ToolBarList::RemoveToolBar (
1424 : sd::ToolBarManager::ToolBarGroup eGroup,
1425 : const ::rtl::OUString& rsName)
1426 : {
1427 0 : Groups::iterator iGroup (maGroups.find(eGroup));
1428 0 : if (iGroup != maGroups.end())
1429 : {
1430 : NameList::iterator iBar (
1431 0 : ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName));
1432 0 : if (iBar != iGroup->second.end())
1433 : {
1434 0 : iGroup->second.erase(iBar);
1435 0 : return true;
1436 : }
1437 : }
1438 0 : return false;
1439 : }
1440 :
1441 :
1442 :
1443 :
1444 0 : void ToolBarList::MakeRequestedToolBarList (NameList& rRequestedToolBars) const
1445 : {
1446 0 : for (int i=sd::ToolBarManager::TBG__FIRST; i<=sd::ToolBarManager::TBG__LAST; ++i)
1447 : {
1448 0 : ::sd::ToolBarManager::ToolBarGroup eGroup = (::sd::ToolBarManager::ToolBarGroup)i;
1449 0 : Groups::const_iterator iGroup (maGroups.find(eGroup));
1450 0 : if (iGroup != maGroups.end())
1451 : ::std::copy(
1452 0 : iGroup->second.begin(),
1453 0 : iGroup->second.end(),
1454 0 : ::std::inserter(rRequestedToolBars,rRequestedToolBars.end()));
1455 : }
1456 0 : }
1457 :
1458 :
1459 :
1460 :
1461 0 : void ToolBarList::GetToolBarsToActivate (NameList& rToolBars) const
1462 : {
1463 0 : NameList aRequestedToolBars;
1464 0 : MakeRequestedToolBarList(aRequestedToolBars);
1465 :
1466 0 : NameList::const_iterator iToolBar;
1467 0 : for (iToolBar=aRequestedToolBars.begin(); iToolBar!=aRequestedToolBars.end(); ++iToolBar)
1468 : {
1469 0 : if (::std::find(maActiveToolBars.begin(),maActiveToolBars.end(),*iToolBar)
1470 0 : == maActiveToolBars.end())
1471 : {
1472 0 : rToolBars.push_back(*iToolBar);
1473 : }
1474 0 : }
1475 0 : }
1476 :
1477 :
1478 :
1479 :
1480 0 : void ToolBarList::GetToolBarsToDeactivate (NameList& rToolBars) const
1481 : {
1482 0 : NameList aRequestedToolBars;
1483 0 : MakeRequestedToolBarList(aRequestedToolBars);
1484 :
1485 0 : NameList::const_iterator iToolBar;
1486 0 : for (iToolBar=maActiveToolBars.begin(); iToolBar!=maActiveToolBars.end(); ++iToolBar)
1487 : {
1488 0 : if (::std::find(aRequestedToolBars.begin(),aRequestedToolBars.end(),*iToolBar)
1489 0 : == aRequestedToolBars.end())
1490 : {
1491 0 : rToolBars.push_back(*iToolBar);
1492 : }
1493 0 : }
1494 0 : }
1495 :
1496 :
1497 :
1498 :
1499 0 : void ToolBarList::MarkToolBarAsActive (const ::rtl::OUString& rsName)
1500 : {
1501 0 : maActiveToolBars.push_back(rsName);
1502 0 : }
1503 :
1504 :
1505 :
1506 :
1507 0 : void ToolBarList::MarkToolBarAsNotActive (const ::rtl::OUString& rsName)
1508 : {
1509 : maActiveToolBars.erase(
1510 0 : ::std::find(maActiveToolBars.begin(),maActiveToolBars.end(), rsName));
1511 0 : }
1512 :
1513 :
1514 :
1515 :
1516 0 : void ToolBarList::MarkAllToolBarsAsNotActive (void)
1517 : {
1518 0 : maActiveToolBars.clear();
1519 0 : }
1520 :
1521 :
1522 :
1523 :
1524 : //===== ToolBarShellList ======================================================
1525 :
1526 0 : ToolBarShellList::ShellDescriptor::ShellDescriptor (
1527 : ShellId nId,
1528 : sd::ToolBarManager::ToolBarGroup eGroup)
1529 : : mnId(nId),
1530 0 : meGroup(eGroup)
1531 : {
1532 0 : }
1533 :
1534 :
1535 :
1536 :
1537 0 : ToolBarShellList::ToolBarShellList (void)
1538 : : maNewList()
1539 0 : , maCurrentList()
1540 : {
1541 0 : }
1542 :
1543 :
1544 :
1545 :
1546 0 : void ToolBarShellList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1547 : {
1548 : // In every loop we erase the first member of the specified group.
1549 : // Because that invalidates the iterator another loop is started after
1550 : // that. The loop is left only when no member of the group is found and
1551 : // no element is erased
1552 : bool bLoop;
1553 0 : do
1554 : {
1555 0 : bLoop = false;
1556 :
1557 0 : GroupedShellList::iterator iDescriptor;
1558 0 : for (iDescriptor=maNewList.begin(); iDescriptor!=maNewList.end(); ++iDescriptor)
1559 0 : if (iDescriptor->meGroup == eGroup)
1560 : {
1561 0 : maNewList.erase(iDescriptor);
1562 : // Erasing the descriptor invalidated the iterator so we
1563 : // have to exit the for loop and start anew to search for
1564 : // further elements of the group.
1565 0 : bLoop = true;
1566 0 : break;
1567 : }
1568 : }
1569 : while (bLoop);
1570 0 : }
1571 :
1572 :
1573 :
1574 :
1575 0 : void ToolBarShellList::AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId)
1576 : {
1577 : // Make sure that the shell is not added twice (and possibly in
1578 : // different groups.)
1579 0 : ShellDescriptor aDescriptor (nId,eGroup);
1580 0 : GroupedShellList::iterator iDescriptor (maNewList.find(aDescriptor));
1581 0 : if (iDescriptor != maNewList.end())
1582 : {
1583 : // The shell is already requested.
1584 0 : if (iDescriptor->meGroup != eGroup)
1585 : {
1586 : // It is now being requested for another group.
1587 : // (Is this an error?)
1588 : // Move it to that group.
1589 0 : maNewList.erase(iDescriptor);
1590 0 : maNewList.insert(aDescriptor);
1591 : }
1592 : // else nothing to do.
1593 : }
1594 : else
1595 0 : maNewList.insert(aDescriptor);
1596 0 : }
1597 :
1598 :
1599 :
1600 :
1601 0 : void ToolBarShellList::ReleaseAllShells (ToolBarRules& rRules)
1602 : {
1603 : // Release the currently active tool bars.
1604 0 : GroupedShellList aList (maCurrentList);
1605 0 : GroupedShellList::iterator iDescriptor;
1606 0 : for (iDescriptor=aList.begin(); iDescriptor!=aList.end(); ++iDescriptor)
1607 : {
1608 0 : rRules.SubShellRemoved(iDescriptor->meGroup, iDescriptor->mnId);
1609 : }
1610 :
1611 : // Clear the list of requested tool bars.
1612 0 : maNewList.clear();
1613 0 : }
1614 :
1615 :
1616 :
1617 :
1618 0 : void ToolBarShellList::UpdateShells (
1619 : const ::boost::shared_ptr<ViewShell>& rpMainViewShell,
1620 : const ::boost::shared_ptr<ViewShellManager>& rpManager)
1621 : {
1622 0 : if (rpMainViewShell.get() != NULL)
1623 : {
1624 0 : GroupedShellList aList;
1625 :
1626 : // Deactivate shells that are in maCurrentList, but not in
1627 : // maNewList.
1628 : ::std::set_difference(maCurrentList.begin(), maCurrentList.end(),
1629 : maNewList.begin(), maNewList.end(),
1630 0 : std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1631 0 : for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell)
1632 : {
1633 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": deactivating tool bar shell " << iShell->mnId);
1634 0 : rpManager->DeactivateSubShell(*rpMainViewShell, iShell->mnId);
1635 : }
1636 :
1637 : // Activate shells that are in maNewList, but not in
1638 : // maCurrentList.
1639 0 : aList.clear();
1640 : ::std::set_difference(maNewList.begin(), maNewList.end(),
1641 : maCurrentList.begin(), maCurrentList.end(),
1642 0 : std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1643 0 : for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell)
1644 : {
1645 : SAL_INFO("sd.view", OSL_THIS_FUNC << ": activating tool bar shell " << iShell->mnId);
1646 0 : rpManager->ActivateSubShell(*rpMainViewShell, iShell->mnId);
1647 : }
1648 :
1649 : // The maNewList now refelects the current state and thus is made
1650 : // maCurrentList.
1651 0 : maCurrentList = maNewList;
1652 : }
1653 0 : }
1654 :
1655 :
1656 :
1657 :
1658 9 : } // end of anonymous namespace
1659 :
1660 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
