sd/source/ui/view/sdview.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 <com/sun/star/embed/NoVisualAreaSizeException.hpp>
  21 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  22
  23 #include "View.hxx"
  24 #include <editeng/unolingu.hxx>
  25 #include <sfx2/request.hxx>
  26 #include <svx/obj3d.hxx>
  27 #include <svx/fmview.hxx>
  28 #include <editeng/outliner.hxx>
  29 #include <svx/svxids.hrc>
  30 #include <svx/svdograf.hxx>
  31 #include <svx/svdoole2.hxx>
  32 #include <svx/svdundo.hxx>
  33
  34 #include <vcl/settings.hxx>
  35 #include <vcl/msgbox.hxx>
  36
  37 #include <sfx2/dispatch.hxx>
  38 #include <sfx2/app.hxx>
  39 #include <svx/svdpagv.hxx>
  40 #include <sfx2/docfile.hxx>
  41 #include <svx/svdoutl.hxx>
  42 #include <svx/sdr/contact/displayinfo.hxx>
  43
  44 #include <svx/svdetc.hxx>
  45 #include <editeng/editstat.hxx>
  46
  47 #include <svx/dialogs.hrc>
  48 #include <sfx2/viewfrm.hxx>
  49 #include <sfx2/sidebar/EnumContext.hxx>
  50 #include <svx/svdopage.hxx>
  51 #include <toolkit/helper/vclunohelper.hxx>
  52 #include <svx/xlndsit.hxx>
  53 #include <svx/xlineit0.hxx>
  54 #include <svx/xlnclit.hxx>
  55 #include <svx/sidebar/ContextChangeEventMultiplexer.hxx>
  56 #include <vcl/virdev.hxx>
  57
  58 #include "app.hrc"
  59 #include "strings.hrc"
  60 #include "Window.hxx"
  61 #include "Client.hxx"
  62 #include "drawdoc.hxx"
  63 #include "DrawDocShell.hxx"
  64 #include "sdmod.hxx"
  65 #include "sdpage.hxx"
  66 #include "glob.hrc"
  67 #include "sdresid.hxx"
  68 #include "DrawViewShell.hxx"
  69 #include "futext.hxx"
  70 #include "fuinsfil.hxx"
  71 #include "slideshow.hxx"
  72 #include "stlpool.hxx"
  73 #include "FrameView.hxx"
  74 #include "ViewClipboard.hxx"
  75 #include "undo/undomanager.hxx"
  76 #include <svx/sdr/contact/viewobjectcontact.hxx>
  77 #include <svx/sdr/contact/viewcontact.hxx>
  78 #include <svx/svdotable.hxx>
  79 #include "EventMultiplexer.hxx"
  80 #include "ViewShellBase.hxx"
  81 #include "ViewShellManager.hxx"
  82
  83 #include <basegfx/polygon/b2dpolygontools.hxx>
  84 #include <basegfx/color/bcolor.hxx>
  85 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  86 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  87 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
  88 #include <svx/sdr/contact/objectcontact.hxx>
  89 #include <svx/sdr/table/tablecontroller.hxx>
  90 #include <basegfx/matrix/b2dhommatrix.hxx>
  91 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  92 #include <svx/unoapi.hxx>
  93 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  94 #include "DrawController.hxx"
  95
  96 #include <numeric>
  97 #include <boost/scoped_ptr.hpp>
  98
  99 using namespace com::sun::star;
 100 using namespace com::sun::star::uno;
 101 using namespace sdr::table;
 102 namespace sd {
 103
 104 TYPEINIT1(View, FmFormView);
 105
 106 View::View(SdDrawDocument& rDrawDoc, OutputDevice* pOutDev,
 107                ViewShell* pViewShell)
 108   : FmFormView(&rDrawDoc, pOutDev),
 109     mrDoc(rDrawDoc),
 110     mpDocSh(rDrawDoc.GetDocSh()),
 111     mpViewSh(pViewShell),
 112     mpDragSrcMarkList(NULL),
 113     mpDropMarkerObj(NULL),
 114     mpDropMarker(NULL),
 115     mnDragSrcPgNum(SDRPAGE_NOTFOUND),
 116     mnAction(DND_ACTION_NONE),
 117     mnLockRedrawSmph(0),
 118     mbIsDropAllowed(true),
 119     maSmartTags(*this),
 120     mpClipboard (new ViewClipboard (*this))
 121 {
 122     // #i73602# Use default from the configuration
 123     SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_DrawImpress());
 124
 125     // #i74769#, #i75172# Use default from the configuration
 126     SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_DrawImpress());
 127
 128     EnableExtendedKeyInputDispatcher(false);
 129     EnableExtendedMouseEventDispatcher(false);
 130     EnableExtendedCommandEventDispatcher(false);
 131
 132     SetUseIncompatiblePathCreateInterface(false);
 133     SetMarkHdlWhenTextEdit(true);
 134     EnableTextEditOnObjectsWithoutTextIfTextTool(true);
 135
 136     SetMinMoveDistancePixel(2);
 137     SetHitTolerancePixel(2);
 138     SetMeasureLayer(SD_RESSTR(STR_LAYER_MEASURELINES));
 139
 140     // Timer for delayed drop (has to be for MAC)
 141     maDropErrorIdle.SetIdleHdl( LINK(this, View, DropErrorHdl) );
 142     maDropErrorIdle.SetPriority(SchedulerPriority::MEDIUM);
 143     maDropInsertFileIdle.SetIdleHdl( LINK(this, View, DropInsertFileHdl) );
 144     maDropInsertFileIdle.SetPriority(SchedulerPriority::MEDIUM);
 145 }
 146
 147 void View::ImplClearDrawDropMarker()
 148 {
 149     if(mpDropMarker)
 150     {
 151         delete mpDropMarker;
 152         mpDropMarker = 0L;
 153     }
 154 }
 155
 156 View::~View()
 157 {
 158     maSmartTags.Dispose();
 159
 160     // release content of selection clipboard, if we own the content
 161     UpdateSelectionClipboard( true );
 162
 163     maDropErrorIdle.Stop();
 164     maDropInsertFileIdle.Stop();
 165
 166     ImplClearDrawDropMarker();
 167
 168     while(PaintWindowCount())
 169     {
 170         // remove all registered OutDevs
 171         DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/);
 172     }
 173 }
 174
 175 class ViewRedirector : public sdr::contact::ViewObjectContactRedirector
 176 {
 177 public:
 178     ViewRedirector();
 179     virtual ~ViewRedirector();
 180
 181     // all default implementations just call the same methods at the original. To do something
 182     // different, override the method and at least do what the method does.
 183     virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
 184         const sdr::contact::ViewObjectContact& rOriginal,
 185         const sdr::contact::DisplayInfo& rDisplayInfo) SAL_OVERRIDE;
 186 };
 187
 188 ViewRedirector::ViewRedirector()
 189 {
 190 }
 191
 192 ViewRedirector::~ViewRedirector()
 193 {
 194 }
 195
 196 drawinglayer::primitive2d::Primitive2DSequence ViewRedirector::createRedirectedPrimitive2DSequence(
 197     const sdr::contact::ViewObjectContact& rOriginal,
 198     const sdr::contact::DisplayInfo& rDisplayInfo)
 199 {
 200     SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
 201     drawinglayer::primitive2d::Primitive2DSequence xRetval;
 202
 203     if(pObject && pObject->GetPage())
 204     {
 205         const bool bDoCreateGeometry(pObject->GetPage()->checkVisibility( rOriginal, rDisplayInfo, true ));
 206
 207         if(!bDoCreateGeometry && !(( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE )) )
 208             return xRetval;
 209
 210         PresObjKind eKind(PRESOBJ_NONE);
 211         const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive());
 212         const bool bIsMasterPageObject(pObject->GetPage()->IsMasterPage());
 213         const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter());
 214         const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView();
 215         const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage());
 216         const SdPage* pObjectsSdPage = dynamic_cast< SdPage* >(pObject->GetPage());
 217         const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage);
 218
 219         // check if we need to draw a placeholder border. Never do it for
 220         // objects inside a SdrPageObj and never when printing
 221         if(!bIsInsidePageObj && !bIsPrinting)
 222         {
 223             bool bCreateOutline(false);
 224
 225             if( pObject->IsEmptyPresObj() && pObject->ISA(SdrTextObj) )
 226             {
 227                 if( !bSubContentProcessing || !pObject->IsNotVisibleAsMaster() )
 228                 {
 229                     eKind = pObjectsSdPage ? pObjectsSdPage->GetPresObjKind(pObject) : PRESOBJ_NONE;
 230                     bCreateOutline = true;
 231                 }
 232             }
 233             else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_TEXT ) )
 234             {
 235                 if( pObjectsSdPage )
 236                 {
 237                     eKind = pObjectsSdPage->GetPresObjKind(pObject);
 238
 239                     if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) )
 240                     {
 241                         if( !bSubContentProcessing )
 242                         {
 243                             // only draw a boundary for header&footer objects on the masterpage itself
 244                             bCreateOutline = true;
 245                         }
 246                     }
 247                 }
 248             }
 249             else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE ) )
 250             {
 251                 // only for handout page, else this frame will be created for each
 252                 // page preview object in SlideSorter and PagePane
 253                 if(pObjectsSdPage && PK_HANDOUT == pObjectsSdPage->GetPageKind())
 254                 {
 255                     bCreateOutline = true;
 256                 }
 257             }
 258
 259             if(bCreateOutline)
 260             {
 261                 // empty presentation objects get a gray frame
 262                 const svtools::ColorConfig aColorConfig;
 263                 const svtools::ColorConfigValue aColor( aColorConfig.GetColorValue( svtools::OBJECTBOUNDARIES ) );
 264
 265                 if( aColor.bIsVisible )
 266                 {
 267                     // get basic object transformation
 268                     const basegfx::BColor aRGBColor(Color(aColor.nColor).getBColor());
 269                     basegfx::B2DHomMatrix aObjectMatrix;
 270                     basegfx::B2DPolyPolygon aObjectPolyPolygon;
 271                     pObject->TRGetBaseGeometry(aObjectMatrix, aObjectPolyPolygon);
 272
 273                     // create dashed border
 274                     {
 275                         // create object polygon
 276                         basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon());
 277                         aPolygon.transform(aObjectMatrix);
 278
 279                         // create line and stroke attribute
 280                         ::std::vector< double > aDotDashArray;
 281
 282                         aDotDashArray.push_back(160.0);
 283                         aDotDashArray.push_back(80.0);
 284
 285                         const double fFullDotDashLen(::std::accumulate(aDotDashArray.begin(), aDotDashArray.end(), 0.0));
 286                         const drawinglayer::attribute::LineAttribute aLine(aRGBColor);
 287                         const drawinglayer::attribute::StrokeAttribute aStroke(aDotDashArray, fFullDotDashLen);
 288
 289                         // create primitive and add
 290                         const drawinglayer::primitive2d::Primitive2DReference xRef(new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
 291                             aPolygon,
 292                             aLine,
 293                             aStroke));
 294                         drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
 295                     }
 296
 297                     // now paint the placeholder description, but only when masterpage
 298                     // is displayed as page directly (MasterPage view)
 299                     if(!bSubContentProcessing && bIsMasterPageObject)
 300                     {
 301                         OUString aObjectString;
 302
 303                         switch( eKind )
 304                         {
 305                             case PRESOBJ_TITLE:
 306                             {
 307                                 if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
 308                                 {
 309                                     static OUString aTitleAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_TITLE));
 310                                     aObjectString = aTitleAreaStr;
 311                                 }
 312
 313                                 break;
 314                             }
 315                             case PRESOBJ_OUTLINE:
 316                             {
 317                                 static OUString aOutlineAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_OUTLINE));
 318                                 aObjectString = aOutlineAreaStr;
 319                                 break;
 320                             }
 321                             case PRESOBJ_FOOTER:
 322                             {
 323                                 static OUString aFooterAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_FOOTER));
 324                                 aObjectString = aFooterAreaStr;
 325                                 break;
 326                             }
 327                             case PRESOBJ_HEADER:
 328                             {
 329                                 static OUString aHeaderAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_HEADER));
 330                                 aObjectString = aHeaderAreaStr;
 331                                 break;
 332                             }
 333                             case PRESOBJ_DATETIME:
 334                             {
 335                                 static OUString aDateTimeStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_DATETIME));
 336                                 aObjectString = aDateTimeStr;
 337                                 break;
 338                             }
 339                             case PRESOBJ_NOTES:
 340                             {
 341                                 static OUString aDateTimeStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_NOTES));
 342                                 aObjectString = aDateTimeStr;
 343                                 break;
 344                             }
 345                             case PRESOBJ_SLIDENUMBER:
 346                             {
 347                                 if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
 348                                 {
 349                                     static OUString aSlideAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_SLIDE));
 350                                     aObjectString = aSlideAreaStr;
 351                                 }
 352                                 else
 353                                 {
 354                                     static OUString aNumberAreaStr(SD_RESSTR(STR_PLACEHOLDER_DESCRIPTION_NUMBER));
 355                                     aObjectString = aNumberAreaStr;
 356                                 }
 357                                 break;
 358                             }
 359                             default:
 360                             {
 361                                 break;
 362                             }
 363                         }
 364
 365                         if( !aObjectString.isEmpty() )
 366                         {
 367                             // decompose object matrix to be able to place text correctly
 368                             basegfx::B2DTuple aScale;
 369                             basegfx::B2DTuple aTranslate;
 370                             double fRotate, fShearX;
 371                             aObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
 372
 373                             // create font
 374                             SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObject );
 375                             const SdrTextVertAdjust eTVA(pTextObj ? pTextObj->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_CENTER);
 376                             vcl::Font aScaledVclFont;
 377
 378                             // use a text size factor to get more reliable text sizes from the text layouter
 379                             // (and from vcl), tipp from HDU
 380                             static sal_uInt32 nTextSizeFactor(100);
 381
 382                             // use a factor to get more linear text size calculations
 383                             aScaledVclFont.SetHeight( 500 * nTextSizeFactor );
 384
 385                             // get basic geometry and get text size
 386                             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 387                             aTextLayouter.setFont(aScaledVclFont);
 388                             const sal_Int32 nTextLength(aObjectString.getLength());
 389
 390                             // do not forget to use the factor again to get the width for the 500
 391                             const double fTextWidth(aTextLayouter.getTextWidth(aObjectString, 0, nTextLength) * (1.0 / nTextSizeFactor));
 392                             const double fTextHeight(aTextLayouter.getTextHeight() * (1.0 / nTextSizeFactor));
 393
 394                             // calculate text primitive position. If text is at bottom, use top for
 395                             // the extra text and vice versa
 396                             const double fHorDist(125);
 397                             const double fVerDist(125);
 398                             const double fPosX((aTranslate.getX() + aScale.getX()) - fTextWidth - fHorDist);
 399                             const double fPosY((SDRTEXTVERTADJUST_BOTTOM == eTVA)
 400                                 ? aTranslate.getY() - fVerDist + fTextHeight
 401                                 : (aTranslate.getY() + aScale.getY()) - fVerDist);
 402
 403                             // get font attributes; use normally scaled font
 404                             const basegfx::BColor aFontColor(aRGBColor);
 405                             vcl::Font aVclFont;
 406                             basegfx::B2DVector aTextSizeAttribute;
 407
 408                             aVclFont.SetHeight( 500 );
 409
 410                             const drawinglayer::attribute::FontAttribute aFontAttribute(
 411                                 drawinglayer::primitive2d::getFontAttributeFromVclFont(
 412                                     aTextSizeAttribute,
 413                                     aVclFont,
 414                                     false,
 415                                     false));
 416
 417                             // fill text matrix
 418                             const basegfx::B2DHomMatrix aTextMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
 419                                 aTextSizeAttribute.getX(), aTextSizeAttribute.getY(),
 420                                 fShearX,
 421                                 fRotate,
 422                                 fPosX, fPosY));
 423
 424                             // create DXTextArray (can be empty one)
 425                             const ::std::vector< double > aDXArray{};
 426
 427                             // create locale; this may need some more information in the future
 428                             const ::com::sun::star::lang::Locale aLocale;
 429
 430                             // create primitive and add
 431                             const drawinglayer::primitive2d::Primitive2DReference xRef(
 432                                 new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 433                                     aTextMatrix,
 434                                     aObjectString,
 435                                     0,
 436                                     nTextLength,
 437                                     aDXArray,
 438                                     aFontAttribute,
 439                                     aLocale,
 440                                     aFontColor));
 441                             drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
 442                         }
 443                     }
 444                 }
 445             }
 446         }
 447
 448         if(bDoCreateGeometry)
 449         {
 450             drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(
 451                 xRetval,
 452                 sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(
 453                     rOriginal,
 454                     rDisplayInfo));
 455         }
 456     }
 457     else
 458     {
 459         // not a SdrObject visualisation (maybe e.g. page) or no page
 460         xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
 461     }
 462
 463     return xRetval;
 464 }
 465
 466 /**
 467  * The event will be forwarded to the View
 468  */
 469 void View::CompleteRedraw(OutputDevice* pOutDev, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/)
 470 {
 471     // execute ??
 472     if (mnLockRedrawSmph == 0)
 473     {
 474         SdrPageView* pPgView = GetSdrPageView();
 475
 476         if (pPgView)
 477         {
 478             SdPage* pPage = static_cast<SdPage*>( pPgView->GetPage() );
 479             if( pPage )
 480             {
 481                 SdrOutliner& rOutl = mrDoc.GetDrawOutliner(NULL);
 482                 bool bScreenDisplay(true);
 483
 484                 if(bScreenDisplay && pOutDev && OUTDEV_PRINTER == pOutDev->GetOutDevType())
 485                 {
 486                     // #i75566# printing; suppress AutoColor BackgroundColor generation
 487                     // for visibility reasons by giving GetPageBackgroundColor()
 488                     // the needed hint
 489                     bScreenDisplay = false;
 490                 }
 491
 492                 if(bScreenDisplay && pOutDev && pOutDev->GetPDFWriter())
 493                 {
 494                     // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above)
 495                     bScreenDisplay = false;
 496                 }
 497
 498                 // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
 499                 // hint value if screen display. Only then the AutoColor mechanisms shall be applied
 500                 rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor(pPgView, bScreenDisplay) );
 501             }
 502         }
 503
 504         ViewRedirector aViewRedirector;
 505         FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector);
 506     }
 507     // or save?
 508     else
 509     {
 510         SdViewRedrawRec* pRec = new SdViewRedrawRec;
 511         pRec->mpOut = pOutDev;
 512         pRec->aRect = rReg.GetBoundRect();
 513         maLockedRedraws.push_back(pRec);
 514     }
 515 }
 516
 517 void View::MarkListHasChanged()
 518 {
 519     FmFormView::MarkListHasChanged();
 520
 521     if( GetMarkedObjectCount() > 0 )
 522         maSmartTags.deselect();
 523 }
 524
 525 bool View::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
 526 {
 527     bool bOk = FmFormView::SetAttributes(rSet, bReplaceAll);
 528     return bOk;
 529 }
 530
 531 bool View::GetAttributes( SfxItemSet& rTargetSet, bool bOnlyHardAttr ) const
 532 {
 533     return FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr );
 534 }
 535
 536 /**
 537  * Is a presentation object selected?
 538  */
 539 bool View::IsPresObjSelected(bool bOnPage, bool bOnMasterPage, bool bCheckPresObjListOnly, bool bCheckLayoutOnly) const
 540 {
 541     SdrMarkList* pMarkList;
 542
 543     if (mnDragSrcPgNum != SDRPAGE_NOTFOUND &&
 544         mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum())
 545     {
 546         /* Drag&Drop is in progress
 547            Source and destination page are different:
 548            we use the saved mark list */
 549         pMarkList = mpDragSrcMarkList;
 550     }
 551     else
 552     {
 553         // We use the current mark list
 554         pMarkList = new SdrMarkList(GetMarkedObjectList());
 555     }
 556
 557     SdrMark* pMark;
 558     SdPage* pPage;
 559
 560     bool bSelected = false;
 561     bool bMasterPage = false;
 562
 563     for (size_t nMark = pMarkList->GetMarkCount(); nMark && !bSelected; )
 564     {
 565         --nMark;
 566         // Backwards through mark list
 567         pMark = pMarkList->GetMark(nMark);
 568         SdrObject* pObj = pMark->GetMarkedSdrObj();
 569
 570         if ( pObj && ( bCheckPresObjListOnly || pObj->IsEmptyPresObj() || pObj->GetUserCall() ) )
 571         {
 572             pPage = static_cast<SdPage*>( pObj->GetPage() );
 573             bMasterPage = pPage && pPage->IsMasterPage();
 574
 575             if ( (bMasterPage && bOnMasterPage) || (!bMasterPage && bOnPage) )
 576             {
 577                 if ( pPage && pPage->IsPresObj(pObj) )
 578                 {
 579                     if( bCheckLayoutOnly )
 580                     {
 581                         PresObjKind eKind = pPage->GetPresObjKind(pObj);
 582
 583                         if((eKind != PRESOBJ_FOOTER) && (eKind != PRESOBJ_HEADER) && (eKind != PRESOBJ_DATETIME) && (eKind != PRESOBJ_SLIDENUMBER) )
 584                             bSelected = true;
 585                     }
 586                     else
 587                     {
 588                         bSelected = true;
 589                     }
 590                 }
 591             }
 592         }
 593     }
 594
 595     if (pMarkList != mpDragSrcMarkList)
 596     {
 597        delete pMarkList;
 598     }
 599
 600     return bSelected;
 601 }
 602
 603 void View::SelectAll()
 604 {
 605     if ( IsTextEdit() )
 606     {
 607         OutlinerView* pOLV = GetTextEditOutlinerView();
 608         const ::Outliner* pOutliner = GetTextEditOutliner();
 609         pOLV->SelectRange( 0, pOutliner->GetParagraphCount() );
 610     }
 611     else
 612     {
 613         MarkAll();
 614     }
 615 }
 616
 617 void View::ModelHasChanged()
 618 {
 619     // First, notify SdrView
 620     FmFormView::ModelHasChanged();
 621 }
 622
 623 bool View::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
 624 {
 625     // forward to SdrView
 626     return FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
 627 }
 628
 629 /**
 630  * Start text input
 631  */
 632 static void SetSpellOptions( const SdDrawDocument& rDoc, EEControlBits& rCntrl )
 633 {
 634     bool bOnlineSpell = rDoc.GetOnlineSpell();
 635
 636     if( bOnlineSpell )
 637         rCntrl |= EEControlBits::ONLINESPELLING;
 638     else
 639         rCntrl &= ~EEControlBits::ONLINESPELLING;
 640 }
 641
 642 void OutlinerMasterViewFilter::Start(SdrOutliner *pOutl)
 643 {
 644     m_pOutl = pOutl;
 645     OutlinerView* pOutlView = m_pOutl->GetView(0);
 646     m_bReadOnly = pOutlView->IsReadOnly();
 647     pOutlView->SetReadOnly(true);
 648 }
 649
 650 void OutlinerMasterViewFilter::End()
 651 {
 652     if (m_pOutl)
 653     {
 654         OutlinerView* pOutlView = m_pOutl->GetView(0);
 655         pOutlView->SetReadOnly(m_bReadOnly);
 656         m_pOutl = NULL;
 657     }
 658 }
 659
 660 bool View::SdrBeginTextEdit(
 661     SdrObject* pObj, SdrPageView* pPV, vcl::Window* pWin,
 662     bool bIsNewObj,
 663     SdrOutliner* pOutl, OutlinerView* pGivenOutlinerView,
 664     bool bDontDeleteOutliner, bool bOnlyOneView, bool bGrabFocus )
 665 {
 666     SdrPage* pPage = pObj ? pObj->GetPage() : NULL;
 667     bool bMasterPage = pPage && pPage->IsMasterPage();
 668
 669     GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
 670         sd::tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT, (void*)pObj );
 671
 672     if( pOutl==NULL && pObj )
 673         pOutl = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, *pObj->GetModel());
 674
 675     // make draw&impress specific initialisations
 676     if( pOutl )
 677     {
 678         pOutl->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>( mrDoc.GetStyleSheetPool() ));
 679         pOutl->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
 680         EEControlBits nCntrl = pOutl->GetControlWord();
 681         nCntrl |= EEControlBits::ALLOWBIGOBJS;
 682         nCntrl |= EEControlBits::MARKFIELDS;
 683         nCntrl |= EEControlBits::AUTOCORRECT;
 684
 685         nCntrl &= ~EEControlBits::ULSPACESUMMATION;
 686         if ( mrDoc.IsSummationOfParagraphs() )
 687             nCntrl |= EEControlBits::ULSPACESUMMATION;
 688
 689         SetSpellOptions( mrDoc, nCntrl );
 690
 691         pOutl->SetControlWord(nCntrl);
 692
 693         Reference< linguistic2::XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
 694         if ( xSpellChecker.is() )
 695             pOutl->SetSpeller( xSpellChecker );
 696
 697         Reference< linguistic2::XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
 698         if( xHyphenator.is() )
 699             pOutl->SetHyphenator( xHyphenator );
 700
 701         pOutl->SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
 702     }
 703
 704     bool bReturn = FmFormView::SdrBeginTextEdit(
 705         pObj, pPV, pWin, bIsNewObj, pOutl,
 706         pGivenOutlinerView, bDontDeleteOutliner,
 707         bOnlyOneView, bGrabFocus);
 708
 709     if ( mpViewSh )
 710     {
 711         mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 712     }
 713
 714     if (bReturn)
 715     {
 716         ::Outliner* pOL = GetTextEditOutliner();
 717
 718         if( pObj && pObj->GetPage() )
 719         {
 720             Color aBackground;
 721             if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_TABLE )
 722             {
 723                 aBackground = GetTextEditBackgroundColor(*this);
 724             }
 725             else
 726             {
 727                 aBackground = pObj->GetPage()->GetPageBackgroundColor(pPV);
 728             }
 729             if (pOL != NULL)
 730                 pOL->SetBackgroundColor( aBackground  );
 731         }
 732
 733         if (pOL != NULL)
 734         {
 735             pOL->SetParaInsertedHdl(LINK(this, View, OnParagraphInsertedHdl));
 736             pOL->SetParaRemovingHdl(LINK(this, View, OnParagraphRemovingHdl));
 737         }
 738     }
 739
 740     if (bMasterPage && bReturn && pOutl)
 741     {
 742         const SdrTextObj* pTextObj = pOutl->GetTextObj();
 743         const SdPage* pSdPage = pTextObj ? static_cast<const SdPage*>(pTextObj->GetPage()) : NULL;
 744         const PresObjKind eKind = pSdPage ? pSdPage->GetPresObjKind(const_cast<SdrTextObj*>(pTextObj)) : PRESOBJ_NONE;
 745         switch (eKind)
 746         {
 747             case PRESOBJ_TITLE:
 748             case PRESOBJ_OUTLINE:
 749             case PRESOBJ_TEXT:
 750                 maMasterViewFilter.Start(pOutl);
 751                 break;
 752             default:
 753                 break;
 754         }
 755     }
 756
 757     return bReturn;
 758 }
 759
 760 /** ends current text editing */
 761 SdrEndTextEditKind View::SdrEndTextEdit(bool bDontDeleteReally)
 762 {
 763     maMasterViewFilter.End();
 764
 765     SdrObjectWeakRef xObj( GetTextEditObject() );
 766
 767     bool bDefaultTextRestored = RestoreDefaultText( dynamic_cast< SdrTextObj* >( GetTextEditObject() ) );
 768
 769     SdrEndTextEditKind eKind = FmFormView::SdrEndTextEdit(bDontDeleteReally);
 770
 771     if( bDefaultTextRestored )
 772     {
 773         if( xObj.is() && !xObj->IsEmptyPresObj() )
 774         {
 775             xObj->SetEmptyPresObj( true );
 776         }
 777         else
 778         {
 779             eKind = SDRENDTEXTEDIT_UNCHANGED;
 780         }
 781     }
 782     else if( xObj.is() && xObj->IsEmptyPresObj() )
 783     {
 784         SdrTextObj* pObj = dynamic_cast< SdrTextObj* >( xObj.get() );
 785         if( pObj && pObj->HasText() )
 786         {
 787             SdrPage* pPage = pObj->GetPage();
 788             if( !pPage || !pPage->IsMasterPage() )
 789                 pObj->SetEmptyPresObj( false );
 790         }
 791     }
 792
 793     GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
 794         sd::tools::EventMultiplexerEvent::EID_END_TEXT_EDIT,
 795         (void*)xObj.get() );
 796
 797     if( xObj.is() )
 798     {
 799         if ( mpViewSh )
 800         {
 801             mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 802         }
 803
 804         SdPage* pPage = dynamic_cast< SdPage* >( xObj->GetPage() );
 805         if( pPage )
 806             pPage->onEndTextEdit( xObj.get() );
 807     }
 808
 809     return eKind;
 810 }
 811
 812 /** restores the default text if the given text object is currently in edit mode and
 813     no text has been entered already. Is only useful just before text edit ends. */
 814 bool View::RestoreDefaultText( SdrTextObj* pTextObj )
 815 {
 816     bool bRestored = false;
 817
 818     if( pTextObj && (pTextObj == GetTextEditObject()) )
 819     {
 820         if( !pTextObj->HasText() )
 821         {
 822             SdPage* pPage = dynamic_cast< SdPage* >( pTextObj->GetPage() );
 823
 824             if(pPage)
 825             {
 826                 bRestored = pPage->RestoreDefaultText( pTextObj );
 827                 if( bRestored )
 828                 {
 829                     SdrOutliner* pOutliner = GetTextEditOutliner();
 830                     pTextObj->SetTextEditOutliner( pOutliner );
 831                     OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
 832                     if (pOutliner)
 833                         pOutliner->SetText(*pParaObj);
 834                 }
 835             }
 836         }
 837     }
 838
 839     return bRestored;
 840 }
 841
 842 /**
 843  * Sets the original size of the marked objects.
 844  */
 845 void View::SetMarkedOriginalSize()
 846 {
 847     SdrUndoGroup* pUndoGroup = new SdrUndoGroup(mrDoc);
 848     const size_t nCount = GetMarkedObjectCount();
 849     bool            bOK = false;
 850
 851     for( size_t i = 0; i < nCount; ++i )
 852     {
 853         SdrObject* pObj = GetMarkedObjectByIndex(i);
 854
 855         if( pObj->GetObjInventor() == SdrInventor )
 856         {
 857             if( pObj->GetObjIdentifier() == OBJ_OLE2 )
 858             {
 859                 uno::Reference < embed::XEmbeddedObject > xObj = static_cast<SdrOle2Obj*>(pObj)->GetObjRef();
 860                 if( xObj.is() )
 861                 {
 862                     // TODO/LEAN: working with VisualArea can switch object to running state
 863
 864                        sal_Int64 nAspect = static_cast<SdrOle2Obj*>(pObj)->GetAspect();
 865                     Size aOleSize;
 866
 867                     if ( nAspect == embed::Aspects::MSOLE_ICON )
 868                     {
 869                         MapMode aMap100( MAP_100TH_MM );
 870                         aOleSize = static_cast<SdrOle2Obj*>(pObj)->GetOrigObjSize( &aMap100 );
 871                         bOK = true;
 872                     }
 873                     else
 874                     {
 875                         MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
 876                         try
 877                         {
 878                             awt::Size aSz = xObj->getVisualAreaSize( nAspect );
 879                             aOleSize = OutputDevice::LogicToLogic( Size( aSz.Width, aSz.Height ), aUnit, MAP_100TH_MM );
 880                             bOK = true;
 881                         }
 882                         catch( embed::NoVisualAreaSizeException& )
 883                         {}
 884                     }
 885
 886                     if ( bOK )
 887                     {
 888                         Rectangle   aDrawRect( pObj->GetLogicRect() );
 889
 890                         pUndoGroup->AddAction( mrDoc.GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
 891                         pObj->Resize( aDrawRect.TopLeft(), Fraction( aOleSize.Width(), aDrawRect.GetWidth() ),
 892                                                            Fraction( aOleSize.Height(), aDrawRect.GetHeight() ) );
 893                     }
 894                 }
 895             }
 896             else if( pObj->GetObjIdentifier() == OBJ_GRAF )
 897             {
 898                 const MapMode   aMap100( MAP_100TH_MM );
 899                 Size            aSize;
 900
 901                 if ( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL )
 902                     aSize = Application::GetDefaultDevice()->PixelToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(), aMap100 );
 903                 else
 904                 {
 905                     aSize = OutputDevice::LogicToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(),
 906                                                         static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode(),
 907                                                         aMap100 );
 908                 }
 909
 910                 pUndoGroup->AddAction( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj ) );
 911                 Rectangle aRect( pObj->GetLogicRect() );
 912                 aRect.SetSize( aSize );
 913                 pObj->SetLogicRect( aRect );
 914
 915                 bOK = true;
 916             }
 917         }
 918     }
 919
 920     if( bOK )
 921     {
 922         pUndoGroup->SetComment(SD_RESSTR(STR_UNDO_ORIGINALSIZE));
 923         mpDocSh->GetUndoManager()->AddUndoAction(pUndoGroup);
 924     }
 925     else
 926         delete pUndoGroup;
 927 }
 928
 929 /**
 930  * Connect OLE object to client.
 931  */
 932 void View::DoConnect(SdrOle2Obj* pObj)
 933 {
 934     if (mpViewSh)
 935     {
 936         uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
 937         if( xObj.is() )
 938         {
 939             ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
 940             SfxInPlaceClient* pSdClient = mpViewSh-> GetViewShellBase().FindIPClient( xObj, pWindow );
 941             if ( !pSdClient )
 942             {
 943                 pSdClient = new Client(pObj, mpViewSh, pWindow);
 944                 Rectangle aRect = pObj->GetLogicRect();
 945                 {
 946                     // TODO/LEAN: working with visual area can switch object to running state
 947                     Size aDrawSize = aRect.GetSize();
 948                     awt::Size aSz;
 949
 950                     MapMode aMapMode( mrDoc.GetScaleUnit() );
 951                     Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
 952
 953                     Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
 954                     Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
 955                     aScaleWidth.ReduceInaccurate(10);       // compatible to SdrOle2Obj
 956                     aScaleHeight.ReduceInaccurate(10);
 957                     pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
 958
 959                     // visible area is only changed in-place!
 960                     // the object area must be set after the scaling, since it triggers resize
 961                     aRect.SetSize(aObjAreaSize);
 962                     pSdClient->SetObjArea(aRect);
 963                 }
 964             }
 965         }
 966     }
 967 }
 968
 969 bool View::IsMorphingAllowed() const
 970 {
 971     const SdrMarkList&  rMarkList = GetMarkedObjectList();
 972     bool                bRet = false;
 973
 974     if ( rMarkList.GetMarkCount() == 2 )
 975     {
 976         const SdrObject*    pObj1 = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 977         const SdrObject*    pObj2 = rMarkList.GetMark( 1 )->GetMarkedSdrObj();
 978         const sal_uInt16        nKind1 = pObj1->GetObjIdentifier();
 979         const sal_uInt16        nKind2 = pObj2->GetObjIdentifier();
 980
 981         if ( ( nKind1 != OBJ_TEXT && nKind2 != OBJ_TEXT ) &&
 982              ( nKind1 != OBJ_TITLETEXT && nKind2 != OBJ_TITLETEXT ) &&
 983              ( nKind1 != OBJ_OUTLINETEXT && nKind2 != OBJ_OUTLINETEXT ) &&
 984              ( nKind1 != OBJ_GRUP && nKind2 != OBJ_GRUP ) &&
 985              ( nKind1 != OBJ_LINE && nKind2 != OBJ_LINE ) &&
 986              ( nKind1 != OBJ_PLIN && nKind2 != OBJ_PLIN ) &&
 987              ( nKind1 != OBJ_PATHLINE && nKind2 != OBJ_PATHLINE ) &&
 988              ( nKind1 != OBJ_FREELINE && nKind2 != OBJ_FREELINE ) &&
 989              ( nKind1 != OBJ_PATHPLIN && nKind2 != OBJ_PATHPLIN ) &&
 990              ( nKind1 != OBJ_MEASURE && nKind2 != OBJ_MEASURE ) &&
 991              ( nKind1 != OBJ_EDGE && nKind2 != OBJ_EDGE ) &&
 992              ( nKind1 != OBJ_GRAF && nKind2 != OBJ_GRAF ) &&
 993              ( nKind1 != OBJ_OLE2 && nKind2 != OBJ_OLE2 ) &&
 994              ( nKind1 != OBJ_CAPTION && nKind2 !=  OBJ_CAPTION ) &&
 995              !pObj1->ISA( E3dObject) && !pObj2->ISA( E3dObject) )
 996         {
 997             SfxItemSet      aSet1( mrDoc.GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );
 998             SfxItemSet      aSet2( mrDoc.GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );
 999
1000             aSet1.Put(pObj1->GetMergedItemSet());
1001             aSet2.Put(pObj2->GetMergedItemSet());
1002
1003             const drawing::FillStyle eFillStyle1 = static_cast<const XFillStyleItem&>( aSet1.Get( XATTR_FILLSTYLE ) ).GetValue();
1004             const drawing::FillStyle eFillStyle2 = static_cast<const XFillStyleItem&>( aSet2.Get( XATTR_FILLSTYLE ) ).GetValue();
1005
1006             if( ( eFillStyle1 == drawing::FillStyle_NONE || eFillStyle1 == drawing::FillStyle_SOLID ) &&
1007                 ( eFillStyle2 == drawing::FillStyle_NONE || eFillStyle2 == drawing::FillStyle_SOLID ) )
1008                 bRet = true;
1009         }
1010     }
1011
1012     return bRet;
1013 }
1014
1015 bool View::IsVectorizeAllowed() const
1016 {
1017     const SdrMarkList&  rMarkList = GetMarkedObjectList();
1018     bool                bRet = false;
1019
1020     if( rMarkList.GetMarkCount() == 1 )
1021     {
1022         const SdrGrafObj* pObj = dynamic_cast< const SdrGrafObj* >(rMarkList.GetMark( 0 )->GetMarkedSdrObj());
1023
1024         if(pObj)
1025         {
1026             if(GRAPHIC_BITMAP == pObj->GetGraphicType() && !pObj->isEmbeddedSvg())
1027             {
1028                 bRet = true;
1029             }
1030         }
1031     }
1032
1033     return bRet;
1034 }
1035
1036 void View::onAccessibilityOptionsChanged()
1037 {
1038     if( mpViewSh )
1039     {
1040         ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
1041         if( pWindow )
1042         {
1043             const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings();
1044
1045             sal_uInt16 nOutputSlot, nPreviewSlot;
1046
1047             SvtAccessibilityOptions& aAccOptions = getAccessibilityOptions();
1048
1049             if( mpViewSh->GetViewFrame() && mpViewSh->GetViewFrame()->GetDispatcher() )
1050             {
1051                 if( rStyleSettings.GetHighContrastMode() )
1052                 {
1053                     nOutputSlot = SID_OUTPUT_QUALITY_CONTRAST;
1054                 }
1055                 else
1056                 {
1057                     nOutputSlot = SID_OUTPUT_QUALITY_COLOR;
1058                 }
1059
1060                 if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
1061                 {
1062                     nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST;
1063                 }
1064                 else
1065                 {
1066                     nPreviewSlot = SID_PREVIEW_QUALITY_COLOR;
1067                 }
1068
1069                 mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nOutputSlot, SfxCallMode::ASYNCHRON );
1070                 mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nPreviewSlot, SfxCallMode::ASYNCHRON );
1071             }
1072
1073             mpViewSh->Invalidate();
1074         }
1075     }
1076 }
1077
1078 IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner *, pOutliner )
1079 {
1080     Paragraph* pPara = pOutliner->GetHdlParagraph();
1081     SdrObject* pObj = GetTextEditObject();
1082
1083     if( pPara && pObj )
1084     {
1085         SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
1086         if( pPage )
1087             pPage->onParagraphInserted( pOutliner, pPara, pObj );
1088     }
1089     return 0;
1090 }
1091
1092 /**
1093  * Handler for the deletion of the pages (paragraphs).
1094  */
1095 IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner *, pOutliner )
1096 {
1097     Paragraph* pPara = pOutliner->GetHdlParagraph();
1098     SdrObject* pObj = GetTextEditObject();
1099
1100     if( pPara && pObj )
1101     {
1102         SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
1103         if( pPage )
1104             pPage->onParagraphRemoving( pOutliner, pPara, pObj );
1105     }
1106     return 0;
1107 }
1108
1109 bool View::isRecordingUndo() const
1110 {
1111     if( mrDoc.IsUndoEnabled() )
1112     {
1113         sd::UndoManager* pUndoManager = mrDoc.GetUndoManager();
1114         return pUndoManager && pUndoManager->IsInListAction();
1115     }
1116     else
1117     {
1118         return false;
1119     }
1120 }
1121
1122 void View::AddCustomHdl()
1123 {
1124     maSmartTags.addCustomHandles( maHdlList );
1125 }
1126
1127 void View::updateHandles()
1128 {
1129     AdjustMarkHdl();
1130 }
1131
1132 SdrViewContext View::GetContext() const
1133 {
1134     SdrViewContext eContext = SDRCONTEXT_STANDARD;
1135     if( maSmartTags.getContext( eContext ) )
1136         return eContext;
1137     else
1138         return FmFormView::GetContext();
1139 }
1140
1141 bool View::HasMarkablePoints() const
1142 {
1143     if( maSmartTags.HasMarkablePoints() )
1144         return true;
1145     else
1146         return FmFormView::HasMarkablePoints();
1147 }
1148
1149 sal_uLong View::GetMarkablePointCount() const
1150 {
1151     sal_uLong nCount = FmFormView::GetMarkablePointCount();
1152     nCount += maSmartTags.GetMarkablePointCount();
1153     return nCount;
1154 }
1155
1156 bool View::HasMarkedPoints() const
1157 {
1158     if( maSmartTags.HasMarkedPoints() )
1159         return true;
1160     else
1161         return FmFormView::HasMarkedPoints();
1162 }
1163
1164 sal_uLong View::GetMarkedPointCount() const
1165 {
1166     sal_uLong nCount = FmFormView::GetMarkedPointCount();
1167     nCount += maSmartTags.GetMarkedPointCount();
1168     return nCount;
1169 }
1170
1171 bool View::IsPointMarkable(const SdrHdl& rHdl) const
1172 {
1173     if( SmartTagSet::IsPointMarkable( rHdl ) )
1174         return true;
1175     else
1176         return FmFormView::IsPointMarkable( rHdl );
1177 }
1178
1179 bool View::MarkPoint(SdrHdl& rHdl, bool bUnmark )
1180 {
1181     if( maSmartTags.MarkPoint( rHdl, bUnmark ) )
1182         return true;
1183     else
1184         return FmFormView::MarkPoint( rHdl, bUnmark );
1185 }
1186
1187 bool View::MarkPoints(const Rectangle* pRect, bool bUnmark)
1188 {
1189     if( maSmartTags.MarkPoints( pRect, bUnmark ) )
1190         return true;
1191     else
1192         return FmFormView::MarkPoints( pRect, bUnmark );
1193 }
1194
1195 void View::CheckPossibilities()
1196 {
1197     FmFormView::CheckPossibilities();
1198     maSmartTags.CheckPossibilities();
1199 }
1200
1201 void View::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfos*/ )
1202 {
1203 }
1204
1205 /** this is called after a paste or drop operation, make sure that the newly inserted paragraphs
1206     get the correct style sheet. */
1207 void View::OnEndPasteOrDrop( PasteOrDropInfos* pInfos )
1208 {
1209     SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetTextEditObject() );
1210     SdrOutliner* pOutliner = GetTextEditOutliner();
1211     if( pOutliner && pTextObj && pTextObj->GetPage() )
1212     {
1213         SdPage* pPage = static_cast< SdPage* >( pTextObj->GetPage() );
1214
1215         SfxStyleSheet* pStyleSheet = 0;
1216
1217         const PresObjKind eKind = pPage->GetPresObjKind(pTextObj);
1218         if( eKind != PRESOBJ_NONE )
1219             pStyleSheet = pPage->GetStyleSheetForPresObj(eKind);
1220         else
1221             pStyleSheet = pTextObj->GetStyleSheet();
1222
1223         if( eKind == PRESOBJ_OUTLINE )
1224         {
1225             // for outline shapes, set the correct outline style sheet for each
1226             // new paragraph, depending on the paragraph depth
1227             SfxStyleSheetBasePool* pStylePool = GetDoc().GetStyleSheetPool();
1228
1229             for ( sal_Int32 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
1230             {
1231                 sal_Int16 nDepth = pOutliner->GetDepth( nPara );
1232
1233                 SfxStyleSheet* pStyle = 0;
1234                 if( nDepth > 0 )
1235                 {
1236                     OUString aStyleSheetName( pStyleSheet->GetName() );
1237                     if (!aStyleSheetName.isEmpty())
1238                         aStyleSheetName = aStyleSheetName.copy(0, aStyleSheetName.getLength() - 1);
1239                     aStyleSheetName += OUString::number( nDepth );
1240                     pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyleSheet->GetFamily() ) );
1241                     DBG_ASSERT( pStyle, "sd::View::OnEndPasteOrDrop(), Style not found!" );
1242                 }
1243
1244                 if( !pStyle )
1245                     pStyle = pStyleSheet;
1246
1247                 pOutliner->SetStyleSheet( nPara, pStyle );
1248             }
1249         }
1250         else
1251         {
1252             // just put the object style on each new paragraph
1253             for ( sal_Int32 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
1254             {
1255                 pOutliner->SetStyleSheet( nPara, pStyleSheet );
1256             }
1257         }
1258     }
1259 }
1260
1261 bool View::ShouldToggleOn(
1262     const bool bBulletOnOffMode,
1263     const bool bNormalBullet)
1264 {
1265     // If setting bullets/numbering by the dialog, always should toggle on.
1266     if (!bBulletOnOffMode)
1267         return true;
1268     SdrModel* pSdrModel = GetModel();
1269     if (!pSdrModel)
1270         return false;
1271
1272     bool bToggleOn = false;
1273     boost::scoped_ptr<SdrOutliner> pOutliner(SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, *pSdrModel));
1274     const size_t nMarkCount = GetMarkedObjectCount();
1275     for (size_t nIndex = 0; nIndex < nMarkCount && !bToggleOn; ++nIndex)
1276     {
1277         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1278         if (!pTextObj || pTextObj->IsTextEditActive())
1279             continue;
1280         if (pTextObj->ISA(SdrTableObj))
1281         {
1282             SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1283             if (!pTableObj)
1284                 continue;
1285             CellPos aStart, aEnd;
1286             SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1287             if (pTableController)
1288             {
1289                 pTableController->getSelectedCells(aStart, aEnd);
1290             }
1291             else
1292             {
1293                 aStart = SdrTableObj::getFirstCell();
1294                 aEnd = pTableObj->getLastCell();
1295             }
1296             sal_Int32 nColCount = pTableObj->getColumnCount();
1297             for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow && !bToggleOn; nRow++)
1298             {
1299                 for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol && !bToggleOn; nCol++)
1300                 {
1301                     sal_Int32 nCellIndex = nRow * nColCount + nCol;
1302                     SdrText* pText = pTableObj->getText(nCellIndex);
1303                     if (!pText || !pText->GetOutlinerParaObject())
1304                         continue;
1305                     pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1306                     sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1307                     bToggleOn = (bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1) || bToggleOn;
1308                     pOutliner->Clear();
1309                 }
1310             }
1311         }
1312         else
1313         {
1314             OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1315             if (!pParaObj)
1316                 continue;
1317             pOutliner->SetText(*pParaObj);
1318             sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1319             bToggleOn = (bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1) || bToggleOn;
1320             pOutliner->Clear();
1321         }
1322     }
1323     return bToggleOn;
1324 }
1325
1326 void View::ChangeMarkedObjectsBulletsNumbering(
1327     const bool bToggle,
1328     const bool bHandleBullets,
1329     const SvxNumRule* pNumRule,
1330     const bool bSwitchOff )
1331 {
1332     SdrModel* pSdrModel = GetModel();
1333     vcl::Window* pWindow = dynamic_cast< vcl::Window* >(GetFirstOutputDevice());
1334     if (!pSdrModel || !pWindow)
1335         return;
1336
1337     const bool bUndoEnabled = pSdrModel->IsUndoEnabled();
1338     SdrUndoGroup* pUndoGroup = bUndoEnabled ? new SdrUndoGroup(*pSdrModel) : 0;
1339
1340     const bool bToggleOn =
1341         !bSwitchOff
1342         && ShouldToggleOn( bToggle, bHandleBullets );
1343
1344     boost::scoped_ptr<SdrOutliner> pOutliner(SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, *pSdrModel));
1345     boost::scoped_ptr<OutlinerView> pOutlinerView(new OutlinerView(pOutliner.get(), pWindow));
1346
1347     const size_t nMarkCount = GetMarkedObjectCount();
1348     for (size_t nIndex = 0; nIndex < nMarkCount; ++nIndex)
1349     {
1350         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1351         if (!pTextObj || pTextObj->IsTextEditActive())
1352             continue;
1353         if (pTextObj->ISA(SdrTableObj))
1354         {
1355             SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1356             if (!pTableObj)
1357                 continue;
1358             CellPos aStart, aEnd;
1359             SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1360             if (pTableController)
1361             {
1362                 pTableController->getSelectedCells(aStart, aEnd);
1363             }
1364             else
1365             {
1366                 aStart = SdrTableObj::getFirstCell();
1367                 aEnd = pTableObj->getLastCell();
1368             }
1369             sal_Int32 nColCount = pTableObj->getColumnCount();
1370             for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++)
1371             {
1372                 for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++)
1373                 {
1374                     sal_Int32 nCellIndex = nRow * nColCount + nCol;
1375                     SdrText* pText = pTableObj->getText(nCellIndex);
1376                     if (!pText || !pText->GetOutlinerParaObject())
1377                         continue;
1378
1379                     pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1380                     if (bUndoEnabled)
1381                     {
1382                         SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, nCellIndex));
1383                         pUndoGroup->AddAction(pTxtUndo);
1384                     }
1385                     if ( !bToggleOn )
1386                     {
1387                         pOutlinerView->SwitchOffBulletsNumbering();
1388                     }
1389                     else
1390                     {
1391                         pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1392                     }
1393                     sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1394                     pText->SetOutlinerParaObject(pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount));
1395                     pOutliner->Clear();
1396                 }
1397             }
1398             // Broadcast the object change event.
1399             if (!pTextObj->AdjustTextFrameWidthAndHeight())
1400             {
1401                 pTextObj->SetChanged();
1402                 pTextObj->BroadcastObjectChange();
1403             }
1404         }
1405         else
1406         {
1407             OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1408             if (!pParaObj)
1409                 continue;
1410             pOutliner->SetText(*pParaObj);
1411             if (bUndoEnabled)
1412             {
1413                 SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, 0));
1414                 pUndoGroup->AddAction(pTxtUndo);
1415             }
1416             if ( !bToggleOn )
1417             {
1418                 pOutlinerView->SwitchOffBulletsNumbering();
1419             }
1420             else
1421             {
1422                 pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1423             }
1424             sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1425             pTextObj->SetOutlinerParaObject(pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount));
1426             pOutliner->Clear();
1427         }
1428     }
1429
1430     if ( bUndoEnabled && pUndoGroup->GetActionCount() > 0 )
1431     {
1432         pSdrModel->BegUndo();
1433         pSdrModel->AddUndo(pUndoGroup);
1434         pSdrModel->EndUndo();
1435     }
1436     else
1437         delete pUndoGroup;
1438 }
1439
1440 } // end of namespace sd
1441
1442 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */