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