sd/source/ui/unoidl/SdUnoDrawView.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 #include <SdUnoDrawView.hxx>
  21
  22 #include <DrawController.hxx>
  23 #include <DrawDocShell.hxx>
  24 #include <DrawViewShell.hxx>
  25 #include <drawdoc.hxx>
  26 #include "unolayer.hxx"
  27 #include <unomodel.hxx>
  28 #include <unopage.hxx>
  29 #include <Window.hxx>
  30 #include <pres.hxx>
  31
  32 #include <comphelper/processfactory.hxx>
  33 #include <cppuhelper/supportsservice.hxx>
  34 #include <sfx2/dispatch.hxx>
  35 #include <sfx2/viewfrm.hxx>
  36 #include <svx/svdpagv.hxx>
  37 #include <svx/unoshape.hxx>
  38 #include <sfx2/zoomitem.hxx>
  39 #include <com/sun/star/drawing/DrawViewMode.hpp>
  40 #include <com/sun/star/drawing/ShapeCollection.hpp>
  41 #include <com/sun/star/drawing/XLayerManager.hpp>
  42 #include <com/sun/star/view/DocumentZoomType.hpp>
  43
  44 #include <vector>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::drawing;
  49
  50 namespace sd {
  51
  52 SdUnoDrawView::SdUnoDrawView(
  53     DrawViewShell& rViewShell,
  54     View& rView) throw()
  55     :   DrawSubControllerInterfaceBase(m_aMutex),
  56         mrDrawViewShell(rViewShell),
  57         mrView(rView)
  58 {
  59 }
  60
  61 SdUnoDrawView::~SdUnoDrawView() throw()
  62 {
  63 }
  64
  65 bool SdUnoDrawView::getMasterPageMode() const throw()
  66 {
  67     return (mrDrawViewShell.GetEditMode() == EditMode::MasterPage);
  68 }
  69
  70 void SdUnoDrawView::setMasterPageMode (bool bMasterPageMode) throw()
  71 {
  72     if ((mrDrawViewShell.GetEditMode() == EditMode::MasterPage) != bMasterPageMode)
  73     {
  74         mrDrawViewShell.ChangeEditMode (
  75             bMasterPageMode ? EditMode::MasterPage : EditMode::Page,
  76             mrDrawViewShell.IsLayerModeActive());
  77     }
  78 }
  79
  80 bool SdUnoDrawView::getLayerMode() const throw()
  81 {
  82     return mrDrawViewShell.IsLayerModeActive();
  83 }
  84
  85 void SdUnoDrawView::setLayerMode (bool bLayerMode) throw()
  86 {
  87     if (mrDrawViewShell.IsLayerModeActive() != bLayerMode)
  88     {
  89         mrDrawViewShell.ChangeEditMode (
  90             mrDrawViewShell.GetEditMode(),
  91             bLayerMode);
  92     }
  93 }
  94
  95 Reference<drawing::XLayer> SdUnoDrawView::getActiveLayer()
  96 {
  97     Reference<drawing::XLayer> xCurrentLayer;
  98
  99     do
 100     {
 101         // Retrieve the layer manager from the model.
 102         SdXImpressDocument* pModel = GetModel();
 103         if (pModel == nullptr)
 104             break;
 105
 106         SdDrawDocument* pSdModel = pModel->GetDoc();
 107         if (pSdModel == nullptr)
 108             break;
 109
 110         // From the model get the current SdrLayer object via the layer admin.
 111         SdrLayerAdmin& rLayerAdmin = pSdModel->GetLayerAdmin ();
 112         SdrLayer* pLayer = rLayerAdmin.GetLayer (mrView.GetActiveLayer());
 113         if (pLayer == nullptr)
 114             break;
 115
 116         // Get the corresponding XLayer object from the implementation
 117         // object of the layer manager.
 118         Reference<drawing::XLayerManager> xManager (pModel->getLayerManager(), uno::UNO_QUERY);
 119         SdLayerManager* pManager = SdLayerManager::getImplementation (xManager);
 120         if (pManager != nullptr)
 121             xCurrentLayer = pManager->GetLayer (pLayer);
 122     }
 123     while (false);
 124
 125     return xCurrentLayer;
 126 }
 127
 128 void SdUnoDrawView::setActiveLayer (const Reference<drawing::XLayer>& rxLayer)
 129 {
 130     // Get the SdrLayer object corresponding to the given reference.
 131     if ( ! rxLayer.is())
 132         return;
 133
 134     SdLayer* pLayer = SdLayer::getImplementation (rxLayer);
 135     if (pLayer == nullptr)
 136         return;
 137
 138     SdrLayer* pSdrLayer = pLayer->GetSdrLayer();
 139     if (pSdrLayer == nullptr)
 140         return;
 141
 142     // Set the new active layer and make the change visible.
 143     mrView.SetActiveLayer (pSdrLayer->GetName());
 144     mrDrawViewShell.ResetActualLayer ();
 145 }
 146
 147 // XSelectionSupplier
 148
 149 sal_Bool SAL_CALL SdUnoDrawView::select( const Any& aSelection )
 150 {
 151     bool bOk = true;
 152
 153     ::std::vector<SdrObject*> aObjects;
 154
 155     SdrPage* pSdrPage = nullptr;
 156
 157     Reference< drawing::XShape > xShape;
 158     aSelection >>= xShape;
 159
 160     if(xShape.is())
 161     {
 162         SvxShape* pShape = SvxShape::getImplementation( xShape );
 163         if( pShape && (pShape->GetSdrObject() != nullptr) )
 164         {
 165             SdrObject* pObj = pShape->GetSdrObject();
 166             pSdrPage = pObj->getSdrPageFromSdrObject();
 167             aObjects.push_back( pObj );
 168         }
 169         else
 170         {
 171             bOk = false;
 172         }
 173     }
 174     else
 175     {
 176         Reference< drawing::XShapes > xShapes;
 177         aSelection >>= xShapes;
 178         if( xShapes.is() )
 179         {
 180             const sal_uInt32 nCount = xShapes->getCount();
 181             for( sal_uInt32 i = 0; i < nCount; i++ )
 182             {
 183                 xShapes->getByIndex(i) >>= xShape;
 184                 if( xShape.is() )
 185                 {
 186                     SvxShape* pShape = SvxShape::getImplementation(xShape);
 187                     if( (pShape == nullptr) || (pShape->GetSdrObject() == nullptr) )
 188                     {
 189                         bOk = false;
 190                         break;
 191                     }
 192
 193                     SdrObject* pObj = pShape->GetSdrObject();
 194
 195                     if( pSdrPage == nullptr )
 196                     {
 197                         pSdrPage = pObj->getSdrPageFromSdrObject();
 198                     }
 199                     else if( pSdrPage != pObj->getSdrPageFromSdrObject() )
 200                     {
 201                         bOk = false;
 202                         break;
 203                     }
 204
 205                     aObjects.push_back( pObj );
 206                 }
 207             }
 208         }
 209     }
 210
 211     if( bOk )
 212     {
 213         if( pSdrPage )
 214         {
 215             setMasterPageMode( pSdrPage->IsMasterPage() );
 216             mrDrawViewShell.SwitchPage( (pSdrPage->GetPageNum() - 1) >> 1 );
 217             mrDrawViewShell.WriteFrameViewData();
 218         }
 219
 220         SdrPageView *pPV = mrView.GetSdrPageView();
 221
 222         if(pPV)
 223         {
 224             // first deselect all
 225             mrView.UnmarkAllObj( pPV );
 226
 227             for( SdrObject* pObj : aObjects )
 228             {
 229                 mrView.MarkObj( pObj, pPV );
 230             }
 231         }
 232         else
 233         {
 234             bOk = false;
 235         }
 236     }
 237
 238     return bOk;
 239 }
 240
 241 Any SAL_CALL SdUnoDrawView::getSelection()
 242 {
 243     Any aAny;
 244
 245     if( mrView.IsTextEdit() )
 246         mrView.getTextSelection( aAny );
 247
 248     if( !aAny.hasValue() )
 249     {
 250         const SdrMarkList& rMarkList = mrView.GetMarkedObjectList();
 251         const size_t nCount = rMarkList.GetMarkCount();
 252         if( nCount )
 253         {
 254             Reference< drawing::XShapes > xShapes( drawing::ShapeCollection::create(
 255                         comphelper::getProcessComponentContext()), UNO_QUERY );
 256             for( size_t nNum = 0; nNum < nCount; ++nNum)
 257             {
 258                 SdrMark *pMark = rMarkList.GetMark(nNum);
 259                 if(pMark==nullptr)
 260                     continue;
 261
 262                 SdrObject *pObj = pMark->GetMarkedSdrObj();
 263                 if(pObj==nullptr || pObj->getSdrPageFromSdrObject() == nullptr)
 264                     continue;
 265
 266                 Reference< drawing::XDrawPage > xPage( pObj->getSdrPageFromSdrObject()->getUnoPage(), UNO_QUERY);
 267
 268                 if(!xPage.is())
 269                     continue;
 270
 271                 SvxDrawPage* pDrawPage = SvxDrawPage::getImplementation( xPage );
 272
 273                 if(pDrawPage==nullptr)
 274                     continue;
 275
 276                 Reference< drawing::XShape > xShape( pObj->getUnoShape(), UNO_QUERY );
 277
 278                 if(xShape.is())
 279                     xShapes->add(xShape);
 280             }
 281             aAny <<= xShapes;
 282         }
 283     }
 284
 285     return aAny;
 286 }
 287
 288 void SAL_CALL SdUnoDrawView::addSelectionChangeListener (
 289     const css::uno::Reference<css::view::XSelectionChangeListener>&)
 290 {}
 291
 292 void SAL_CALL SdUnoDrawView::removeSelectionChangeListener (
 293     const css::uno::Reference<css::view::XSelectionChangeListener>&)
 294 {}
 295
 296 void SdUnoDrawView::setFastPropertyValue (
 297     sal_Int32 nHandle,
 298         const Any& rValue)
 299 {
 300     switch( nHandle )
 301     {
 302         case DrawController::PROPERTY_CURRENTPAGE:
 303             {
 304                 Reference< drawing::XDrawPage > xPage;
 305                 rValue >>= xPage;
 306                 setCurrentPage( xPage );
 307             }
 308             break;
 309
 310         case DrawController::PROPERTY_MASTERPAGEMODE:
 311             {
 312                 bool bValue = false;
 313                 rValue >>= bValue;
 314                 setMasterPageMode( bValue );
 315             }
 316             break;
 317
 318         case DrawController::PROPERTY_LAYERMODE:
 319             {
 320                 bool bValue = false;
 321                 rValue >>= bValue;
 322                 setLayerMode( bValue );
 323             }
 324             break;
 325         case DrawController::PROPERTY_ACTIVE_LAYER:
 326             {
 327                 Reference<drawing::XLayer> xLayer;
 328                 rValue >>= xLayer;
 329                 setActiveLayer (xLayer);
 330             }
 331             break;
 332         case DrawController::PROPERTY_ZOOMVALUE:
 333             {
 334                 sal_Int16 nZoom = 0;
 335                 rValue >>= nZoom;
 336                 SetZoom( nZoom );
 337             }
 338             break;
 339         case DrawController::PROPERTY_ZOOMTYPE:
 340             {
 341                 sal_Int16 nType = 0;
 342                 rValue >>= nType;
 343                 SetZoomType( nType );
 344             }
 345             break;
 346         case DrawController::PROPERTY_VIEWOFFSET:
 347             {
 348                 awt::Point aOffset;
 349                 rValue >>= aOffset;
 350                 SetViewOffset( aOffset );
 351             }
 352             break;
 353         default:
 354             throw beans::UnknownPropertyException( OUString::number(nHandle), static_cast<cppu::OWeakObject*>(this));
 355     }
 356 }
 357
 358 Any SAL_CALL SdUnoDrawView::getFastPropertyValue (
 359     sal_Int32 nHandle)
 360 {
 361     Any aValue;
 362     switch( nHandle )
 363     {
 364         case DrawController::PROPERTY_CURRENTPAGE:
 365             aValue <<= getCurrentPage();
 366             break;
 367
 368         case DrawController::PROPERTY_MASTERPAGEMODE:
 369             aValue <<= getMasterPageMode();
 370             break;
 371
 372         case DrawController::PROPERTY_LAYERMODE:
 373             aValue <<= getLayerMode();
 374             break;
 375
 376         case DrawController::PROPERTY_ACTIVE_LAYER:
 377             aValue <<= getActiveLayer();
 378             break;
 379
 380         case DrawController::PROPERTY_ZOOMVALUE:
 381             aValue <<= GetZoom();
 382             break;
 383         case DrawController::PROPERTY_ZOOMTYPE:
 384             aValue <<= sal_Int16(css::view::DocumentZoomType::BY_VALUE);
 385             break;
 386         case DrawController::PROPERTY_VIEWOFFSET:
 387             aValue <<= GetViewOffset();
 388             break;
 389
 390         case DrawController::PROPERTY_DRAWVIEWMODE:
 391             aValue = getDrawViewMode();
 392             break;
 393
 394         default:
 395             throw beans::UnknownPropertyException( OUString::number(nHandle), static_cast<cppu::OWeakObject*>(this));
 396     }
 397
 398     return aValue;
 399 }
 400
 401 // XDrawView
 402
 403 void SAL_CALL SdUnoDrawView::setCurrentPage (
 404     const Reference< drawing::XDrawPage >& xPage )
 405 {
 406     SvxDrawPage* pDrawPage = SvxDrawPage::getImplementation( xPage );
 407     SdrPage *pSdrPage = pDrawPage ? pDrawPage->GetSdrPage() : nullptr;
 408
 409     if(pSdrPage)
 410     {
 411         // End editing of text.  Otherwise the edited text object would
 412         // still be visible on the new page.
 413         mrDrawViewShell.GetView()->SdrEndTextEdit();
 414
 415         setMasterPageMode( pSdrPage->IsMasterPage() );
 416         mrDrawViewShell.SwitchPage( (pSdrPage->GetPageNum() - 1) >> 1 );
 417         mrDrawViewShell.WriteFrameViewData();
 418     }
 419 }
 420
 421 Reference< drawing::XDrawPage > SAL_CALL SdUnoDrawView::getCurrentPage()
 422 {
 423     Reference< drawing::XDrawPage >  xPage;
 424
 425     SdrPageView *pPV = mrView.GetSdrPageView();
 426     SdrPage* pPage = pPV ? pPV->GetPage() : nullptr;
 427
 428     if(pPage)
 429         xPage.set( pPage->getUnoPage(), UNO_QUERY );
 430
 431     return xPage;
 432 }
 433
 434 sal_Int16 SdUnoDrawView::GetZoom() const
 435 {
 436     if (mrDrawViewShell.GetActiveWindow() )
 437     {
 438         return static_cast<sal_Int16>(mrDrawViewShell.GetActiveWindow()->GetZoom());
 439     }
 440     else
 441     {
 442         return 0;
 443     }
 444 }
 445
 446 void SdUnoDrawView::SetZoom( sal_Int16 nZoom )
 447 {
 448     SvxZoomItem aZoomItem( SvxZoomType::PERCENT, nZoom );
 449
 450     SfxViewFrame* pViewFrame = mrDrawViewShell.GetViewFrame();
 451     if( pViewFrame )
 452     {
 453         SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher();
 454         if( pDispatcher )
 455         {
 456             pDispatcher->ExecuteList(SID_ATTR_ZOOM, SfxCallMode::SYNCHRON,
 457                     { &aZoomItem });
 458         }
 459     }
 460 }
 461
 462 void SdUnoDrawView::SetViewOffset(const awt::Point& rWinPos )
 463 {
 464     Point aWinPos( rWinPos.X, rWinPos.Y );
 465     aWinPos += mrDrawViewShell.GetViewOrigin();
 466     mrDrawViewShell.SetWinViewPos( aWinPos );
 467 }
 468
 469 awt::Point SdUnoDrawView::GetViewOffset() const
 470 {
 471     Point aRet = mrDrawViewShell.GetWinViewPos();
 472     aRet -= mrDrawViewShell.GetViewOrigin();
 473
 474     return awt::Point( aRet.X(), aRet.Y() );
 475 }
 476
 477 void SdUnoDrawView::SetZoomType ( sal_Int16 nType )
 478 {
 479     SfxViewFrame* pViewFrame = mrDrawViewShell.GetViewFrame();
 480     if( !pViewFrame )
 481         return;
 482
 483     SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher();
 484     if( !pDispatcher )
 485         return;
 486
 487     SvxZoomType eZoomType;
 488     switch( nType )
 489     {
 490         case css::view::DocumentZoomType::OPTIMAL:
 491             eZoomType = SvxZoomType::OPTIMAL;
 492             break;
 493
 494         case css::view::DocumentZoomType::PAGE_WIDTH:
 495         case css::view::DocumentZoomType::PAGE_WIDTH_EXACT:
 496             eZoomType = SvxZoomType::PAGEWIDTH;
 497             break;
 498
 499         case css::view::DocumentZoomType::ENTIRE_PAGE:
 500             eZoomType = SvxZoomType::WHOLEPAGE;
 501             break;
 502
 503         default:
 504             return;
 505     }
 506     SvxZoomItem aZoomItem( eZoomType );
 507     pDispatcher->ExecuteList(SID_ATTR_ZOOM, SfxCallMode::SYNCHRON,
 508             { &aZoomItem });
 509 }
 510
 511 SdXImpressDocument* SdUnoDrawView::GetModel() const throw()
 512 {
 513     if (mrView.GetDocSh()!=nullptr)
 514     {
 515         Reference<frame::XModel> xModel (mrView.GetDocSh()->GetModel());
 516         return SdXImpressDocument::getImplementation(xModel);
 517     }
 518     else
 519         return nullptr;
 520 }
 521
 522 Any SdUnoDrawView::getDrawViewMode() const
 523 {
 524     Any aRet;
 525     switch( mrDrawViewShell.GetPageKind() )
 526     {
 527     case PageKind::Notes:  aRet <<= DrawViewMode_NOTES; break;
 528     case PageKind::Handout: aRet <<= DrawViewMode_HANDOUT; break;
 529     case PageKind::Standard: aRet <<= DrawViewMode_DRAW; break;
 530     }
 531     return aRet;
 532 }
 533
 534 // XServiceInfo
 535 OUString SAL_CALL SdUnoDrawView::getImplementationName(  )
 536 {
 537     return OUString( "com.sun.star.comp.sd.SdUnoDrawView") ;
 538 }
 539
 540 sal_Bool SAL_CALL SdUnoDrawView::supportsService( const OUString& ServiceName )
 541 {
 542     return cppu::supportsService( this, ServiceName );
 543 }
 544
 545 Sequence< OUString > SAL_CALL SdUnoDrawView::getSupportedServiceNames(  )
 546 {
 547     OUString aSN("com.sun.star.drawing.DrawingDocumentDrawView");
 548     uno::Sequence< OUString > aSeq( &aSN, 1 );
 549     return aSeq;
 550 }
 551
 552 } // end of namespace sd
 553
 554 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */