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