sdext/source/presenter/PresenterProtocolHandler.cxx

   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 <memory>
  21 #include "PresenterProtocolHandler.hxx"
  22 #include "PresenterController.hxx"
  23 #include "PresenterNotesView.hxx"
  24 #include "PresenterPaneContainer.hxx"
  25 #include "PresenterViewFactory.hxx"
  26 #include "PresenterWindowManager.hxx"
  27 #include <cppuhelper/compbase.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <algorithm>
  30
  31 using namespace ::com::sun::star;
  32 using namespace ::com::sun::star::uno;
  33 using namespace ::com::sun::star::drawing::framework;
  34
  35 namespace sdext::presenter {
  36
  37 namespace {
  38     class Command
  39     {
  40     public:
  41         virtual ~Command() {}
  42         virtual void Execute() = 0;
  43         virtual bool IsEnabled() const { return true; }
  44         virtual Any GetState() const { return Any(false); }
  45     };
  46
  47     class GotoPreviousSlideCommand : public Command
  48     {
  49     public:
  50         explicit GotoPreviousSlideCommand (
  51             const rtl::Reference<PresenterController>& rpPresenterController);
  52         virtual void Execute() override;
  53         virtual bool IsEnabled() const override;
  54     private:
  55         rtl::Reference<PresenterController> mpPresenterController;
  56     };
  57
  58     class GotoNextSlideCommand : public Command
  59     {
  60     public:
  61         explicit GotoNextSlideCommand (
  62             const rtl::Reference<PresenterController>& rpPresenterController);
  63         virtual void Execute() override;
  64         // The next slide command is always enabled, even when the current slide
  65         // is the last slide:  from the last slide it goes to the pause slide,
  66         // and from there it ends the slide show.
  67         virtual bool IsEnabled() const override { return true; }
  68     private:
  69         rtl::Reference<PresenterController> mpPresenterController;
  70     };
  71
  72     class GotoNextEffectCommand : public Command
  73     {
  74     public:
  75         explicit GotoNextEffectCommand (
  76             const rtl::Reference<PresenterController>& rpPresenterController);
  77         virtual void Execute() override;
  78         virtual bool IsEnabled() const override;
  79     private:
  80         rtl::Reference<PresenterController> mpPresenterController;
  81     };
  82
  83     class SwitchMonitorCommand : public Command
  84     {
  85     public:
  86         explicit SwitchMonitorCommand (
  87             const rtl::Reference<PresenterController>& rpPresenterController);
  88         virtual void Execute() override;
  89     private:
  90         rtl::Reference<PresenterController> mpPresenterController;
  91     };
  92
  93     class PauseResumeCommand : public Command
  94     {
  95     public:
  96         explicit PauseResumeCommand(const rtl::Reference<PresenterController>& rpPresenterController);
  97         virtual void Execute() override;
  98         virtual Any GetState() const override;
  99     private:
 100         rtl::Reference<PresenterController> mpPresenterController;
 101     };
 102
 103     /// This command restarts the presentation timer.
 104     class RestartTimerCommand : public Command
 105     {
 106     public:
 107         explicit RestartTimerCommand(const rtl::Reference<PresenterController>& rpPresenterController);
 108         virtual void Execute() override;
 109     private:
 110         rtl::Reference<PresenterController> mpPresenterController;
 111     };
 112
 113     class SetNotesViewCommand : public Command
 114     {
 115     public:
 116         SetNotesViewCommand (
 117             const bool bOn,
 118             const rtl::Reference<PresenterController>& rpPresenterController);
 119         virtual void Execute() override;
 120         virtual Any GetState() const override;
 121     private:
 122         bool mbOn;
 123         rtl::Reference<PresenterController> mpPresenterController;
 124     };
 125
 126     class SetSlideSorterCommand : public Command
 127     {
 128     public:
 129         SetSlideSorterCommand (
 130             const bool bOn,
 131             const rtl::Reference<PresenterController>& rpPresenterController);
 132         virtual void Execute() override;
 133         virtual Any GetState() const override;
 134     private:
 135         bool mbOn;
 136         rtl::Reference<PresenterController> mpPresenterController;
 137     };
 138
 139     class SetHelpViewCommand : public Command
 140     {
 141     public:
 142         SetHelpViewCommand (
 143             const bool bOn,
 144             const rtl::Reference<PresenterController>& rpPresenterController);
 145         virtual void Execute() override;
 146         virtual Any GetState() const override;
 147     private:
 148         bool mbOn;
 149         rtl::Reference<PresenterController> mpPresenterController;
 150     };
 151
 152     class NotesFontSizeCommand : public Command
 153     {
 154     public:
 155         NotesFontSizeCommand(
 156             const rtl::Reference<PresenterController>& rpPresenterController,
 157             const sal_Int32 nSizeChange);
 158         virtual void Execute() override;
 159         virtual Any GetState() const override;
 160     protected:
 161         ::rtl::Reference<PresenterNotesView> GetNotesView() const;
 162     private:
 163         rtl::Reference<PresenterController> mpPresenterController;
 164         const sal_Int32 mnSizeChange;
 165     };
 166
 167     class ExitPresenterCommand : public Command
 168     {
 169     public:
 170         explicit ExitPresenterCommand(const rtl::Reference<PresenterController>& rpPresenterController);
 171         virtual void Execute() override;
 172     private:
 173         rtl::Reference<PresenterController> mpPresenterController;
 174     };
 175
 176 } // end of anonymous namespace
 177
 178 namespace {
 179     typedef ::cppu::WeakComponentImplHelper <
 180         css::frame::XDispatch,
 181         css::document::XEventListener
 182         > PresenterDispatchInterfaceBase;
 183 }
 184
 185 class PresenterProtocolHandler::Dispatch
 186     : protected ::cppu::BaseMutex,
 187       public PresenterDispatchInterfaceBase
 188 {
 189 public:
 190     /** Create a new Dispatch object.  When the given command name
 191         (rsURLPath) is not known then an empty reference is returned.
 192     */
 193     static Reference<frame::XDispatch> Create (
 194         const OUString& rsURLPath,
 195         const ::rtl::Reference<PresenterController>& rpPresenterController);
 196
 197     void SAL_CALL disposing() override;
 198     static Command* CreateCommand (
 199         const OUString& rsURLPath,
 200         const ::rtl::Reference<PresenterController>& rpPresenterController);
 201
 202     // XDispatch
 203     virtual void SAL_CALL dispatch(
 204         const css::util::URL& aURL,
 205         const css::uno::Sequence<css::beans::PropertyValue>& rArguments) override;
 206
 207     virtual void SAL_CALL addStatusListener(
 208         const css::uno::Reference<css::frame::XStatusListener>& rxListener,
 209         const css::util::URL& rURL) override;
 210
 211     virtual void SAL_CALL removeStatusListener (
 212         const css::uno::Reference<css::frame::XStatusListener>& rxListener,
 213         const css::util::URL& rURL) override;
 214
 215     // document::XEventListener
 216
 217     virtual void SAL_CALL notifyEvent (const css::document::EventObject& rEvent) override;
 218
 219     // lang::XEventListener
 220
 221     virtual void SAL_CALL disposing (const css::lang::EventObject& rEvent) override;
 222
 223 private:
 224     OUString msURLPath;
 225     std::unique_ptr<Command> mpCommand;
 226     ::rtl::Reference<PresenterController> mpPresenterController;
 227     typedef ::std::vector<Reference<frame::XStatusListener> > StatusListenerContainer;
 228     StatusListenerContainer maStatusListenerContainer;
 229     bool mbIsListeningToWindowManager;
 230
 231     Dispatch (
 232         const OUString& rsURLPath,
 233         const ::rtl::Reference<PresenterController>& rpPresenterController);
 234     virtual ~Dispatch() override;
 235 };
 236
 237
 238 //===== PresenterProtocolHandler =========================================================
 239
 240 PresenterProtocolHandler::PresenterProtocolHandler ()
 241     : PresenterProtocolHandlerInterfaceBase(m_aMutex)
 242 {
 243 }
 244
 245 PresenterProtocolHandler::~PresenterProtocolHandler()
 246 {
 247 }
 248
 249 void SAL_CALL PresenterProtocolHandler::disposing()
 250 {
 251 }
 252
 253 //----- XInitialize -----------------------------------------------------------
 254
 255 void SAL_CALL PresenterProtocolHandler::initialize (const Sequence<Any>& aArguments)
 256 {
 257     ThrowIfDisposed();
 258     if (aArguments.getLength() <= 0)
 259         return;
 260
 261     try
 262     {
 263         Reference<frame::XFrame> xFrame;
 264         if (aArguments[0] >>= xFrame)
 265         {
 266             mpPresenterController = PresenterController::Instance(xFrame);
 267         }
 268     }
 269     catch (RuntimeException&)
 270     {
 271         OSL_ASSERT(false);
 272     }
 273 }
 274
 275 OUString PresenterProtocolHandler::getImplementationName()
 276 {
 277     return "org.libreoffice.comp.PresenterScreenProtocolHandler";
 278 }
 279
 280 sal_Bool PresenterProtocolHandler::supportsService(OUString const & ServiceName)
 281 {
 282     return cppu::supportsService(this, ServiceName);
 283 }
 284
 285 css::uno::Sequence<OUString>
 286 PresenterProtocolHandler::getSupportedServiceNames()
 287 {
 288     return { "com.sun.star.frame.ProtocolHandler" };
 289 }
 290
 291 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 292 sdext_PresenterProtocolHandler_get_implementation(
 293     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 294 {
 295     return cppu::acquire(new PresenterProtocolHandler());
 296 }
 297
 298 //----- XDispatchProvider -----------------------------------------------------
 299
 300 Reference<frame::XDispatch> SAL_CALL PresenterProtocolHandler::queryDispatch (
 301     const css::util::URL& rURL,
 302     const OUString&,
 303     sal_Int32)
 304 {
 305     ThrowIfDisposed();
 306
 307     Reference<frame::XDispatch> xDispatch;
 308
 309     if (rURL.Protocol == "vnd.org.libreoffice.presenterscreen:")
 310     {
 311         xDispatch.set(Dispatch::Create(rURL.Path, mpPresenterController));
 312     }
 313
 314     return xDispatch;
 315 }
 316
 317 Sequence<Reference<frame::XDispatch> > SAL_CALL PresenterProtocolHandler::queryDispatches(
 318     const Sequence<frame::DispatchDescriptor>&)
 319 {
 320     ThrowIfDisposed();
 321     return Sequence<Reference<frame::XDispatch> >();
 322 }
 323
 324
 325 void PresenterProtocolHandler::ThrowIfDisposed() const
 326 {
 327     if (rBHelper.bDisposed || rBHelper.bInDispose)
 328     {
 329         throw lang::DisposedException (
 330             "PresenterProtocolHandler object has already been disposed",
 331             const_cast<uno::XWeak*>(static_cast<const uno::XWeak*>(this)));
 332     }
 333 }
 334
 335 //===== PresenterProtocolHandler::Dispatch ====================================
 336
 337 Reference<frame::XDispatch> PresenterProtocolHandler::Dispatch::Create (
 338     const OUString& rsURLPath,
 339     const ::rtl::Reference<PresenterController>& rpPresenterController)
 340 {
 341     ::rtl::Reference<Dispatch> pDispatch (new Dispatch (rsURLPath, rpPresenterController));
 342     if (pDispatch->mpCommand != nullptr)
 343         return pDispatch;
 344     else
 345         return nullptr;
 346 }
 347
 348 PresenterProtocolHandler::Dispatch::Dispatch (
 349     const OUString& rsURLPath,
 350     const ::rtl::Reference<PresenterController>& rpPresenterController)
 351     : PresenterDispatchInterfaceBase(m_aMutex),
 352       msURLPath(rsURLPath),
 353       mpCommand(CreateCommand(rsURLPath, rpPresenterController)),
 354       mpPresenterController(rpPresenterController),
 355       maStatusListenerContainer(),
 356       mbIsListeningToWindowManager(false)
 357 {
 358     if (mpCommand != nullptr)
 359     {
 360         mpPresenterController->GetWindowManager()->AddLayoutListener(this);
 361         mbIsListeningToWindowManager = true;
 362     }
 363 }
 364
 365 Command* PresenterProtocolHandler::Dispatch::CreateCommand (
 366     const OUString& rsURLPath,
 367     const ::rtl::Reference<PresenterController>& rpPresenterController)
 368 {
 369     if (rsURLPath.getLength() <= 5)
 370         return nullptr;
 371
 372     if (rsURLPath == "CloseNotes")
 373         return new SetNotesViewCommand(false, rpPresenterController);
 374     if (rsURLPath == "CloseSlideSorter")
 375         return new SetSlideSorterCommand(false, rpPresenterController);
 376     if (rsURLPath == "CloseHelp")
 377         return new SetHelpViewCommand(false, rpPresenterController);
 378     if (rsURLPath == "GrowNotesFont")
 379         return new NotesFontSizeCommand(rpPresenterController, +1);
 380     if (rsURLPath == "NextEffect")
 381         return new GotoNextEffectCommand(rpPresenterController);
 382     if (rsURLPath == "NextSlide")
 383         return new GotoNextSlideCommand(rpPresenterController);
 384     if (rsURLPath == "PrevSlide")
 385         return new GotoPreviousSlideCommand(rpPresenterController);
 386     if (rsURLPath == "SwitchMonitor")
 387         return new SwitchMonitorCommand(rpPresenterController);
 388     if (rsURLPath == "PauseResumeTimer")
 389         return new PauseResumeCommand(rpPresenterController);
 390     if (rsURLPath == "RestartTimer")
 391         return new RestartTimerCommand(rpPresenterController);
 392     if (rsURLPath == "ShowNotes")
 393         return new SetNotesViewCommand(true, rpPresenterController);
 394     if (rsURLPath == "ShowSlideSorter")
 395         return new SetSlideSorterCommand(true, rpPresenterController);
 396     if (rsURLPath == "ShowHelp")
 397         return new SetHelpViewCommand(true, rpPresenterController);
 398     if (rsURLPath == "ShrinkNotesFont")
 399         return new NotesFontSizeCommand(rpPresenterController, -1);
 400     if (rsURLPath == "ExitPresenter")
 401         return new ExitPresenterCommand(rpPresenterController);
 402
 403     return nullptr;
 404 }
 405
 406 PresenterProtocolHandler::Dispatch::~Dispatch()
 407 {
 408 }
 409
 410 void PresenterProtocolHandler::Dispatch::disposing()
 411 {
 412     if (mbIsListeningToWindowManager)
 413     {
 414         if (mpPresenterController)
 415             mpPresenterController->GetWindowManager()->RemoveLayoutListener(this);
 416         mbIsListeningToWindowManager = false;
 417     }
 418
 419     msURLPath.clear();
 420     mpCommand.reset();
 421 }
 422
 423 //----- XDispatch -------------------------------------------------------------
 424
 425 void SAL_CALL PresenterProtocolHandler::Dispatch::dispatch(
 426     const css::util::URL& rURL,
 427     const css::uno::Sequence<css::beans::PropertyValue>& /*rArguments*/)
 428 {
 429     if (rBHelper.bDisposed || rBHelper.bInDispose)
 430     {
 431         throw lang::DisposedException (
 432             "PresenterProtocolHandler::Dispatch object has already been disposed",
 433             static_cast<uno::XWeak*>(this));
 434     }
 435
 436     if (rURL.Protocol != "vnd.org.libreoffice.presenterscreen:"
 437         || rURL.Path != msURLPath)
 438     {
 439         // We can not throw an IllegalArgumentException
 440         throw RuntimeException();
 441     }
 442
 443     if (mpCommand != nullptr)
 444         mpCommand->Execute();
 445 }
 446
 447 void SAL_CALL PresenterProtocolHandler::Dispatch::addStatusListener(
 448     const css::uno::Reference<css::frame::XStatusListener>& rxListener,
 449     const css::util::URL& rURL)
 450 {
 451     if (rURL.Path != msURLPath)
 452         throw RuntimeException();
 453
 454     maStatusListenerContainer.push_back(rxListener);
 455
 456     frame::FeatureStateEvent aEvent;
 457     aEvent.FeatureURL = rURL;
 458     aEvent.IsEnabled = mpCommand->IsEnabled();
 459     aEvent.Requery = false;
 460     aEvent.State = mpCommand->GetState();
 461     rxListener->statusChanged(aEvent);
 462 }
 463
 464 void SAL_CALL PresenterProtocolHandler::Dispatch::removeStatusListener (
 465     const css::uno::Reference<css::frame::XStatusListener>& rxListener,
 466     const css::util::URL& rURL)
 467 {
 468     if (rURL.Path != msURLPath)
 469         throw RuntimeException();
 470
 471     StatusListenerContainer::iterator iListener (
 472         ::std::find(
 473             maStatusListenerContainer.begin(),
 474             maStatusListenerContainer.end(),
 475             rxListener));
 476     if (iListener != maStatusListenerContainer.end())
 477         maStatusListenerContainer.erase(iListener);
 478 }
 479
 480 //----- document::XEventListener ----------------------------------------------
 481
 482 void SAL_CALL PresenterProtocolHandler::Dispatch::notifyEvent (
 483     const css::document::EventObject&)
 484 {
 485     mpCommand->GetState();
 486 }
 487
 488 //----- lang::XEventListener --------------------------------------------------
 489
 490 void SAL_CALL PresenterProtocolHandler::Dispatch::disposing (const css::lang::EventObject&)
 491 {
 492     mbIsListeningToWindowManager = false;
 493 }
 494
 495 //===== GotoPreviousSlideCommand ==============================================
 496
 497 GotoPreviousSlideCommand::GotoPreviousSlideCommand (
 498     const rtl::Reference<PresenterController>& rpPresenterController)
 499     : mpPresenterController(rpPresenterController)
 500 {
 501 }
 502
 503 void GotoPreviousSlideCommand::Execute()
 504 {
 505     if ( ! mpPresenterController.is())
 506         return;
 507
 508     if ( ! mpPresenterController->GetSlideShowController().is())
 509         return;
 510
 511     mpPresenterController->GetSlideShowController()->gotoPreviousSlide();
 512 }
 513
 514 bool GotoPreviousSlideCommand::IsEnabled() const
 515 {
 516     if ( ! mpPresenterController.is())
 517         return false;
 518
 519     if ( ! mpPresenterController->GetSlideShowController().is())
 520         return false;
 521
 522     return mpPresenterController->GetSlideShowController()->getCurrentSlideIndex()>0;
 523 }
 524
 525 //===== GotoNextEffect ========================================================
 526
 527 GotoNextEffectCommand::GotoNextEffectCommand (
 528     const rtl::Reference<PresenterController>& rpPresenterController)
 529     : mpPresenterController(rpPresenterController)
 530 {
 531 }
 532
 533 void GotoNextEffectCommand::Execute()
 534 {
 535     if ( ! mpPresenterController.is())
 536         return;
 537
 538     if ( ! mpPresenterController->GetSlideShowController().is())
 539         return;
 540
 541     mpPresenterController->GetSlideShowController()->gotoNextEffect();
 542 }
 543
 544 bool GotoNextEffectCommand::IsEnabled() const
 545 {
 546     if ( ! mpPresenterController.is())
 547         return false;
 548
 549     if ( ! mpPresenterController->GetSlideShowController().is())
 550         return false;
 551
 552     return ( mpPresenterController->GetSlideShowController()->getNextSlideIndex() < mpPresenterController->GetSlideShowController()->getSlideCount() );
 553
 554 }
 555
 556 //===== GotoNextSlide =========================================================
 557
 558 GotoNextSlideCommand::GotoNextSlideCommand (
 559     const rtl::Reference<PresenterController>& rpPresenterController)
 560     : mpPresenterController(rpPresenterController)
 561 {
 562 }
 563
 564 void GotoNextSlideCommand::Execute()
 565 {
 566     if ( ! mpPresenterController.is())
 567         return;
 568
 569     if ( ! mpPresenterController->GetSlideShowController().is())
 570         return;
 571
 572     mpPresenterController->GetSlideShowController()->gotoNextSlide();
 573 }
 574
 575 //===== SwitchMonitorCommand ==============================================
 576
 577 SwitchMonitorCommand::SwitchMonitorCommand (
 578     const rtl::Reference<PresenterController>& rpPresenterController)
 579     : mpPresenterController(rpPresenterController)
 580 {
 581 }
 582
 583 void SwitchMonitorCommand::Execute()
 584 {
 585     mpPresenterController->SwitchMonitors();
 586 }
 587
 588 //===== PauseResumeCommand ==============================================
 589
 590 PauseResumeCommand::PauseResumeCommand (const rtl::Reference<PresenterController>& rpPresenterController)
 591 : mpPresenterController(rpPresenterController)
 592 {
 593 }
 594
 595 void PauseResumeCommand::Execute()
 596 {
 597     if ( ! mpPresenterController.is())
 598         return;
 599
 600     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 601         mpPresenterController->GetWindowManager());
 602     if ( ! pWindowManager.is())
 603         return;
 604
 605     IPresentationTime* pPresentationTime = mpPresenterController->GetPresentationTime();
 606     if (!pPresentationTime)
 607         return;
 608
 609     if(pPresentationTime->isPaused())
 610     {
 611         pPresentationTime->setPauseStatus(false);
 612         pWindowManager->SetPauseState(false);
 613     }
 614     else
 615     {
 616         pPresentationTime->setPauseStatus(true);
 617         pWindowManager->SetPauseState(true);
 618     }
 619 }
 620
 621 Any PauseResumeCommand::GetState() const
 622 {
 623     if ( ! mpPresenterController.is())
 624         return Any(false);
 625
 626     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 627         mpPresenterController->GetWindowManager());
 628     if ( ! pWindowManager.is())
 629         return Any(false);
 630
 631     if (IPresentationTime* pPresentationTime = mpPresenterController->GetPresentationTime())
 632     {
 633         return Any(pPresentationTime->isPaused());
 634     }
 635     else
 636         return Any(false);
 637 }
 638
 639 RestartTimerCommand::RestartTimerCommand (const rtl::Reference<PresenterController>& rpPresenterController)
 640 : mpPresenterController(rpPresenterController)
 641 {
 642 }
 643
 644 void RestartTimerCommand::Execute()
 645 {
 646     if ( ! mpPresenterController.is())
 647         return;
 648
 649     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 650         mpPresenterController->GetWindowManager());
 651     if ( ! pWindowManager.is())
 652         return;
 653
 654     if (IPresentationTime* pPresentationTime = mpPresenterController->GetPresentationTime())
 655     {
 656         //Resets the pause status and restarts the timer
 657         pPresentationTime->setPauseStatus(false);
 658         pWindowManager->SetPauseState(false);
 659         pPresentationTime->restart();
 660     }
 661 }
 662
 663 //===== SetNotesViewCommand ===================================================
 664
 665 SetNotesViewCommand::SetNotesViewCommand (
 666     const bool bOn,
 667     const rtl::Reference<PresenterController>& rpPresenterController)
 668     : mbOn(bOn),
 669       mpPresenterController(rpPresenterController)
 670 {
 671 }
 672
 673 void SetNotesViewCommand::Execute()
 674 {
 675     if ( ! mpPresenterController.is())
 676         return;
 677
 678     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 679         mpPresenterController->GetWindowManager());
 680     if ( ! pWindowManager.is())
 681         return;
 682
 683     if (mbOn)
 684         pWindowManager->SetViewMode(PresenterWindowManager::VM_Notes);
 685     else
 686         pWindowManager->SetViewMode(PresenterWindowManager::VM_Standard);
 687 }
 688
 689 Any SetNotesViewCommand::GetState() const
 690 {
 691     if ( ! mpPresenterController.is())
 692         return Any(false);
 693
 694     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 695         mpPresenterController->GetWindowManager());
 696     if ( ! pWindowManager.is())
 697         return Any(false);
 698
 699     return Any(pWindowManager->GetViewMode() == PresenterWindowManager::VM_Notes);
 700 }
 701
 702 //===== SetSlideSorterCommand =================================================
 703
 704 SetSlideSorterCommand::SetSlideSorterCommand (
 705     const bool bOn,
 706     const rtl::Reference<PresenterController>& rpPresenterController)
 707     : mbOn(bOn),
 708       mpPresenterController(rpPresenterController)
 709 {
 710 }
 711
 712 void SetSlideSorterCommand::Execute()
 713 {
 714     if ( ! mpPresenterController.is())
 715         return;
 716
 717     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 718         mpPresenterController->GetWindowManager());
 719     if ( ! pWindowManager.is())
 720         return;
 721
 722     pWindowManager->SetSlideSorterState(mbOn);
 723 }
 724
 725 Any SetSlideSorterCommand::GetState() const
 726 {
 727     if ( ! mpPresenterController.is())
 728         return Any(false);
 729
 730     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 731         mpPresenterController->GetWindowManager());
 732     if ( ! pWindowManager.is())
 733         return Any(false);
 734
 735     return Any(pWindowManager->GetViewMode()==PresenterWindowManager::VM_SlideOverview);
 736 }
 737
 738 //===== SetHelpViewCommand ===================================================
 739
 740 SetHelpViewCommand::SetHelpViewCommand (
 741     const bool bOn,
 742     const rtl::Reference<PresenterController>& rpPresenterController)
 743     : mbOn(bOn),
 744       mpPresenterController(rpPresenterController)
 745 {
 746 }
 747
 748 void SetHelpViewCommand::Execute()
 749 {
 750     if ( ! mpPresenterController.is())
 751         return;
 752
 753     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 754         mpPresenterController->GetWindowManager());
 755     if ( ! pWindowManager.is())
 756         return;
 757
 758     pWindowManager->SetHelpViewState(mbOn);
 759 }
 760
 761 Any SetHelpViewCommand::GetState() const
 762 {
 763     if ( ! mpPresenterController.is())
 764         return Any(false);
 765
 766     ::rtl::Reference<PresenterWindowManager> pWindowManager (
 767         mpPresenterController->GetWindowManager());
 768     if ( ! pWindowManager.is())
 769         return Any(false);
 770
 771     return Any(pWindowManager->GetViewMode()==PresenterWindowManager::VM_Help);
 772 }
 773
 774 //===== NotesFontSizeCommand ==================================================
 775
 776 NotesFontSizeCommand::NotesFontSizeCommand(
 777     const rtl::Reference<PresenterController>& rpPresenterController,
 778     const sal_Int32 nSizeChange)
 779     : mpPresenterController(rpPresenterController),
 780       mnSizeChange(nSizeChange)
 781 {
 782 }
 783
 784 ::rtl::Reference<PresenterNotesView> NotesFontSizeCommand::GetNotesView() const
 785 {
 786     if (!mpPresenterController)
 787         return nullptr;
 788
 789     PresenterPaneContainer::SharedPaneDescriptor pDescriptor (
 790         mpPresenterController->GetPaneContainer()->FindViewURL(
 791             PresenterViewFactory::msNotesViewURL));
 792     if (!pDescriptor)
 793         return nullptr;
 794
 795     return dynamic_cast<PresenterNotesView*>(pDescriptor->mxView.get());
 796 }
 797
 798 void NotesFontSizeCommand::Execute()
 799 {
 800     ::rtl::Reference<PresenterNotesView> pView (GetNotesView());
 801     if (pView.is())
 802         pView->ChangeFontSize(mnSizeChange);
 803 }
 804
 805 Any NotesFontSizeCommand::GetState() const
 806 {
 807     return Any();
 808 }
 809
 810 //===== ExitPresenterCommand ==================================================
 811
 812 ExitPresenterCommand::ExitPresenterCommand (const rtl::Reference<PresenterController>& rpPresenterController)
 813 : mpPresenterController(rpPresenterController)
 814 {
 815 }
 816
 817 void ExitPresenterCommand::Execute()
 818 {
 819     if ( ! mpPresenterController.is())
 820         return;
 821
 822     mpPresenterController->ExitPresenter();
 823 }
 824
 825 } // end of namespace ::sdext::presenter
 826
 827 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */