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