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