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