sd/source/ui/toolpanel/TaskPaneViewShell.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: TaskPaneViewShell.cxx,v $
  10  * $Revision: 1.21 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "TaskPaneViewShell.hxx"
  35
  36 #include "TaskPaneShellManager.hxx"
  37 #include "ToolPanelChildWindow.hrc"
  38 #include "ToolPanelChildWindow.hxx"
  39 #include "taskpane/SlideSorterCacheDisplay.hxx"
  40 #include "taskpane/ToolPanel.hxx"
  41 #include "taskpane/TitledControl.hxx"
  42 #include "LayoutMenu.hxx"
  43 #include "TaskPaneFocusManager.hxx"
  44 #include "taskpane/SubToolPanel.hxx"
  45 #include "taskpane/ScrollPanel.hxx"
  46 #include "taskpane/TaskPaneControlFactory.hxx"
  47 #include "controls/MasterPagesPanel.hxx"
  48 #include "controls/MasterPagesSelector.hxx"
  49 #include "controls/TableDesignPanel.hxx"
  50 #include "controls/CustomAnimationPanel.hxx"
  51 #include "controls/SlideTransitionPanel.hxx"
  52 #include "controls/AnimationSchemesPanel.hxx"
  53 #include "TitleToolBox.hxx"
  54 #include "taskpane/ControlContainer.hxx"
  55 #include "FrameView.hxx"
  56 #include "Window.hxx"
  57 #include "PaneDockingWindow.hxx"
  58 #include "AccessibleTaskPane.hxx"
  59 #include "DrawSubController.hxx"
  60 #include "sdmod.hxx"
  61 #include "app.hrc"
  62 #include "glob.hrc"
  63 #include "res_bmp.hrc"
  64 #include "helpids.h"
  65 #include "strings.hrc"
  66 #include "sdresid.hxx"
  67 #include "framework/FrameworkHelper.hxx"
  68 #include <com/sun/star/drawing/framework/XResourceId.hpp>
  69 #include <com/sun/star/drawing/framework/ResourceActivationMode.hpp>
  70 #include <com/sun/star/drawing/XDrawSubController.hpp>
  71
  72 #include <svx/dlgctrl.hxx>
  73 #include <sfx2/bindings.hxx>
  74 #include <sfx2/dispatch.hxx>
  75 #include <sfx2/viewfrm.hxx>
  76 #include <sfx2/msg.hxx>
  77 #include <sfx2/objface.hxx>
  78 #include <svx/colrctrl.hxx>
  79 #include <svx/xtable.hxx>
  80 #include <vcl/dockwin.hxx>
  81 #include "sdtreelb.hxx"
  82 #include "DrawViewShell.hxx"
  83 #include "drawdoc.hxx"
  84 #include "ViewShellBase.hxx"
  85 #include <svx/ruler.hxx>
  86 #include <vcl/svapp.hxx>
  87
  88 //#define SHOW_TEST_PANEL
  89 #ifdef SHOW_TEST_PANEL
  90 #include "TestPanel.hxx"
  91 #endif
  92 //#define SHOW_COLOR_MENU
  93 #ifdef SHOW_COLOR_MENU
  94 #include "TestMenu.hxx"
  95 #endif
  96
  97 #include <vector>
  98 #include <boost/shared_ptr.hpp>
  99
 100 using namespace ::sd::toolpanel;
 101
 102 #define TaskPaneViewShell
 103 #include "sdslots.hxx"
 104
 105
 106 using namespace ::com::sun::star;
 107 using namespace ::com::sun::star::uno;
 108 using ::sd::framework::FrameworkHelper;
 109
 110
 111 namespace sd { namespace toolpanel {
 112
 113 SFX_IMPL_INTERFACE(TaskPaneViewShell, SfxShell, SdResId(STR_TASKPANEVIEWSHELL))
 114 {
 115 }
 116
 117
 118 TYPEINIT1(TaskPaneViewShell, ViewShell);
 119
 120
 121 /** Inner implementation class of TaskPaneViewShell.
 122 */
 123 class TaskPaneViewShell::Implementation
 124 {
 125 public:
 126     static const sal_uInt32 mnInvalidId = 0xffffffff;
 127
 128     Implementation (void);
 129     ~Implementation (void);
 130
 131     /** Here the panels are created that are shown in the task pane.
 132     */
 133     void Setup (ToolPanel* pToolPanel, ViewShellBase& rBase);
 134
 135     /** Make a new panel known to the translation table that translates
 136         between internal indices as returned by
 137         ControlContainer::AddControl() and public indices defined by
 138         TaskPaneViewShell::PanelId.
 139     */
 140     void AddPanel (sal_uInt32 nInternalId, PanelId nPublicId);
 141
 142     /** Return the public id for the given internal one.
 143         @return
 144             When the given public id is not known then PID_UNKNOWN is
 145             returned.
 146     */
 147     PanelId GetPublicId (sal_uInt32 nInternalId) const;
 148
 149     /** Return the internal id for the given public one.
 150         @return
 151             When the given public id is not known then mnInvalidId is
 152             returned.
 153     */
 154     sal_uInt32 GetInternalId (PanelId nPublicId) const;
 155
 156 private:
 157     /** This map translates between internal indices returned by
 158         ControlContainer::AddControl() and public indices defined by
 159         TaskPaneViewShell::PanelId.
 160     */
 161     typedef ::std::vector<PanelId> InternalIdToPanelIdMap;
 162     InternalIdToPanelIdMap maIndexMap;
 163 };
 164
 165
 166
 167
 168 namespace {
 169
 170 enum MenuId {
 171     MID_UNLOCK_TASK_PANEL = 1,
 172     MID_LOCK_TASK_PANEL = 2,
 173     MID_CUSTOMIZE = 3,
 174     MID_FIRST_CONTROL = 4
 175 };
 176
 177 /** This control is used for extracting the title string from the resource
 178     of some dialogs that are displayed in the task pane.  With this the
 179     actual controls can be created on demand.  This class only loads (a part
 180     of) their resource.
 181 */
 182 class DummyControl : public Control
 183 {
 184 public:
 185     DummyControl (::Window* pParent, const ResId& rResId)
 186         : Control(pParent,rResId)
 187     {
 188         FreeResource();
 189     }
 190 };
 191
 192 class ResourceActivationClickHandler
 193 {
 194 public:
 195     ResourceActivationClickHandler (
 196         const ::boost::shared_ptr<FrameworkHelper>& rpFrameworkHelper,
 197         const Reference<drawing::framework::XResourceId>& rxResourceId,
 198         ControlContainer& rControlContainer);
 199     void operator () (TitledControl& rTitledControl);
 200
 201 private:
 202     ::boost::shared_ptr<FrameworkHelper> mpFrameworkHelper;
 203     Reference<drawing::framework::XResourceId> mxResourceId;
 204     ControlContainer& mrControlContainer;
 205 };
 206
 207 } // end of anonymouse namespace
 208
 209
 210
 211
 212
 213 void TaskPaneViewShell::Implementation::Setup (
 214     ToolPanel* pToolPanel,
 215     ViewShellBase& rBase)
 216 {
 217     SdDrawDocument* pDocument = rBase.GetDocument();
 218     sal_uInt32 nId;
 219     sal_uInt32 nIdOfControlToExpand;
 220
 221     ::boost::shared_ptr<FrameworkHelper> pFrameworkHelper (FrameworkHelper::Instance(rBase));
 222     Reference<drawing::framework::XResourceId> xTaskPaneId (pFrameworkHelper->CreateResourceId(
 223         FrameworkHelper::msTaskPaneURL, FrameworkHelper::msRightPaneURL));
 224
 225     // The master page controls.
 226     nId = pToolPanel->AddControl (
 227         controls::MasterPagesPanel::CreateControlFactory(rBase),
 228         SdResId(STR_TASKPANEL_MASTER_PAGE_TITLE),
 229         HID_SD_SLIDE_DESIGNS,
 230         ResourceActivationClickHandler(
 231             pFrameworkHelper,
 232             pFrameworkHelper->CreateResourceId(
 233                 FrameworkHelper::msMasterPagesTaskPanelURL, xTaskPaneId),
 234             pToolPanel->GetControlContainer()));
 235     AddPanel (nId, PID_MASTER_PAGES);
 236
 237     // Layout Menu.
 238     nId = pToolPanel->AddControl (
 239         LayoutMenu::CreateControlFactory(rBase, *pDocument->GetDocSh()),
 240         SdResId(STR_TASKPANEL_LAYOUT_MENU_TITLE),
 241         HID_SD_SLIDE_LAYOUTS,
 242         ResourceActivationClickHandler(
 243             pFrameworkHelper,
 244             pFrameworkHelper->CreateResourceId(
 245                 FrameworkHelper::msLayoutTaskPanelURL, xTaskPaneId),
 246             pToolPanel->GetControlContainer()));
 247     AddPanel (nId, PID_LAYOUT);
 248     nIdOfControlToExpand = nId;
 249
 250     {
 251         DummyControl aControl (pToolPanel, SdResId(DLG_TABLEDESIGNPANE));
 252
 253         // TableDesignPanel
 254         nId = pToolPanel->AddControl (
 255             controls::TableDesignPanel::CreateControlFactory(rBase),
 256             aControl.GetText(),
 257             HID_SD_TABLE_DESIGN,
 258             ResourceActivationClickHandler(
 259                 pFrameworkHelper,
 260                     pFrameworkHelper->CreateResourceId(
 261                         FrameworkHelper::msTableDesignPanelURL, xTaskPaneId),
 262                 pToolPanel->GetControlContainer()));
 263         AddPanel (nId, PID_TABLE_DESIGN);
 264     }
 265
 266     {
 267         DummyControl aControl (pToolPanel, SdResId(RID_CUSTOMANIMATION_START+0));
 268
 269         // CustomAnimationPanel
 270         nId = pToolPanel->AddControl (
 271             controls::CustomAnimationPanel::CreateControlFactory(rBase),
 272             aControl.GetText(),
 273             HID_SD_CUSTOM_ANIMATIONS,
 274             ResourceActivationClickHandler(
 275                 pFrameworkHelper,
 276                     pFrameworkHelper->CreateResourceId(
 277                         FrameworkHelper::msCustomAnimationTaskPanelURL, xTaskPaneId),
 278                 pToolPanel->GetControlContainer()));
 279         AddPanel (nId, PID_CUSTOM_ANIMATION);
 280     }
 281
 282     // SlideTransitionPanel
 283     {
 284         DummyControl aControl (pToolPanel, SdResId(RID_CUSTOMANIMATION_START+3));
 285
 286         nId = pToolPanel->AddControl (
 287             controls::SlideTransitionPanel::CreateControlFactory(rBase),
 288             aControl.GetText(),
 289             HID_SD_SLIDE_TRANSITIONS,
 290             ResourceActivationClickHandler(
 291                 pFrameworkHelper,
 292                     pFrameworkHelper->CreateResourceId(
 293                         FrameworkHelper::msSlideTransitionTaskPanelURL, xTaskPaneId),
 294                 pToolPanel->GetControlContainer()));
 295         AddPanel (nId, PID_SLIDE_TRANSITION);
 296     }
 297
 298 #ifdef SHOW_COLOR_MENU
 299     // Test Menu.
 300     pToolPanel->AddControl (
 301         ColorMenu::CreateControlFactory(),
 302         String::CreateFromAscii ("Color Test Menu"),
 303         0);
 304 #endif
 305
 306 #ifdef SHOW_TEST_PANEL
 307     // Test Panel.
 308     pToolPanel->AddControl (
 309         TestPanel::CreateControlFactory(),
 310         String::CreateFromAscii ("Test Panel"),
 311         0);
 312 #endif
 313
 314 #ifdef USE_SLIDE_SORTER_CACHE_DISPLAY
 315     pToolPanel->AddControl (
 316         SlideSorterCacheDisplay::CreateControlFactory(pDocument),
 317         String::CreateFromAscii("Slide Sorter Cache Status"),
 318         0);
 319 #endif
 320
 321     // Expand the layout menu.
 322     pToolPanel->GetControlContainer().SetExpansionState (
 323         nIdOfControlToExpand,
 324         ControlContainer::ES_EXPAND);
 325
 326     pToolPanel->GetWindow()->Show();
 327 }
 328
 329
 330
 331
 332 void TaskPaneViewShell::Initialize (void)
 333 {
 334     if ( ! mbIsInitialized)
 335     {
 336         mbIsInitialized = true;
 337         mpImpl->Setup (mpTaskPane.get(), GetViewShellBase());
 338     }
 339 }
 340
 341
 342
 343
 344 TaskPaneViewShell::TaskPaneViewShell (
 345     SfxViewFrame* pFrame,
 346     ViewShellBase& rViewShellBase,
 347     ::Window* pParentWindow,
 348     FrameView* pFrameViewArgument)
 349     : ViewShell (pFrame, pParentWindow, rViewShellBase),
 350       mpImpl(NULL),
 351       mpTaskPane(NULL),
 352       mbIsInitialized(false),
 353       mpSubShellManager(),
 354       mnMenuId(0)
 355 {
 356     meShellType = ST_TASK_PANE;
 357
 358     mpImpl.reset (new Implementation());
 359
 360     mpContentWindow->SetCenterAllowed (false);
 361     pParentWindow->SetStyle(pParentWindow->GetStyle() | WB_DIALOGCONTROL);
 362
 363     mpTaskPane = ::std::auto_ptr<ToolPanel>(new ToolPanel (
 364         mpContentWindow.get(), *this));
 365
 366     GetParentWindow()->SetBackground(Wallpaper());
 367     mpContentWindow->SetBackground(Wallpaper());
 368
 369     GetParentWindow()->SetHelpId(HID_SD_TASK_PANE);
 370
 371     PaneDockingWindow* pDockingWindow = dynamic_cast<PaneDockingWindow*>(GetDockingWindow());
 372     if (pDockingWindow != NULL)
 373     {
 374         pDockingWindow->InitializeTitleToolBox();
 375         mnMenuId = pDockingWindow->AddMenu (
 376             String(SdResId(STR_TASKPANEL_MASTER_PAGE_MENU_TITLE)),
 377             HID_SD_TASK_PANE_VIEW_MENU,
 378             LINK(this, TaskPaneViewShell, ToolboxClickHandler));
 379     }
 380
 381     // Tell the focus manager that we want to pass the focus to our
 382     // child.
 383     FocusManager::Instance().RegisterDownLink(pParentWindow, mpTaskPane.get());
 384
 385     SetPool (&GetDoc()->GetPool());
 386
 387     if (pFrameViewArgument != NULL)
 388         mpFrameView = pFrameViewArgument;
 389     else
 390         mpFrameView = new FrameView(GetDoc());
 391     GetFrameView()->Connect();
 392
 393     // Hide or delete unused controls that we have inherited from the
 394     // ViewShell base class.
 395     mpHorizontalScrollBar.reset();
 396     mpVerticalScrollBar.reset();
 397     mpScrollBarBox.reset();
 398     mpHorizontalRuler.reset();
 399     mpVerticalRuler.reset();
 400
 401     SetName (String (RTL_CONSTASCII_USTRINGPARAM("TaskPaneViewShell")));
 402
 403     // For accessibility we have to shortly hide the content window.  This
 404     // triggers the construction of a new accessibility object for the new
 405     // view shell.  (One is created earlier while the construtor of the base
 406     // class is executed.  At that time the correct accessibility object can
 407     // not be constructed.)
 408     if (mpContentWindow.get() !=NULL)
 409     {
 410         mpContentWindow->Hide();
 411         mpContentWindow->Show();
 412     }
 413
 414     // Register the shell manager as factory at the ViewShellManager.
 415     mpSubShellManager.reset (new TaskPaneShellManager(
 416         GetViewShellBase().GetViewShellManager(),
 417         *this));
 418     GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this, mpSubShellManager);
 419 }
 420
 421
 422
 423
 424 TaskPaneViewShell::~TaskPaneViewShell (void)
 425 {
 426     GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory(this, mpSubShellManager);
 427 }
 428
 429
 430
 431 // static
 432 void TaskPaneViewShell::RegisterControls (void)
 433 {
 434     SfxModule* pModule = SD_MOD();
 435     controls::MasterPagesSelector::RegisterInterface (pModule);
 436     LayoutMenu::RegisterInterface (pModule);
 437 }
 438
 439
 440
 441
 442 void TaskPaneViewShell::ArrangeGUIElements (void)
 443 {
 444     ViewShell::ArrangeGUIElements();
 445
 446     Point aOrigin (maViewPos);
 447     Size aSize (maViewSize);
 448
 449     Initialize();
 450
 451     // Place the task pane.
 452     if (mpTaskPane.get() != NULL)
 453         mpTaskPane->SetPosSizePixel (Point(0,0), aSize);
 454 }
 455
 456
 457
 458
 459 void TaskPaneViewShell::GetFocus (void)
 460 {
 461     Invalidate ();
 462 }
 463
 464
 465
 466
 467 void TaskPaneViewShell::LoseFocus (void)
 468 {
 469     Invalidate ();
 470 }
 471
 472
 473
 474
 475 void TaskPaneViewShell::KeyInput (const KeyEvent& rEvent)
 476 {
 477     KeyCode nCode = rEvent.GetKeyCode();
 478     if (nCode == KEY_RETURN)
 479     {
 480         mpTaskPane->GrabFocus();
 481     }
 482     else
 483         ViewShell::KeyInput (rEvent, NULL);
 484 }
 485
 486
 487
 488
 489 IMPL_LINK(TaskPaneViewShell, ToolboxClickHandler, ToolBox*, pToolBox)
 490 {
 491     if (pToolBox->GetCurItemId() == mnMenuId)
 492     {
 493         pToolBox->EndSelection();
 494
 495         DockingWindow* pDockingWindow = GetDockingWindow();
 496         ::std::auto_ptr<PopupMenu> pMenu = CreatePopupMenu (
 497             pDockingWindow!=NULL && !pDockingWindow->IsFloatingMode());
 498         pMenu->SetSelectHdl (
 499             LINK(this, TaskPaneViewShell, MenuSelectHandler));
 500
 501         // pass toolbox button rect so the menu can stay open on button up
 502         Rectangle aRect = pToolBox->GetItemRect(mnMenuId);
 503         aRect.SetPos(pToolBox->GetPosPixel() );
 504         pMenu->Execute (pDockingWindow, aRect, POPUPMENU_EXECUTE_DOWN);
 505     }
 506
 507     return 0;
 508 }
 509
 510
 511
 512
 513 IMPL_LINK(TaskPaneViewShell, MenuSelectHandler, Menu*, pMenu)
 514 {
 515     if (pMenu)
 516     {
 517         pMenu->Deactivate();
 518         switch (pMenu->GetCurItemId())
 519         {
 520             case MID_UNLOCK_TASK_PANEL:
 521             {
 522                 DockingWindow* pDockingWindow = GetDockingWindow();
 523                 if (pDockingWindow != NULL)
 524                     pDockingWindow->SetFloatingMode (TRUE);
 525             }
 526             break;
 527
 528             case MID_LOCK_TASK_PANEL:
 529             {
 530                 DockingWindow* pDockingWindow = GetDockingWindow();
 531                 if (pDockingWindow != NULL)
 532                     pDockingWindow->SetFloatingMode (FALSE);
 533             }
 534             break;
 535
 536             case MID_CUSTOMIZE:
 537                 DBG_ASSERT (0, "Customization not yet implemented");
 538                 break;
 539
 540             default:
 541             {
 542                 sal_uInt32 nIndex (pMenu->GetUserValue(pMenu->GetCurItemId()));
 543                 mpTaskPane->GetControlContainer().SetVisibilityState (
 544                     nIndex,
 545                     ControlContainer::VS_TOGGLE);
 546                 //                mpTaskPane->Resize();
 547                 //                mpTaskPane->Invalidate();
 548             }
 549             break;
 550         }
 551     }
 552
 553     return 0;
 554 }
 555
 556
 557
 558
 559 ::std::auto_ptr<PopupMenu> TaskPaneViewShell::CreatePopupMenu (
 560     bool bIsDocking)
 561 {
 562     ::std::auto_ptr<PopupMenu> pMenu (new PopupMenu ());
 563     FloatingWindow* pFloat = static_cast<FloatingWindow*>(pMenu->GetWindow());
 564     if (pFloat != NULL)
 565     {
 566         pFloat->SetPopupModeFlags (
 567             pFloat->GetPopupModeFlags()
 568             | FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE);
 569     }
 570
 571     // warning free code changes:
 572     // FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE is 0x10000, so cast to USHORT is 0
 573     // so why was this used anyway?
 574     pMenu->SetMenuFlags (
 575         pMenu->GetMenuFlags() /* | (USHORT)FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE */ );
 576
 577     // Add one entry for every tool panel element to individually make
 578     // them visible or hide them.
 579     USHORT nIndex = MID_FIRST_CONTROL;
 580     sal_uInt32 nControlIndex;
 581     ControlContainer& rContainer (mpTaskPane->GetControlContainer());
 582     for (nControlIndex=0;
 583          nControlIndex<rContainer.GetControlCount();
 584          nControlIndex=rContainer.GetNextIndex(nControlIndex,true,false))
 585     {
 586         TreeNode* pChild = rContainer.GetControl(nControlIndex);
 587         TitledControl* pControl
 588             = static_cast<TitledControl*>(pChild->GetWindow());
 589         pMenu->InsertItem (nIndex,
 590             pControl->GetTitle(),
 591             MIB_CHECKABLE);
 592         pMenu->SetUserValue (nIndex, nControlIndex);
 593         if (pControl->IsVisible())
 594             pMenu->CheckItem (nIndex, TRUE);
 595         nIndex++;
 596     }
 597
 598     pMenu->InsertSeparator ();
 599
 600     // Add entry for docking or un-docking the tool panel.
 601     if (bIsDocking)
 602         pMenu->InsertItem (
 603             MID_UNLOCK_TASK_PANEL,
 604             String(SdResId(STR_TASKPANEL_MASTER_PAGE_MENU_UNLOCK)));
 605     else
 606         pMenu->InsertItem (
 607             MID_LOCK_TASK_PANEL,
 608             String(SdResId(STR_TASKPANEL_MASTER_PAGE_MENU_LOCK)));
 609     pMenu->RemoveDisabledEntries (FALSE, FALSE);
 610
 611     return pMenu;
 612 }
 613
 614
 615
 616
 617 SdPage* TaskPaneViewShell::GetActualPage (void)
 618 {
 619     return NULL;
 620 }
 621
 622 SdPage* TaskPaneViewShell::getCurrentPage(void) const
 623 {
 624     return NULL;
 625 }
 626
 627
 628
 629 void TaskPaneViewShell::Execute (SfxRequest& )
 630 {
 631 }
 632
 633
 634
 635
 636 void TaskPaneViewShell::GetState (SfxItemSet& rItemSet)
 637 {
 638     (void)rItemSet;
 639 }
 640
 641
 642
 643
 644 TaskPaneShellManager& TaskPaneViewShell::GetSubShellManager (void) const
 645 {
 646     return *mpSubShellManager.get();
 647 }
 648
 649
 650
 651
 652 DockingWindow* TaskPaneViewShell::GetDockingWindow (void)
 653 {
 654     ::Window* pParentWindow = GetParentWindow();
 655     DockingWindow* pDockingWindow = NULL;
 656     while (pParentWindow!=NULL && pDockingWindow==NULL)
 657     {
 658         pDockingWindow = dynamic_cast<DockingWindow*>(pParentWindow);
 659         pParentWindow = pParentWindow->GetParent();
 660     }
 661     return pDockingWindow;
 662 }
 663
 664
 665
 666
 667 void TaskPaneViewShell::ShowPanel (const PanelId nPublicId)
 668 {
 669     Initialize();
 670     sal_uInt32 nId (mpImpl->GetInternalId(nPublicId));
 671     if (nId != Implementation::mnInvalidId)
 672     {
 673         mpTaskPane->GetControlContainer().SetVisibilityState (
 674             nId,
 675             ControlContainer::VS_SHOW);
 676     }
 677 }
 678
 679
 680
 681
 682 void TaskPaneViewShell::HidePanel (const PanelId nPublicId)
 683 {
 684     Initialize();
 685     sal_uInt32 nId (mpImpl->GetInternalId(nPublicId));
 686     if (nId != Implementation::mnInvalidId)
 687     {
 688         mpTaskPane->GetControlContainer().SetVisibilityState (
 689             nId,
 690             ControlContainer::VS_HIDE);
 691     }
 692 }
 693
 694
 695
 696
 697 void TaskPaneViewShell::ExpandPanel (const PanelId nPublicId)
 698 {
 699    Initialize();
 700     sal_uInt32 nId (mpImpl->GetInternalId(nPublicId));
 701     if (nId != Implementation::mnInvalidId)
 702     {
 703         mpTaskPane->GetControlContainer().SetExpansionState (
 704             nId,
 705             ControlContainer::ES_EXPAND);
 706     }
 707 }
 708
 709
 710
 711
 712 void TaskPaneViewShell::CollapsePanel (const PanelId nPublicId)
 713 {
 714     Initialize();
 715     sal_uInt32 nId (mpImpl->GetInternalId(nPublicId));
 716     if (nId != Implementation::mnInvalidId)
 717     {
 718         mpTaskPane->GetControlContainer().SetExpansionState (
 719             nId,
 720             ControlContainer::ES_COLLAPSE);
 721     }
 722 }
 723
 724
 725
 726
 727 ::com::sun::star::uno::Reference<
 728     ::com::sun::star::accessibility::XAccessible>
 729     TaskPaneViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow)
 730 {
 731     ::com::sun::star::uno::Reference<
 732         ::com::sun::star::accessibility::XAccessible> xAccessible;
 733
 734     if (mpTaskPane.get()!=NULL && pWindow!=NULL)
 735     {
 736         // We have to call CreateAccessible directly so that we can specify
 737         // the correct accessible parent.
 738         ::Window* pParentWindow = pWindow->GetAccessibleParentWindow();
 739         if (pParentWindow != NULL)
 740             xAccessible = mpTaskPane->CreateAccessibleObject(
 741                 pParentWindow->GetAccessible());
 742     }
 743
 744     return xAccessible;
 745 }
 746
 747
 748
 749
 750 Reference<drawing::XDrawSubController> TaskPaneViewShell::CreateSubController (void)
 751 {
 752     // This view shell is not designed to be the main view shell and thus
 753     // does not support a UNO sub controller.
 754     return Reference<drawing::XDrawSubController>();
 755 }
 756
 757
 758
 759
 760 bool TaskPaneViewShell::RelocateToParentWindow (::Window* pParentWindow)
 761 {
 762     ::Window* pOldParentWindow = GetParentWindow();
 763     FocusManager::Instance().RemoveLinks(pOldParentWindow, mpTaskPane.get());
 764     FocusManager::Instance().RemoveLinks(mpTaskPane.get(), pOldParentWindow);
 765
 766     ViewShell::RelocateToParentWindow(pParentWindow);
 767
 768     PaneDockingWindow* pDockingWindow = dynamic_cast<PaneDockingWindow*>(GetDockingWindow());
 769     if (pDockingWindow != NULL)
 770     {
 771         pDockingWindow->InitializeTitleToolBox();
 772         mnMenuId = pDockingWindow->AddMenu (
 773             String(SdResId(STR_TASKPANEL_MASTER_PAGE_MENU_TITLE)),
 774             HID_SD_TASK_PANE_VIEW_MENU,
 775             LINK(this, TaskPaneViewShell, ToolboxClickHandler));
 776     }
 777     FocusManager::Instance().RegisterDownLink(pParentWindow, mpTaskPane.get());
 778
 779     Resize();
 780
 781     return true;
 782 }
 783
 784
 785
 786
 787 //===== TaskPaneViewShell::Implementation =====================================
 788
 789 TaskPaneViewShell::Implementation::Implementation (void)
 790     : maIndexMap(
 791         (InternalIdToPanelIdMap::size_type)PID__END,
 792         PID_UNKNOWN)
 793 {
 794 }
 795
 796
 797
 798
 799 TaskPaneViewShell::Implementation::~Implementation (void)
 800 {
 801 }
 802
 803
 804
 805
 806 void TaskPaneViewShell::Implementation::AddPanel (
 807     sal_uInt32 nInternalId,
 808     PanelId nPublicId)
 809 {
 810     maIndexMap[nInternalId] = nPublicId;
 811 }
 812
 813
 814
 815
 816 TaskPaneViewShell::PanelId
 817     TaskPaneViewShell::Implementation::GetPublicId (
 818         sal_uInt32 nInternalId) const
 819 {
 820     if (nInternalId < maIndexMap.size())
 821         return maIndexMap[nInternalId];
 822     else
 823         return PID_UNKNOWN;
 824 }
 825
 826
 827
 828
 829 sal_uInt32
 830     TaskPaneViewShell::Implementation::GetInternalId (
 831         TaskPaneViewShell::PanelId nPublicId) const
 832 {
 833     sal_uInt32 nId = mnInvalidId;
 834     for (sal_uInt32 nI=0; nI<maIndexMap.size(); nI++)
 835         if (maIndexMap[nI] == nPublicId)
 836         {
 837             nId = nI;
 838             break;
 839         }
 840
 841     return nId;
 842 }
 843
 844
 845
 846
 847 //===== PanelActivation =======================================================
 848
 849 PanelActivation::PanelActivation (ViewShellBase& rBase, TaskPaneViewShell::PanelId nPanelId)
 850     : mrBase(rBase),
 851       mnPanelId(nPanelId)
 852 {
 853 }
 854
 855 void PanelActivation::operator() (bool)
 856 {
 857     toolpanel::TaskPaneViewShell* pTaskPane
 858         = dynamic_cast<toolpanel::TaskPaneViewShell*>(
 859             framework::FrameworkHelper::Instance(mrBase)
 860             ->GetViewShell(framework::FrameworkHelper::msRightPaneURL).get());
 861     if (pTaskPane != NULL)
 862         pTaskPane->ShowPanel(mnPanelId);
 863 }
 864
 865
 866
 867
 868 //===== ResourceActivationClickHandler ========================================
 869
 870 ResourceActivationClickHandler::ResourceActivationClickHandler (
 871     const ::boost::shared_ptr<FrameworkHelper>& rpFrameworkHelper,
 872     const Reference<drawing::framework::XResourceId>& rxResourceId,
 873     ControlContainer& rControlContainer)
 874     : mpFrameworkHelper(rpFrameworkHelper),
 875       mxResourceId(rxResourceId),
 876       mrControlContainer(rControlContainer)
 877 {
 878 }
 879
 880
 881
 882
 883 void ResourceActivationClickHandler::operator () (TitledControl& rTitledControl)
 884 {
 885     mrControlContainer.SetExpansionState (
 886         &rTitledControl,
 887         ControlContainer::ES_EXPAND);
 888     mpFrameworkHelper->GetConfigurationController()->requestResourceActivation(
 889         mxResourceId, drawing::framework::ResourceActivationMode_REPLACE);
 890 }
 891
 892
 893 } } // end of namespace ::sd::toolpanel