cppcanvas/source/wrapper/vclfactory.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: vclfactory.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_cppcanvas.hxx"
  33 #include <rtl/instance.hxx>
  34 #include <osl/getglobalmutex.hxx>
  35 #include <osl/diagnose.h>
  36 #include <com/sun/star/rendering/InterpolationMode.hpp>
  37 #include <vcl/window.hxx>
  38 #include <vcl/graph.hxx>
  39 #include <vcl/canvastools.hxx>
  40 #include <basegfx/polygon/b2dpolypolygon.hxx>
  41
  42 #include <cppcanvas/vclfactory.hxx>
  43
  44 #include <implbitmapcanvas.hxx>
  45 #include <implspritecanvas.hxx>
  46 #include <implpolypolygon.hxx>
  47 #include <implbitmap.hxx>
  48 #include <implrenderer.hxx>
  49 #include <impltext.hxx>
  50 #include <implsprite.hxx>
  51
  52
  53 using namespace ::com::sun::star;
  54
  55 namespace cppcanvas
  56 {
  57     /* Singleton handling */
  58     struct InitInstance
  59     {
  60         VCLFactory* operator()()
  61         {
  62             return new VCLFactory();
  63         }
  64     };
  65
  66     VCLFactory& VCLFactory::getInstance()
  67     {
  68         return *rtl_Instance< VCLFactory, InitInstance, ::osl::MutexGuard,
  69             ::osl::GetGlobalMutex >::create(
  70                 InitInstance(), ::osl::GetGlobalMutex());
  71     }
  72
  73     VCLFactory::VCLFactory()
  74     {
  75     }
  76
  77     VCLFactory::~VCLFactory()
  78     {
  79     }
  80
  81     BitmapCanvasSharedPtr VCLFactory::createCanvas( const ::Window& rVCLWindow )
  82     {
  83         return BitmapCanvasSharedPtr(
  84             new internal::ImplBitmapCanvas(
  85                 uno::Reference< rendering::XBitmapCanvas >(
  86                     rVCLWindow.GetCanvas(),
  87                     uno::UNO_QUERY) ) );
  88     }
  89
  90     BitmapCanvasSharedPtr VCLFactory::createCanvas( const uno::Reference< rendering::XBitmapCanvas >& xCanvas )
  91     {
  92         return BitmapCanvasSharedPtr(
  93             new internal::ImplBitmapCanvas( xCanvas ) );
  94     }
  95
  96     SpriteCanvasSharedPtr VCLFactory::createSpriteCanvas( const ::Window& rVCLWindow ) const
  97     {
  98         return SpriteCanvasSharedPtr(
  99             new internal::ImplSpriteCanvas(
 100                 uno::Reference< rendering::XSpriteCanvas >(
 101                     rVCLWindow.GetSpriteCanvas(),
 102                     uno::UNO_QUERY) ) );
 103     }
 104
 105     SpriteCanvasSharedPtr VCLFactory::createSpriteCanvas( const uno::Reference< rendering::XSpriteCanvas >& xCanvas ) const
 106     {
 107         return SpriteCanvasSharedPtr(
 108             new internal::ImplSpriteCanvas( xCanvas ) );
 109     }
 110
 111     SpriteCanvasSharedPtr VCLFactory::createFullscreenSpriteCanvas( const ::Window& rVCLWindow,
 112                                                                     const Size&         rFullscreenSize ) const
 113     {
 114         return SpriteCanvasSharedPtr(
 115             new internal::ImplSpriteCanvas(
 116                 uno::Reference< rendering::XSpriteCanvas >(
 117                     rVCLWindow.GetFullscreenSpriteCanvas( rFullscreenSize ),
 118                     uno::UNO_QUERY) ) );
 119     }
 120
 121     PolyPolygonSharedPtr VCLFactory::createPolyPolygon( const CanvasSharedPtr&  rCanvas,
 122                                                         const ::Polygon&                rPoly ) const
 123     {
 124         OSL_ENSURE( rCanvas.get() != NULL &&
 125                     rCanvas->getUNOCanvas().is(),
 126                     "VCLFactory::createPolyPolygon(): Invalid canvas" );
 127
 128         if( rCanvas.get() == NULL )
 129             return PolyPolygonSharedPtr();
 130
 131         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 132         if( !xCanvas.is() )
 133             return PolyPolygonSharedPtr();
 134
 135         return PolyPolygonSharedPtr(
 136             new internal::ImplPolyPolygon( rCanvas,
 137                                            ::vcl::unotools::xPolyPolygonFromPolygon(
 138                                                xCanvas->getDevice(),
 139                                                rPoly) ) );
 140     }
 141
 142     PolyPolygonSharedPtr VCLFactory::createPolyPolygon( const CanvasSharedPtr&  rCanvas,
 143                                                         const ::PolyPolygon&    rPolyPoly ) const
 144     {
 145         OSL_ENSURE( rCanvas.get() != NULL &&
 146                     rCanvas->getUNOCanvas().is(),
 147                     "VCLFactory::createPolyPolygon(): Invalid canvas" );
 148
 149         if( rCanvas.get() == NULL )
 150             return PolyPolygonSharedPtr();
 151
 152         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 153         if( !xCanvas.is() )
 154             return PolyPolygonSharedPtr();
 155
 156         return PolyPolygonSharedPtr(
 157             new internal::ImplPolyPolygon( rCanvas,
 158                                            ::vcl::unotools::xPolyPolygonFromPolyPolygon(
 159                                                xCanvas->getDevice(),
 160                                                rPolyPoly) ) );
 161     }
 162
 163     BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr&    rCanvas,
 164                                               const ::Size&                     rSize ) const
 165     {
 166         OSL_ENSURE( rCanvas.get() != NULL &&
 167                     rCanvas->getUNOCanvas().is(),
 168                     "VCLFactory::createBitmap(): Invalid canvas" );
 169
 170         if( rCanvas.get() == NULL )
 171             return BitmapSharedPtr();
 172
 173         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 174         if( !xCanvas.is() )
 175             return BitmapSharedPtr();
 176
 177         return BitmapSharedPtr(
 178             new internal::ImplBitmap( rCanvas,
 179                                       xCanvas->getDevice()->createCompatibleBitmap(
 180                                           ::vcl::unotools::integerSize2DFromSize(rSize) ) ) );
 181     }
 182
 183     BitmapSharedPtr VCLFactory::createAlphaBitmap( const CanvasSharedPtr&       rCanvas,
 184                                                    const ::Size&                        rSize ) const
 185     {
 186         OSL_ENSURE( rCanvas.get() != NULL &&
 187                     rCanvas->getUNOCanvas().is(),
 188                     "VCLFactory::createBitmap(): Invalid canvas" );
 189
 190         if( rCanvas.get() == NULL )
 191             return BitmapSharedPtr();
 192
 193         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 194         if( !xCanvas.is() )
 195             return BitmapSharedPtr();
 196
 197         return BitmapSharedPtr(
 198             new internal::ImplBitmap( rCanvas,
 199                                       xCanvas->getDevice()->createCompatibleAlphaBitmap(
 200                                           ::vcl::unotools::integerSize2DFromSize(rSize) ) ) );
 201     }
 202
 203     BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr&    rCanvas,
 204                                               const ::Bitmap&                   rBitmap ) const
 205     {
 206         OSL_ENSURE( rCanvas.get() != NULL &&
 207                     rCanvas->getUNOCanvas().is(),
 208                     "VCLFactory::createBitmap(): Invalid canvas" );
 209
 210         if( rCanvas.get() == NULL )
 211             return BitmapSharedPtr();
 212
 213         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 214         if( !xCanvas.is() )
 215             return BitmapSharedPtr();
 216
 217         return BitmapSharedPtr( new internal::ImplBitmap( rCanvas,
 218                                                           ::vcl::unotools::xBitmapFromBitmap(
 219                                                               xCanvas->getDevice(),
 220                                                               rBitmap) ) );
 221     }
 222
 223     BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr&    rCanvas,
 224                                               const ::BitmapEx&                 rBmpEx ) const
 225     {
 226         OSL_ENSURE( rCanvas.get() != NULL &&
 227                     rCanvas->getUNOCanvas().is(),
 228                     "VCLFactory::createBitmap(): Invalid canvas" );
 229
 230         if( rCanvas.get() == NULL )
 231             return BitmapSharedPtr();
 232
 233         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 234         if( !xCanvas.is() )
 235             return BitmapSharedPtr();
 236
 237         return BitmapSharedPtr( new internal::ImplBitmap( rCanvas,
 238                                                           ::vcl::unotools::xBitmapFromBitmapEx(
 239                                                               xCanvas->getDevice(),
 240                                                               rBmpEx) ) );
 241     }
 242
 243     RendererSharedPtr VCLFactory::createRenderer( const CanvasSharedPtr&                rCanvas,
 244                                                   const ::Graphic&                              rGraphic,
 245                                                   const Renderer::Parameters&   rParms ) const
 246     {
 247         OSL_ENSURE( rCanvas.get() != NULL &&
 248                     rCanvas->getUNOCanvas().is(),
 249                     "VCLFactory::createRenderer(): Invalid canvas" );
 250
 251         if( rCanvas.get() == NULL )
 252             return RendererSharedPtr();
 253
 254         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 255         if( !xCanvas.is() )
 256             return RendererSharedPtr();
 257
 258         if( rGraphic.GetType() == GRAPHIC_GDIMETAFILE )
 259             return RendererSharedPtr( new internal::ImplRenderer( rCanvas,
 260                                                                   rGraphic.GetGDIMetaFile(),
 261                                                                   rParms ) );
 262         else
 263             return RendererSharedPtr( new internal::ImplRenderer( rCanvas,
 264                                                                   rGraphic.GetBitmapEx(),
 265                                                                   rParms ) );
 266     }
 267
 268     RendererSharedPtr VCLFactory::createRenderer( const CanvasSharedPtr&                rCanvas,
 269                                                   const ::GDIMetaFile&                  rMtf,
 270                                                   const Renderer::Parameters&   rParms ) const
 271     {
 272         return RendererSharedPtr( new internal::ImplRenderer( rCanvas,
 273                                                               rMtf,
 274                                                               rParms ) );
 275     }
 276
 277     SpriteSharedPtr VCLFactory::createAnimatedSprite( const SpriteCanvasSharedPtr& rCanvas, const ::Animation& rAnim ) const
 278     {
 279         OSL_ENSURE( rCanvas.get() != NULL &&
 280                     rCanvas->getUNOCanvas().is(),
 281                     "VCLFactory::createAnimatedSprite(): Invalid canvas" );
 282
 283         if( rCanvas.get() == NULL )
 284             return SpriteSharedPtr();
 285
 286         uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() );
 287         if( !xCanvas.is() )
 288             return SpriteSharedPtr();
 289
 290         uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas( rCanvas->getUNOSpriteCanvas() );
 291         if( !xSpriteCanvas.is() )
 292             return SpriteSharedPtr();
 293
 294         if( rAnim.IsEmpty() )
 295             return SpriteSharedPtr();
 296
 297         internal::ImplSpriteCanvas* pSpriteCanvas = dynamic_cast< internal::ImplSpriteCanvas* >( rCanvas.get() );
 298         if( !pSpriteCanvas )
 299             return SpriteSharedPtr();
 300
 301         const USHORT nBitmaps( rAnim.Count() );
 302         uno::Sequence< uno::Reference< rendering::XBitmap > > aBitmapSequence( nBitmaps );
 303         uno::Reference< rendering::XBitmap >* pBitmaps = aBitmapSequence.getArray();
 304
 305         unsigned int i;
 306         BitmapEx aBmpEx;
 307         BitmapEx aRestoreBuffer;
 308         aBmpEx.SetSizePixel( rAnim.GetDisplaySizePixel() );
 309         aRestoreBuffer.SetSizePixel( rAnim.GetDisplaySizePixel() );
 310         aBmpEx.Erase( ::Color( 255, 0,0,0 ) ); // clear alpha channel
 311         aRestoreBuffer = aBmpEx;
 312         const Point aEmptyPoint;
 313
 314         for( i=0; i<nBitmaps; ++i )
 315         {
 316             const AnimationBitmap& rAnimBmp( rAnim.Get((USHORT)i) );
 317
 318             // Handle dispose according to GIF spec: a
 319             // DISPOSE_PREVIOUS does _not_ mean to revert to the
 320             // previous frame, but to revert to the last frame with
 321             // DISPOSE_NOT
 322
 323             // dispose previous
 324             if( rAnimBmp.eDisposal == DISPOSE_BACK )
 325             {
 326                 // simply clear bitmap to transparent
 327                 aBmpEx.Erase( ::Color( 255, 0,0,0 ) );
 328             }
 329             else if( rAnimBmp.eDisposal == DISPOSE_PREVIOUS )
 330             {
 331                 // copy in last known full frame
 332                 aBmpEx = aRestoreBuffer;
 333             }
 334             // I have exactly _no_ idea what DISPOSE_FULL is supposed
 335             // to do. It's apparently not set anywhere in our code
 336             OSL_ENSURE( rAnimBmp.eDisposal!=DISPOSE_FULL,
 337                         "VCLFactory::createAnimatedSprite(): Somebody set the deprecated DISPOSE_FULL at the Animation" );
 338
 339             // update display
 340             aBmpEx.CopyPixel( Rectangle( rAnimBmp.aPosPix,
 341                                          rAnimBmp.aSizePix ),
 342                               Rectangle( aEmptyPoint,
 343                                          rAnimBmp.aSizePix ),
 344                               &rAnimBmp.aBmpEx );
 345
 346             // store last DISPOSE_NOT frame, for later
 347             // DISPOSE_PREVIOUS updates
 348             if( rAnimBmp.eDisposal == DISPOSE_NOT )
 349                 aRestoreBuffer = aBmpEx;
 350
 351             pBitmaps[i] = ::vcl::unotools::xBitmapFromBitmapEx(
 352                 xCanvas->getDevice(),
 353                 aBmpEx);
 354         }
 355
 356         return pSpriteCanvas->createSpriteFromBitmaps( aBitmapSequence,
 357                                                        rendering::InterpolationMode::NEAREST_NEIGHBOR );
 358     }
 359
 360     TextSharedPtr VCLFactory::createText( const CanvasSharedPtr& rCanvas, const ::rtl::OUString& rText ) const
 361     {
 362         return TextSharedPtr( new internal::ImplText( rCanvas,
 363                                                       rText ) );
 364     }
 365
 366 }