slideshow/source/engine/slide/userpaintoverlay.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
  21 #include <com/sun/star/awt/MouseButton.hpp>
  22 #include <com/sun/star/awt/MouseEvent.hpp>
  23
  24 #include <basegfx/point/b2dpoint.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <basegfx/matrix/b2dhommatrix.hxx>
  27 #include <cppcanvas/basegfxfactory.hxx>
  28 #include <comphelper/diagnose_ex.hxx>
  29
  30 #include <slideshowcontext.hxx>
  31 #include "userpaintoverlay.hxx"
  32 #include <mouseeventhandler.hxx>
  33 #include <eventmultiplexer.hxx>
  34 #include <screenupdater.hxx>
  35 #include <vieweventhandler.hxx>
  36
  37 #include <slide.hxx>
  38 #include <cursormanager.hxx>
  39
  40 using namespace ::com::sun::star;
  41
  42 namespace slideshow::internal
  43 {
  44         class PaintOverlayHandler : public MouseEventHandler,
  45                                     public ViewEventHandler,
  46                     public UserPaintEventHandler
  47         {
  48         public:
  49             PaintOverlayHandler( const RGBColor&          rStrokeColor,
  50                                  double                   nStrokeWidth,
  51                                  ScreenUpdater&           rScreenUpdater,
  52                                  const UnoViewContainer&  rViews,
  53                                  Slide&                   rSlide,
  54                                  PolyPolygonVector&&      rPolygons,
  55                                  bool                     bActive ) :
  56                 mrScreenUpdater( rScreenUpdater ),
  57                 maViews(),
  58                 maPolygons( std::move(rPolygons) ),
  59                 maStrokeColor( rStrokeColor ),
  60                 mnStrokeWidth( nStrokeWidth ),
  61                 maLastPoint(),
  62                 maLastMouseDownPos(),
  63                 mbIsLastPointValid( false ),
  64                 mbIsLastMouseDownPosValid( false ),
  65                 //handle the "remove all ink from slide" mode of erasing
  66                 mbIsEraseAllModeActivated( false ),
  67                 //handle the "remove stroke by stroke" mode of erasing
  68                 mbIsEraseModeActivated( false ),
  69                 mrSlide(rSlide),
  70                 mnSize(100),
  71                 mbActive( bActive )
  72             {
  73                 for( const auto& rView : rViews )
  74                     viewAdded( rView );
  75
  76                 drawPolygons();
  77             }
  78
  79             void dispose()
  80             {
  81                 maViews.clear();
  82             }
  83
  84             // ViewEventHandler methods
  85             virtual void viewAdded( const UnoViewSharedPtr& rView ) override
  86             {
  87                 maViews.push_back( rView );
  88             }
  89
  90             virtual void viewRemoved( const UnoViewSharedPtr& rView ) override
  91             {
  92                 maViews.erase( ::std::remove( maViews.begin(),
  93                                               maViews.end(),
  94                                               rView ) );
  95             }
  96
  97             virtual void viewChanged( const UnoViewSharedPtr& /*rView*/ ) override
  98             {
  99                 // TODO(F2): for persistent drawings, need to store
 100                 // polygon and repaint here.
 101             }
 102
 103             virtual void viewsChanged() override
 104             {
 105                 // TODO(F2): for persistent drawings, need to store
 106                 // polygon and repaint here.
 107             }
 108
 109             bool colorChanged( RGBColor const& rUserColor ) override
 110             {
 111                 mbIsLastPointValid = false;
 112                 mbActive = true;
 113                 maStrokeColor = rUserColor;
 114                 mbIsEraseModeActivated = false;
 115                 return true;
 116             }
 117
 118             bool widthChanged( double nUserStrokeWidth ) override
 119             {
 120                 mnStrokeWidth = nUserStrokeWidth;
 121                 mbIsEraseModeActivated = false;
 122                 return true;
 123             }
 124
 125             void repaintWithoutPolygons()
 126             {
 127                     // must get access to the instance to erase all polygon
 128                     for( const auto& rxView : maViews )
 129                     {
 130                         // fully clear view content to background color
 131                         //rxView->getCanvas()->clear();
 132
 133                         //get via SlideImpl instance the bitmap of the slide unmodified to redraw it
 134                         SlideBitmapSharedPtr         pBitmap( mrSlide.getCurrentSlideBitmap( rxView ) );
 135                         ::cppcanvas::CanvasSharedPtr pCanvas( rxView->getCanvas() );
 136
 137                         const ::basegfx::B2DHomMatrix   aViewTransform( rxView->getTransformation() );
 138                         const ::basegfx::B2DPoint       aOutPosPixel( aViewTransform * ::basegfx::B2DPoint() );
 139
 140                         // setup a canvas with device coordinate space, the slide
 141                         // bitmap already has the correct dimension.
 142                         ::cppcanvas::CanvasSharedPtr pDevicePixelCanvas( pCanvas->clone() );
 143
 144                         pDevicePixelCanvas->setTransformation( ::basegfx::B2DHomMatrix() );
 145
 146                         // render at given output position
 147                         pBitmap->move( aOutPosPixel );
 148
 149                         // clear clip (might have been changed, e.g. from comb
 150                         // transition)
 151                         pBitmap->clip( ::basegfx::B2DPolyPolygon() );
 152                         pBitmap->draw( pDevicePixelCanvas );
 153
 154                         mrScreenUpdater.notifyUpdate(rxView,true);
 155                     }
 156             }
 157
 158             bool eraseAllInkChanged( bool bEraseAllInk ) override
 159             {
 160                 mbIsEraseAllModeActivated = bEraseAllInk;
 161                 // if the erase all mode is activated it will remove all ink from slide,
 162                 // therefore destroy all the polygons stored
 163                 if(mbIsEraseAllModeActivated)
 164                 {
 165                     // The Erase Mode should be deactivated
 166                     mbIsEraseModeActivated = false;
 167                     repaintWithoutPolygons();
 168                     maPolygons.clear();
 169                 }
 170                 mbIsEraseAllModeActivated=false;
 171                 return true;
 172             }
 173
 174             bool eraseInkWidthChanged( sal_Int32 rEraseInkSize ) override
 175             {
 176                 // Change the size
 177                 mnSize=rEraseInkSize;
 178                 // Changed to mode Erase
 179                 mbIsEraseModeActivated = true;
 180                 return true;
 181             }
 182
 183             bool switchPenMode() override
 184             {
 185                 mbIsLastPointValid = false;
 186                 mbActive = true;
 187                 mbIsEraseModeActivated = false;
 188                 return true;
 189             }
 190
 191             bool switchEraserMode() override
 192             {
 193                 mbIsLastPointValid = false;
 194                 mbActive = true;
 195                 mbIsEraseModeActivated = true;
 196                 return true;
 197             }
 198
 199             bool disable() override
 200             {
 201                 mbIsLastPointValid = false;
 202                 mbIsLastMouseDownPosValid = false;
 203                 mbActive = false;
 204                 return true;
 205             }
 206
 207             //Draw all registered polygons.
 208             void drawPolygons()
 209             {
 210                 for( const auto& rxPolygon : maPolygons )
 211                 {
 212                     rxPolygon->draw();
 213                 }
 214                 // screen update necessary to show painting
 215                 mrScreenUpdater.notifyUpdate();
 216             }
 217
 218             //Retrieve all registered polygons.
 219             const PolyPolygonVector& getPolygons() const
 220             {
 221                 return maPolygons;
 222             }
 223
 224             // MouseEventHandler methods
 225             virtual bool handleMousePressed( const awt::MouseEvent& e ) override
 226             {
 227                 if( !mbActive )
 228                     return false;
 229
 230                 if (e.Buttons == awt::MouseButton::RIGHT)
 231                 {
 232                     mbIsLastPointValid = false;
 233                     return false;
 234                 }
 235
 236                 if (e.Buttons != awt::MouseButton::LEFT)
 237                     return false;
 238
 239                 maLastMouseDownPos.setX( e.X );
 240                 maLastMouseDownPos.setY( e.Y );
 241                 mbIsLastMouseDownPosValid = true;
 242
 243                 // eat mouse click (though we don't process it
 244                 // _directly_, it enables the drag mode
 245                 return true;
 246             }
 247
 248             virtual bool handleMouseReleased( const awt::MouseEvent& e ) override
 249             {
 250                 if( !mbActive )
 251                     return false;
 252
 253                 if (e.Buttons == awt::MouseButton::RIGHT)
 254                 {
 255                     mbIsLastPointValid = false;
 256                     return false;
 257                 }
 258
 259                 if (e.Buttons != awt::MouseButton::LEFT)
 260                     return false;
 261
 262                 // check, whether up- and down press are on exactly
 263                 // the same pixel. If that's the case, ignore the
 264                 // click, and pass on the event to low-prio
 265                 // handlers. This effectively permits effect
 266                 // advancements via clicks also when user paint is
 267                 // enabled.
 268                 if( mbIsLastMouseDownPosValid &&
 269                     ::basegfx::B2DPoint( e.X,
 270                                          e.Y ) == maLastMouseDownPos )
 271                 {
 272                     mbIsLastMouseDownPosValid = false;
 273                     return false;
 274                 }
 275
 276                 // invalidate, next downpress will have to start a new
 277                 // polygon.
 278                 mbIsLastPointValid = false;
 279
 280                 // eat mouse click (though we don't process it
 281                 // _directly_, it enables the drag mode
 282                 return true;
 283             }
 284
 285             virtual bool handleMouseDragged( const awt::MouseEvent& e ) override
 286             {
 287                 if( !mbActive )
 288                     return false;
 289
 290                 if (e.Buttons == awt::MouseButton::RIGHT)
 291                 {
 292                     mbIsLastPointValid = false;
 293                     return false;
 294                 }
 295
 296                 if(mbIsEraseModeActivated)
 297                 {
 298                     //define the last point as an object
 299                     //we suppose that there's no way this point could be valid
 300                     ::basegfx::B2DPolygon aPoly;
 301
 302                     maLastPoint.setX( e.X-mnSize );
 303                     maLastPoint.setY( e.Y-mnSize );
 304
 305                     aPoly.append( maLastPoint );
 306
 307                     maLastPoint.setX( e.X-mnSize );
 308                     maLastPoint.setY( e.Y+mnSize );
 309
 310                     aPoly.append( maLastPoint );
 311                     maLastPoint.setX( e.X+mnSize );
 312                     maLastPoint.setY( e.Y+mnSize );
 313
 314                     aPoly.append( maLastPoint );
 315                     maLastPoint.setX( e.X+mnSize );
 316                     maLastPoint.setY( e.Y-mnSize );
 317
 318                     aPoly.append( maLastPoint );
 319                     maLastPoint.setX( e.X-mnSize );
 320                     maLastPoint.setY( e.Y-mnSize );
 321
 322                     aPoly.append( maLastPoint );
 323
 324                     //now we have defined a Polygon that is closed
 325
 326                     //The point is to redraw the LastPoint the way it was originally on the bitmap,
 327                     //of the slide
 328                     for (const auto& rxView : maViews)
 329                     {
 330
 331                         //get via SlideImpl instance the bitmap of the slide unmodified to redraw it
 332                         SlideBitmapSharedPtr         pBitmap( mrSlide.getCurrentSlideBitmap( rxView ) );
 333                         ::cppcanvas::CanvasSharedPtr pCanvas( rxView->getCanvas() );
 334
 335                         ::basegfx::B2DHomMatrix     aViewTransform( rxView->getTransformation() );
 336                         const ::basegfx::B2DPoint       aOutPosPixel( aViewTransform * ::basegfx::B2DPoint() );
 337
 338                         // setup a canvas with device coordinate space, the slide
 339                         // bitmap already has the correct dimension.
 340                         ::cppcanvas::CanvasSharedPtr pDevicePixelCanvas( pCanvas->clone() );
 341
 342                         pDevicePixelCanvas->setTransformation( ::basegfx::B2DHomMatrix() );
 343
 344                         // render at given output position
 345                         pBitmap->move( aOutPosPixel );
 346
 347                         ::basegfx::B2DPolyPolygon aPolyPoly(aPoly);
 348                         aViewTransform.translate(-aOutPosPixel.getX(), -aOutPosPixel.getY());
 349                         aPolyPoly.transform(aViewTransform);
 350                         // set clip so that we just redraw a part of the canvas
 351                         pBitmap->clip(aPolyPoly);
 352                         pBitmap->draw( pDevicePixelCanvas );
 353
 354                         mrScreenUpdater.notifyUpdate(rxView,true);
 355                     }
 356
 357                 }
 358                 else
 359                 {
 360                     if( !mbIsLastPointValid )
 361                     {
 362                         mbIsLastPointValid = true;
 363                         maLastPoint.setX( e.X );
 364                         maLastPoint.setY( e.Y );
 365                     }
 366                     else
 367                     {
 368                         ::basegfx::B2DPolygon aPoly;
 369                         aPoly.append( maLastPoint );
 370
 371                         maLastPoint.setX( e.X );
 372                         maLastPoint.setY( e.Y );
 373
 374                         aPoly.append( maLastPoint );
 375
 376                         // paint to all views
 377                         for (const auto& rxView : maViews)
 378                         {
 379                             ::cppcanvas::PolyPolygonSharedPtr pPolyPoly(
 380                                 ::cppcanvas::BaseGfxFactory::createPolyPolygon( rxView->getCanvas(),
 381                                                                                 aPoly ) );
 382
 383                             if( pPolyPoly )
 384                             {
 385                                 pPolyPoly->setStrokeWidth(mnStrokeWidth);
 386                                 pPolyPoly->setRGBALineColor( maStrokeColor.getIntegerColor() );
 387                                 pPolyPoly->draw();
 388                                 maPolygons.push_back(pPolyPoly);
 389                             }
 390                         }
 391
 392                         // screen update necessary to show painting
 393                         mrScreenUpdater.notifyUpdate();
 394                     }
 395                 }
 396                 // mouse events captured
 397                 return true;
 398             }
 399
 400             virtual bool handleMouseMoved( const awt::MouseEvent& /*e*/ ) override
 401             {
 402                 // not used here
 403                 return false; // did not handle the event
 404             }
 405
 406         private:
 407             ScreenUpdater&          mrScreenUpdater;
 408             UnoViewVector           maViews;
 409             PolyPolygonVector       maPolygons;
 410             RGBColor                maStrokeColor;
 411             double                  mnStrokeWidth;
 412             basegfx::B2DPoint       maLastPoint;
 413             basegfx::B2DPoint       maLastMouseDownPos;
 414             bool                    mbIsLastPointValid;
 415             bool                    mbIsLastMouseDownPosValid;
 416             // added bool for erasing purpose :
 417             bool                    mbIsEraseAllModeActivated;
 418             bool                    mbIsEraseModeActivated;
 419             Slide&                  mrSlide;
 420             sal_Int32               mnSize;
 421             bool                    mbActive;
 422         };
 423
 424         UserPaintOverlaySharedPtr UserPaintOverlay::create( const RGBColor&          rStrokeColor,
 425                                                             double                   nStrokeWidth,
 426                                                             const SlideShowContext&  rContext,
 427                                                             PolyPolygonVector&&      rPolygons,
 428                                                             bool                     bActive )
 429         {
 430             UserPaintOverlaySharedPtr pRet( new UserPaintOverlay( rStrokeColor,
 431                                                                   nStrokeWidth,
 432                                                                   rContext,
 433                                                                   std::move(rPolygons),
 434                                                                   bActive));
 435
 436             return pRet;
 437         }
 438
 439         UserPaintOverlay::UserPaintOverlay( const RGBColor&          rStrokeColor,
 440                                             double                   nStrokeWidth,
 441                                             const SlideShowContext&  rContext,
 442                                             PolyPolygonVector&&      rPolygons,
 443                                             bool                     bActive ) :
 444             mpHandler( std::make_shared<PaintOverlayHandler>( rStrokeColor,
 445                                                 nStrokeWidth,
 446                                                 rContext.mrScreenUpdater,
 447                                                 rContext.mrViewContainer,
 448                                                 //adding a link to Slide
 449                                                 dynamic_cast<Slide&>(rContext.mrCursorManager),
 450                                                 std::move(rPolygons), bActive )),
 451             mrMultiplexer( rContext.mrEventMultiplexer )
 452         {
 453             mrMultiplexer.addClickHandler( mpHandler, 3.0 );
 454             mrMultiplexer.addMouseMoveHandler( mpHandler, 3.0 );
 455             mrMultiplexer.addViewHandler( mpHandler );
 456             mrMultiplexer.addUserPaintHandler(mpHandler);
 457         }
 458
 459         PolyPolygonVector const & UserPaintOverlay::getPolygons() const
 460         {
 461             return mpHandler->getPolygons();
 462         }
 463
 464         void UserPaintOverlay::drawPolygons()
 465         {
 466             mpHandler->drawPolygons();
 467         }
 468
 469         UserPaintOverlay::~UserPaintOverlay()
 470         {
 471             try
 472             {
 473                 mrMultiplexer.removeMouseMoveHandler( mpHandler );
 474                 mrMultiplexer.removeClickHandler( mpHandler );
 475                 mrMultiplexer.removeViewHandler( mpHandler );
 476                 mpHandler->dispose();
 477             }
 478             catch (const uno::Exception&)
 479             {
 480                 TOOLS_WARN_EXCEPTION("slideshow", "");
 481             }
 482         }
 483 }
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */