sdext/source/presenter/PresenterPaneBase.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: PresenterPaneBase.cxx,v $
  10  *
  11  * $Revision: 1.5 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sdext.hxx"
  34
  35 #include "PresenterPaneBase.hxx"
  36 #include "PresenterCanvasHelper.hxx"
  37 #include "PresenterController.hxx"
  38 #include "PresenterGeometryHelper.hxx"
  39 #include "PresenterPaintManager.hxx"
  40 #include "PresenterTextView.hxx"
  41 #include <com/sun/star/awt/PosSize.hpp>
  42 #include <com/sun/star/awt/XWindow2.hpp>
  43 #include <com/sun/star/awt/XWindowPeer.hpp>
  44 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  45 #include <com/sun/star/drawing/CanvasFeature.hpp>
  46 #include <com/sun/star/rendering/CompositeOperation.hpp>
  47 #include <com/sun/star/rendering/TexturingMode.hpp>
  48 #include <osl/mutex.hxx>
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::uno;
  52 using namespace ::com::sun::star::drawing::framework;
  53 using ::rtl::OUString;
  54
  55 namespace sdext { namespace presenter {
  56
  57 //===== PresenterPaneBase =====================================================
  58
  59 PresenterPaneBase::PresenterPaneBase (
  60     const Reference<XComponentContext>& rxContext,
  61     const ::rtl::Reference<PresenterController>& rpPresenterController)
  62     : PresenterPaneBaseInterfaceBase(m_aMutex),
  63       mpPresenterController(rpPresenterController),
  64       mxParentWindow(),
  65       mxBorderWindow(),
  66       mxBorderCanvas(),
  67       mxContentWindow(),
  68       mxContentCanvas(),
  69       mxPaneId(),
  70       mxBorderPainter(),
  71       mxPresenterHelper(),
  72       msTitle(),
  73       mxComponentContext(rxContext),
  74       mpViewBackground(),
  75       mbHasCallout(false),
  76       maCalloutAnchor()
  77 {
  78     if (mpPresenterController.get() != NULL)
  79         mxPresenterHelper = mpPresenterController->GetPresenterHelper();
  80 }
  81
  82
  83
  84
  85 PresenterPaneBase::~PresenterPaneBase (void)
  86 {
  87 }
  88
  89
  90
  91
  92 void PresenterPaneBase::disposing (void)
  93 {
  94     if (mxBorderWindow.is())
  95     {
  96         mxBorderWindow->removeWindowListener(this);
  97         mxBorderWindow->removePaintListener(this);
  98     }
  99
 100     {
 101         Reference<XComponent> xComponent (mxContentCanvas, UNO_QUERY);
 102         mxContentCanvas = NULL;
 103         if (xComponent.is())
 104             xComponent->dispose();
 105     }
 106
 107     {
 108         Reference<XComponent> xComponent (mxContentWindow, UNO_QUERY);
 109         mxContentWindow = NULL;
 110         if (xComponent.is())
 111             xComponent->dispose();
 112     }
 113
 114     {
 115         Reference<XComponent> xComponent (mxBorderCanvas, UNO_QUERY);
 116         mxBorderCanvas = NULL;
 117         if (xComponent.is())
 118             xComponent->dispose();
 119     }
 120
 121     {
 122         Reference<XComponent> xComponent (mxBorderWindow, UNO_QUERY);
 123         mxBorderWindow = NULL;
 124         if (xComponent.is())
 125             xComponent->dispose();
 126     }
 127
 128     mxComponentContext = NULL;
 129 }
 130
 131
 132
 133
 134 void PresenterPaneBase::SetTitle (const OUString& rsTitle)
 135 {
 136     msTitle = rsTitle;
 137
 138     OSL_ASSERT(mpPresenterController.get()!=NULL);
 139     OSL_ASSERT(mpPresenterController->GetPaintManager().get()!=NULL);
 140
 141     mpPresenterController->GetPaintManager()->Invalidate(mxBorderWindow);
 142 }
 143
 144
 145
 146
 147 ::rtl::OUString PresenterPaneBase::GetTitle (void) const
 148 {
 149     return msTitle;
 150 }
 151
 152
 153
 154
 155 Reference<drawing::framework::XPaneBorderPainter>
 156     PresenterPaneBase::GetPaneBorderPainter (void) const
 157 {
 158     return mxBorderPainter;
 159 }
 160
 161
 162
 163
 164 void PresenterPaneBase::SetCalloutAnchor (const css::awt::Point& rCalloutAnchor)
 165 {
 166     mbHasCallout = true;
 167     // Anchor is given in the coorindate system of the parent window.
 168     // Transform it into the local coordinate system.
 169     maCalloutAnchor = rCalloutAnchor;
 170     const awt::Rectangle aBorderBox (mxBorderWindow->getPosSize());
 171     maCalloutAnchor.X -= aBorderBox.X;
 172     maCalloutAnchor.Y -= aBorderBox.Y;
 173
 174     // Move the bottom of the border window so that it goes through the
 175     // callout anchor (special case for bottom callout).
 176     sal_Int32 nHeight (rCalloutAnchor.Y - aBorderBox.Y);
 177     if (mxBorderPainter.is() && mxPaneId.is())
 178         nHeight += mxBorderPainter->getCalloutOffset(mxPaneId->getResourceURL()).Y;
 179
 180     if (nHeight != aBorderBox.Height)
 181     {
 182         mxBorderWindow->setPosSize(
 183             aBorderBox.X,
 184             aBorderBox.Y,
 185             aBorderBox.Width,
 186             nHeight,
 187             awt::PosSize::HEIGHT);
 188     }
 189
 190     mpPresenterController->GetPaintManager()->Invalidate(mxBorderWindow);
 191 }
 192
 193
 194
 195
 196 awt::Point PresenterPaneBase::GetCalloutAnchor (void) const
 197 {
 198     return maCalloutAnchor;
 199 }
 200
 201
 202
 203
 204 ::boost::shared_ptr<PresenterTextView> PresenterPaneBase::GetTextViewForTitle (void)
 205 {
 206     ::boost::shared_ptr<PresenterTextView> pTextView(
 207         new PresenterTextView(
 208             mxComponentContext,
 209             mxBorderCanvas));
 210     pTextView->SetText(msTitle);
 211     return pTextView;
 212 }
 213
 214
 215
 216
 217 //----- XInitialization -------------------------------------------------------
 218
 219 void SAL_CALL PresenterPaneBase::initialize (const Sequence<Any>& rArguments)
 220     throw (Exception, RuntimeException)
 221 {
 222     ThrowIfDisposed();
 223
 224     if ( ! mxComponentContext.is())
 225     {
 226         throw RuntimeException(
 227             OUString::createFromAscii("PresenterSpritePane: missing component context"),
 228             static_cast<XWeak*>(this));
 229     }
 230
 231     if (rArguments.getLength() == 5 || rArguments.getLength() == 6)
 232     {
 233         try
 234         {
 235             // Get the resource id from the first argument.
 236             if ( ! (rArguments[0] >>= mxPaneId))
 237             {
 238                 throw lang::IllegalArgumentException(
 239                     OUString::createFromAscii("PresenterPane: invalid pane id"),
 240                     static_cast<XWeak*>(this),
 241                     0);
 242             }
 243
 244             if ( ! (rArguments[1] >>= mxParentWindow))
 245             {
 246                 throw lang::IllegalArgumentException(
 247                     OUString::createFromAscii("PresenterPane: invalid parent window"),
 248                     static_cast<XWeak*>(this),
 249                     1);
 250             }
 251
 252             Reference<rendering::XSpriteCanvas> xParentCanvas;
 253             if ( ! (rArguments[2] >>= xParentCanvas))
 254             {
 255                 throw lang::IllegalArgumentException(
 256                     OUString::createFromAscii("PresenterPane: invalid parent canvas"),
 257                     static_cast<XWeak*>(this),
 258                     2);
 259             }
 260
 261             if ( ! (rArguments[3] >>= msTitle))
 262             {
 263                 throw lang::IllegalArgumentException(
 264                     OUString::createFromAscii("PresenterPane: invalid title"),
 265                     static_cast<XWeak*>(this),
 266                     3);
 267             }
 268
 269             if ( ! (rArguments[4] >>= mxBorderPainter))
 270             {
 271                 throw lang::IllegalArgumentException(
 272                     OUString::createFromAscii("PresenterPane: invalid border painter"),
 273                     static_cast<XWeak*>(this),
 274                     4);
 275             }
 276
 277             bool bIsWindowVisibleOnCreation (true);
 278             if (rArguments.getLength()>5 && ! (rArguments[5] >>= bIsWindowVisibleOnCreation))
 279             {
 280                 throw lang::IllegalArgumentException(
 281                     OUString::createFromAscii("PresenterPane: invalid window visibility flag"),
 282                     static_cast<XWeak*>(this),
 283                     5);
 284             }
 285
 286             CreateWindows(mxParentWindow, bIsWindowVisibleOnCreation);
 287
 288             if (mxBorderWindow.is())
 289             {
 290                 mxBorderWindow->addWindowListener(this);
 291                 mxBorderWindow->addPaintListener(this);
 292             }
 293
 294             CreateCanvases(mxParentWindow, xParentCanvas);
 295
 296             // Raise new windows.
 297             ToTop();
 298         }
 299         catch (Exception&)
 300         {
 301             mxContentWindow = NULL;
 302             mxComponentContext = NULL;
 303             throw;
 304         }
 305     }
 306     else
 307     {
 308         throw RuntimeException(
 309             OUString::createFromAscii("PresenterSpritePane: invalid number of arguments"),
 310                 static_cast<XWeak*>(this));
 311     }
 312 }
 313
 314
 315
 316
 317 //----- XResourceId -----------------------------------------------------------
 318
 319 Reference<XResourceId> SAL_CALL PresenterPaneBase::getResourceId (void)
 320     throw (RuntimeException)
 321 {
 322     ThrowIfDisposed();
 323     return mxPaneId;
 324 }
 325
 326
 327
 328
 329 sal_Bool SAL_CALL PresenterPaneBase::isAnchorOnly (void)
 330     throw (RuntimeException)
 331 {
 332     return true;
 333 }
 334
 335
 336
 337
 338 //----- XWindowListener -------------------------------------------------------
 339
 340 void SAL_CALL PresenterPaneBase::windowResized (const awt::WindowEvent& rEvent)
 341     throw (RuntimeException)
 342 {
 343     (void)rEvent;
 344     ThrowIfDisposed();
 345 }
 346
 347
 348
 349
 350
 351 void SAL_CALL PresenterPaneBase::windowMoved (const awt::WindowEvent& rEvent)
 352     throw (RuntimeException)
 353 {
 354     (void)rEvent;
 355     ThrowIfDisposed();
 356 }
 357
 358
 359
 360
 361 void SAL_CALL PresenterPaneBase::windowShown (const lang::EventObject& rEvent)
 362     throw (RuntimeException)
 363 {
 364     (void)rEvent;
 365     ThrowIfDisposed();
 366 }
 367
 368
 369
 370
 371 void SAL_CALL PresenterPaneBase::windowHidden (const lang::EventObject& rEvent)
 372     throw (RuntimeException)
 373 {
 374     (void)rEvent;
 375     ThrowIfDisposed();
 376 }
 377
 378
 379
 380
 381 //----- lang::XEventListener --------------------------------------------------
 382
 383 void SAL_CALL PresenterPaneBase::disposing (const lang::EventObject& rEvent)
 384     throw (RuntimeException)
 385 {
 386     if (rEvent.Source == mxBorderWindow)
 387     {
 388         mxBorderWindow = NULL;
 389     }
 390 }
 391
 392
 393
 394
 395 //-----------------------------------------------------------------------------
 396
 397
 398 void PresenterPaneBase::CreateWindows (
 399     const Reference<awt::XWindow>& rxParentWindow,
 400     const bool bIsWindowVisibleOnCreation)
 401 {
 402     if (mxPresenterHelper.is() && rxParentWindow.is())
 403     {
 404
 405         mxBorderWindow = mxPresenterHelper->createWindow(
 406             rxParentWindow,
 407             sal_False,
 408             bIsWindowVisibleOnCreation,
 409             sal_False,
 410             sal_False);
 411         mxContentWindow = mxPresenterHelper->createWindow(
 412             mxBorderWindow,
 413             sal_False,
 414             bIsWindowVisibleOnCreation,
 415             sal_False,
 416             sal_False);
 417     }
 418 }
 419
 420
 421
 422
 423 Reference<awt::XWindow> PresenterPaneBase::GetBorderWindow (void) const
 424 {
 425     return mxBorderWindow;
 426 }
 427
 428
 429
 430
 431 void PresenterPaneBase::ToTop (void)
 432 {
 433     if (mxPresenterHelper.is())
 434         mxPresenterHelper->toTop(mxContentWindow);
 435 }
 436
 437
 438
 439
 440 void PresenterPaneBase::SetBackground (const SharedBitmapDescriptor& rpBackground)
 441 {
 442     mpViewBackground = rpBackground;
 443 }
 444
 445
 446
 447
 448 void PresenterPaneBase::PaintBorderBackground (
 449     const awt::Rectangle& rBorderBox,
 450     const awt::Rectangle& rUpdateBox)
 451 {
 452     (void)rBorderBox;
 453     (void)rUpdateBox;
 454     /*
 455     // The outer box of the border is given.  We need the center and inner
 456     // box as well.
 457     awt::Rectangle aCenterBox (
 458         mxBorderPainter->removeBorder(
 459             mxPaneId->getResourceURL(),
 460             rBorderBox,
 461             drawing::framework::BorderType_OUTER_BORDER));
 462     awt::Rectangle aInnerBox (
 463         mxBorderPainter->removeBorder(
 464             mxPaneId->getResourceURL(),
 465             rBorderBox,
 466             drawing::framework::BorderType_TOTAL_BORDER));
 467     mpPresenterController->GetCanvasHelper()->Paint(
 468         mpViewBackground,
 469         mxBorderCanvas,
 470         rUpdateBox,
 471         aCenterBox,
 472         aInnerBox);
 473     */
 474 }
 475
 476
 477
 478
 479 void PresenterPaneBase::PaintBorder (const awt::Rectangle& rUpdateBox)
 480 {
 481     OSL_ASSERT(mxPaneId.is());
 482
 483     if (mxBorderPainter.is() && mxBorderWindow.is() && mxBorderCanvas.is())
 484     {
 485         awt::Rectangle aBorderBox (mxBorderWindow->getPosSize());
 486         awt::Rectangle aLocalBorderBox (0,0, aBorderBox.Width, aBorderBox.Height);
 487
 488         PaintBorderBackground(aLocalBorderBox, rUpdateBox);
 489
 490         if (mbHasCallout)
 491             mxBorderPainter->paintBorderWithCallout(
 492                 mxPaneId->getResourceURL(),
 493                 mxBorderCanvas,
 494                 aLocalBorderBox,
 495                 rUpdateBox,
 496                 msTitle,
 497                 maCalloutAnchor);
 498         else
 499             mxBorderPainter->paintBorder(
 500                 mxPaneId->getResourceURL(),
 501                 mxBorderCanvas,
 502                 aLocalBorderBox,
 503                 rUpdateBox,
 504                 msTitle);
 505     }
 506 }
 507
 508
 509
 510
 511 void PresenterPaneBase::LayoutContextWindow (void)
 512 {
 513     OSL_ASSERT(mxPaneId.is());
 514     OSL_ASSERT(mxBorderWindow.is());
 515     OSL_ASSERT(mxContentWindow.is());
 516     if (mxBorderPainter.is() && mxPaneId.is() && mxBorderWindow.is() && mxContentWindow.is())
 517     {
 518         const awt::Rectangle aBorderBox (mxBorderWindow->getPosSize());
 519         const awt::Rectangle aInnerBox (mxBorderPainter->removeBorder(
 520             mxPaneId->getResourceURL(),
 521             aBorderBox,
 522             drawing::framework::BorderType_TOTAL_BORDER));
 523         mxContentWindow->setPosSize(
 524             aInnerBox.X - aBorderBox.X,
 525             aInnerBox.Y - aBorderBox.Y,
 526             aInnerBox.Width,
 527             aInnerBox.Height,
 528             awt::PosSize::POSSIZE);
 529     }
 530 }
 531
 532
 533
 534
 535 bool PresenterPaneBase::IsVisible (void) const
 536 {
 537     Reference<awt::XWindow2> xWindow2 (mxBorderPainter, UNO_QUERY);
 538     if (xWindow2.is())
 539         return xWindow2->isVisible();
 540
 541     return false;
 542 }
 543
 544
 545
 546
 547 void PresenterPaneBase::ThrowIfDisposed (void)
 548     throw (::com::sun::star::lang::DisposedException)
 549 {
 550     if (rBHelper.bDisposed || rBHelper.bInDispose)
 551     {
 552         throw lang::DisposedException (
 553             ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 554                 "PresenterPane object has already been disposed")),
 555             static_cast<uno::XWeak*>(this));
 556     }
 557 }
 558
 559
 560
 561
 562 } } // end of namespace ::sd::presenter