sd/source/ui/view/drviews3.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 <config_features.h>
  21
  22 #include "DrawViewShell.hxx"
  23
  24 #include <sfx2/viewfrm.hxx>
  25 #include <editeng/eeitem.hxx>
  26 #include <editeng/tstpitem.hxx>
  27 #include <editeng/lrspitem.hxx>
  28 #include <editeng/protitem.hxx>
  29 #include <editeng/frmdiritem.hxx>
  30 #include <editeng/adjustitem.hxx>
  31 #include <svx/ruler.hxx>
  32 #include <editeng/numitem.hxx>
  33 #include <svx/rulritem.hxx>
  34 #include <sfx2/zoomitem.hxx>
  35 #include <svx/svxids.hrc>
  36 #include <svx/svdpagv.hxx>
  37 #include <sfx2/request.hxx>
  38 #include <sfx2/dispatch.hxx>
  39 #include <tools/urlobj.hxx>
  40 #include <svl/aeitem.hxx>
  41 #include <svl/eitem.hxx>
  42 #include <svl/rectitem.hxx>
  43 #include <svl/stritem.hxx>
  44 #include <svx/svdoole2.hxx>
  45 #include <svl/itempool.hxx>
  46 #include <svl/ptitem.hxx>
  47 #include <basic/sbstar.hxx>
  48 #include <basic/sberrors.hxx>
  49 #include <svx/fmshell.hxx>
  50 #include <svx/f3dchild.hxx>
  51 #include <svx/float3d.hxx>
  52 #include "optsitem.hxx"
  53
  54 #include "app.hrc"
  55 #include "glob.hrc"
  56 #include "strings.hrc"
  57 #include "res_bmp.hrc"
  58
  59 #include "sdundogr.hxx"
  60 #include "undopage.hxx"
  61 #include "glob.hxx"
  62 #include "sdmod.hxx"
  63 #include "fupoor.hxx"
  64 #include "slideshow.hxx"
  65 #include "FrameView.hxx"
  66 #include "sdpage.hxx"
  67 #include "Window.hxx"
  68 #include "sdresid.hxx"
  69 #include "drawview.hxx"
  70 #include "drawdoc.hxx"
  71 #include "Ruler.hxx"
  72 #include "DrawDocShell.hxx"
  73 #include "headerfooterdlg.hxx"
  74 #include "masterlayoutdlg.hxx"
  75 #include "sdabstdlg.hxx"
  76 #include <sfx2/ipclient.hxx>
  77 #include <tools/diagnose_ex.h>
  78 #include "ViewShellBase.hxx"
  79 #include "FormShellManager.hxx"
  80 #include "LayerTabBar.hxx"
  81 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  82 #include <com/sun/star/drawing/framework/XConfigurationController.hpp>
  83 #include <com/sun/star/drawing/framework/XConfiguration.hpp>
  84 #include <com/sun/star/frame/XFrame.hpp>
  85 #include <editeng/lspcitem.hxx>
  86 #include <editeng/ulspitem.hxx>
  87 #include <boost/scoped_ptr.hpp>
  88
  89 using namespace ::com::sun::star::uno;
  90 using namespace ::com::sun::star::drawing::framework;
  91 using ::com::sun::star::frame::XFrame;
  92 using ::com::sun::star::frame::XController;
  93
  94 namespace sd {
  95
  96 /**
  97  * handle SfxRequests for controller
  98  */
  99 void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
 100 {
 101     // except a page switch and jumps to bookmarks, nothing is executed during
 102     // a slide show
 103     if( HasCurrentFunction(SID_PRESENTATION) &&
 104         rReq.GetSlot() != SID_SWITCHPAGE &&
 105         rReq.GetSlot() != SID_JUMPTOMARK)
 106         return;
 107
 108     CheckLineTo (rReq);
 109
 110     // End text edit mode for some requests.
 111     sal_uInt16 nSlot = rReq.GetSlot();
 112     switch (nSlot)
 113     {
 114         case SID_OUTPUT_QUALITY_COLOR:
 115         case SID_OUTPUT_QUALITY_GRAYSCALE:
 116         case SID_OUTPUT_QUALITY_BLACKWHITE:
 117         case SID_OUTPUT_QUALITY_CONTRAST:
 118             // Do nothing.
 119             break;
 120         default:
 121             if ( mpDrawView->IsTextEdit() )
 122             {
 123                 mpDrawView->SdrEndTextEdit();
 124             }
 125     }
 126
 127     //  sal_uInt16 nSlot = rReq.GetSlot();
 128     switch (nSlot)
 129     {
 130         case SID_SWITCHPAGE:  // BASIC
 131         {
 132             // switch page in running slide show
 133             if(SlideShow::IsRunning(GetViewShellBase()) && rReq.GetArgs())
 134             {
 135                 SFX_REQUEST_ARG(rReq, pWhatPage, SfxUInt32Item, ID_VAL_WHATPAGE, false);
 136                 SlideShow::GetSlideShow(GetViewShellBase())->jumpToPageNumber((sal_Int32)((pWhatPage->GetValue()-1)>>1));
 137             }
 138             else
 139             {
 140                 const SfxItemSet *pArgs = rReq.GetArgs ();
 141                 sal_uInt16 nSelectedPage = 0;
 142
 143                 if (! pArgs)
 144                 {
 145                     nSelectedPage = maTabControl->GetCurPageId() - 1;
 146                 }
 147                 else if (pArgs->Count () == 2)
 148                 {
 149                     SFX_REQUEST_ARG (rReq, pWhatPage, SfxUInt32Item, ID_VAL_WHATPAGE, false);
 150                     SFX_REQUEST_ARG (rReq, pWhatKind, SfxUInt32Item, ID_VAL_WHATKIND, false);
 151
 152                     sal_Int32 nWhatPage = (sal_Int32)pWhatPage->GetValue ();
 153                     sal_Int32 nWhatKind = (sal_Int32)pWhatKind->GetValue ();
 154                     if (! CHECK_RANGE (PK_STANDARD, nWhatKind, PK_HANDOUT))
 155                     {
 156 #if HAVE_FEATURE_SCRIPTING
 157                         StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
 158 #endif
 159                         rReq.Ignore ();
 160                         break;
 161                     }
 162                     else if (meEditMode != EM_MASTERPAGE)
 163                     {
 164                         if (! CHECK_RANGE (0, nWhatPage, GetDoc()->GetSdPageCount((PageKind)nWhatKind)))
 165                         {
 166 #if HAVE_FEATURE_SCRIPTING
 167                             StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
 168 #endif
 169                             rReq.Ignore ();
 170                             break;
 171                         }
 172
 173                         nSelectedPage = (short) nWhatPage;
 174                         mePageKind    = (PageKind) nWhatKind;
 175                     }
 176                 }
 177                 else
 178                 {
 179 #if HAVE_FEATURE_SCRIPTING
 180                     StarBASIC::FatalError (SbERR_WRONG_ARGS);
 181 #endif
 182                     rReq.Ignore ();
 183                     break;
 184                 }
 185
 186                 if( GetDocSh() && (GetDocSh()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED))
 187                     GetDocSh()->SetModified();
 188
 189                 SwitchPage(nSelectedPage);
 190
 191                 if(HasCurrentFunction(SID_BEZIER_EDIT))
 192                     GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
 193
 194                 Invalidate();
 195                 InvalidateWindows();
 196                 rReq.Done ();
 197             }
 198             break;
 199         }
 200
 201         case SID_SWITCHLAYER:  // BASIC
 202         {
 203             const SfxItemSet *pArgs = rReq.GetArgs ();
 204
 205             // #i87182#
 206             bool bCurPageValid(false);
 207             sal_uInt16 nCurPage(0);
 208
 209             if(GetLayerTabControl())
 210             {
 211                 nCurPage = GetLayerTabControl()->GetCurPageId();
 212                 bCurPageValid = true;
 213             }
 214
 215             if(pArgs && 1 == pArgs->Count())
 216             {
 217                 SFX_REQUEST_ARG (rReq, pWhatLayer, SfxUInt32Item, ID_VAL_WHATLAYER, false);
 218
 219                 if(pWhatLayer)
 220                 {
 221                     nCurPage = (short)pWhatLayer->GetValue();
 222                     bCurPageValid = true;
 223                 }
 224             }
 225
 226             if(bCurPageValid)
 227             {
 228                 mpDrawView->SetActiveLayer( GetLayerTabControl()->GetPageText(nCurPage) );
 229                 Invalidate();
 230             }
 231
 232             rReq.Done ();
 233
 234             break;
 235         }
 236
 237         case SID_PAGEMODE:  // BASIC
 238         {
 239
 240             const SfxItemSet *pArgs = rReq.GetArgs ();
 241
 242             if ( pArgs && pArgs->Count () == 2)
 243             {
 244                 SFX_REQUEST_ARG (rReq, pIsActive, SfxBoolItem, ID_VAL_ISACTIVE, false);
 245                 SFX_REQUEST_ARG (rReq, pWhatKind, SfxUInt32Item, ID_VAL_WHATKIND, false);
 246
 247                 sal_Int32 nWhatKind = (sal_Int32)pWhatKind->GetValue ();
 248                 if (CHECK_RANGE (PK_STANDARD, nWhatKind, PK_HANDOUT))
 249                 {
 250                     mbIsLayerModeActive = pIsActive->GetValue ();
 251                     mePageKind = (PageKind) nWhatKind;
 252                 }
 253             }
 254
 255             // turn on default layer of page
 256             mpDrawView->SetActiveLayer(SD_RESSTR(STR_LAYER_LAYOUT));
 257
 258             ChangeEditMode(EM_PAGE, mbIsLayerModeActive);
 259
 260             Invalidate();
 261             rReq.Done ();
 262
 263             break;
 264         }
 265
 266         case SID_LAYERMODE:  // BASIC
 267         {
 268             const SfxItemSet *pArgs = rReq.GetArgs ();
 269
 270             if ( pArgs && pArgs->Count () == 2)
 271             {
 272                 SFX_REQUEST_ARG (rReq, pWhatLayerMode, SfxBoolItem, ID_VAL_ISACTIVE, false);
 273                 SFX_REQUEST_ARG (rReq, pWhatLayer, SfxUInt32Item, ID_VAL_WHATLAYER, false);
 274
 275                 sal_Int32 nWhatLayer = (sal_Int32)pWhatLayer->GetValue ();
 276                 if (CHECK_RANGE (EM_PAGE, nWhatLayer, EM_MASTERPAGE))
 277                 {
 278                     mbIsLayerModeActive = pWhatLayerMode->GetValue ();
 279                     meEditMode = (EditMode) nWhatLayer;
 280                 }
 281             }
 282
 283             ChangeEditMode(meEditMode, !mbIsLayerModeActive);
 284
 285             Invalidate();
 286             rReq.Done ();
 287
 288             break;
 289         }
 290
 291         case SID_HEADER_AND_FOOTER:
 292         case SID_INSERT_PAGE_NUMBER:
 293         case SID_INSERT_DATE_TIME:
 294         {
 295             SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 296             boost::scoped_ptr<AbstractHeaderFooterDialog> pDlg(pFact ? pFact->CreateHeaderFooterDialog( this, GetActiveWindow(), GetDoc(), mpActualPage ) : 0);
 297             if( pDlg )
 298             {
 299                 pDlg->Execute();
 300                 pDlg.reset();
 301
 302                 GetActiveWindow()->Invalidate();
 303                 UpdatePreview( mpActualPage );
 304             }
 305
 306             Invalidate();
 307             rReq.Done ();
 308
 309             break;
 310         }
 311
 312         case SID_MASTER_LAYOUTS:
 313         {
 314             SdPage* pPage = GetActualPage();
 315             if (meEditMode == EM_MASTERPAGE)
 316                 // Use the master page of the current page.
 317                 pPage = static_cast<SdPage*>(&pPage->TRG_GetMasterPage());
 318
 319             SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 320             boost::scoped_ptr<VclAbstractDialog> pDlg(pFact ? pFact->CreateMasterLayoutDialog( GetActiveWindow(), GetDoc(), pPage ) : 0);
 321             if( pDlg )
 322             {
 323                 pDlg->Execute();
 324                 pDlg.reset();
 325                 Invalidate();
 326             }
 327             rReq.Done ();
 328             break;
 329         }
 330         case SID_OBJECTRESIZE:
 331         {
 332             // The server likes to change the client size
 333             OSL_ASSERT (GetViewShell()!=NULL);
 334             SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient();
 335
 336             if ( pIPClient && pIPClient->IsObjectInPlaceActive() )
 337             {
 338                 const SfxRectangleItem& rRect =
 339                     static_cast<const SfxRectangleItem&>(rReq.GetArgs()->Get(SID_OBJECTRESIZE));
 340                 Rectangle aRect( GetActiveWindow()->PixelToLogic( rRect.GetValue() ) );
 341
 342                 if ( mpDrawView->AreObjectsMarked() )
 343                 {
 344                     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 345
 346                     if (rMarkList.GetMarkCount() == 1)
 347                     {
 348                         SdrMark* pMark = rMarkList.GetMark(0);
 349                         SdrObject* pObj = pMark->GetMarkedSdrObj();
 350
 351                         SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( pObj );
 352                         if(pOle2Obj)
 353                         {
 354                             if( pOle2Obj->GetObjRef().is() )
 355                             {
 356                                 pOle2Obj->SetLogicRect(aRect);
 357                             }
 358                         }
 359                     }
 360                 }
 361             }
 362             rReq.Ignore ();
 363             break;
 364         }
 365
 366         case SID_RELOAD:
 367         {
 368             sal_uInt16 nId = Svx3DChildWindow::GetChildWindowId();
 369             SfxViewFrame* pFrame = GetViewFrame();
 370
 371             try
 372             {
 373                 Reference< XFrame > xFrame( pFrame->GetFrame().GetFrameInterface(), UNO_SET_THROW );
 374
 375                 // Save the current configuration of panes and views.
 376                 Reference<XControllerManager> xControllerManager (
 377                     GetViewShellBase().GetController(), UNO_QUERY_THROW);
 378                 Reference<XConfigurationController> xConfigurationController (
 379                     xControllerManager->getConfigurationController(), UNO_QUERY_THROW );
 380                 Reference<XConfiguration> xConfiguration (
 381                     xConfigurationController->getRequestedConfiguration(), UNO_SET_THROW );
 382
 383                 SfxChildWindow* pWindow = pFrame->GetChildWindow(nId);
 384                 if(pWindow)
 385                 {
 386                     Svx3DWin* p3DWin = static_cast<Svx3DWin*>(pWindow->GetWindow());
 387                     if(p3DWin)
 388                         p3DWin->DocumentReload();
 389                 }
 390
 391                 // normal forwarding to ViewFrame for execution
 392                 GetViewFrame()->ExecuteSlot(rReq);
 393
 394                 // From here on we must cope with this object and the frame already being
 395                 // deleted.  Do not call any methods or use data members.
 396                 Reference<XController> xController( xFrame->getController(), UNO_SET_THROW );
 397
 398                 // Restore the configuration.
 399                 xControllerManager = Reference<XControllerManager>( xController, UNO_QUERY_THROW);
 400                 xConfigurationController = Reference<XConfigurationController>(
 401                     xControllerManager->getConfigurationController());
 402                 if ( ! xConfigurationController.is())
 403                     throw RuntimeException();
 404                 xConfigurationController->restoreConfiguration(xConfiguration);
 405             }
 406             catch (RuntimeException&)
 407             {
 408                 DBG_UNHANDLED_EXCEPTION();
 409             }
 410
 411             // We have to return immediately to avoid accessing this object.
 412             return;
 413         }
 414
 415         case SID_JUMPTOMARK:
 416         {
 417             if( rReq.GetArgs() )
 418             {
 419                 SFX_REQUEST_ARG(rReq, pBookmark, SfxStringItem, SID_JUMPTOMARK, false);
 420
 421                 if (pBookmark)
 422                 {
 423                     OUString sBookmark(INetURLObject::decode(pBookmark->GetValue(), INetURLObject::DECODE_WITH_CHARSET));
 424
 425                     rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) );
 426                     if(xSlideshow.is() && xSlideshow->isRunning())
 427                     {
 428                         xSlideshow->jumpToBookmark(sBookmark);
 429                     }
 430                     else
 431                     {
 432                         GotoBookmark(sBookmark);
 433                     }
 434                 }
 435             }
 436             rReq.Done();
 437             break;
 438         }
 439
 440         case SID_OUTPUT_QUALITY_COLOR:
 441         case SID_OUTPUT_QUALITY_GRAYSCALE:
 442         case SID_OUTPUT_QUALITY_BLACKWHITE:
 443         case SID_OUTPUT_QUALITY_CONTRAST:
 444         {
 445             ExecReq( rReq );
 446             break;
 447         }
 448
 449         case SID_MAIL_SCROLLBODY_PAGEDOWN:
 450         {
 451             ExecReq( rReq );
 452             break;
 453         }
 454
 455         case SID_ATTR_YEAR2000:
 456         {
 457             FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
 458             if (pFormShell != NULL)
 459             {
 460                 const SfxPoolItem* pItem;
 461                 if (rReq.GetArgs()->GetItemState(
 462                     SID_ATTR_YEAR2000, true, &pItem) == SfxItemState::SET)
 463                     pFormShell->SetY2KState (
 464                         static_cast<const SfxUInt16Item*>(pItem)->GetValue());
 465             }
 466
 467             rReq.Done();
 468         }
 469         break;
 470
 471         case SID_OPT_LOCALE_CHANGED:
 472         {
 473             GetActiveWindow()->Invalidate();
 474             UpdatePreview( mpActualPage );
 475             rReq.Done();
 476         }
 477
 478         default:
 479         break;
 480     }
 481 }
 482
 483 void  DrawViewShell::ExecRuler(SfxRequest& rReq)
 484 {
 485     // nothing is executed during a slide show!
 486     if(HasCurrentFunction(SID_PRESENTATION))
 487         return;
 488
 489     CheckLineTo (rReq);
 490
 491     const SfxItemSet* pArgs = rReq.GetArgs();
 492     const Point aPagePos( GetActiveWindow()->GetViewOrigin() );
 493     Size aPageSize = mpActualPage->GetSize();
 494     Size aViewSize = GetActiveWindow()->GetViewSize();
 495
 496     switch ( rReq.GetSlot() )
 497     {
 498         case SID_ATTR_LONG_LRSPACE:
 499         {
 500             SdUndoGroup* pUndoGroup = new SdUndoGroup(GetDoc());
 501             pUndoGroup->SetComment(SdResId(STR_UNDO_CHANGE_PAGEBORDER));
 502
 503             const SvxLongLRSpaceItem& rLRSpace = static_cast<const SvxLongLRSpaceItem&>(
 504                     pArgs->Get(GetPool().GetWhich(SID_ATTR_LONG_LRSPACE)));
 505
 506             if( mpDrawView->IsTextEdit() )
 507             {
 508                 Rectangle aRect = maMarkRect;
 509                 aRect.SetPos(aRect.TopLeft() + aPagePos);
 510                 aRect.Left()  = rLRSpace.GetLeft();
 511                 aRect.Right() = aViewSize.Width() - rLRSpace.GetRight();
 512                 aRect.SetPos(aRect.TopLeft() - aPagePos);
 513                 if ( aRect != maMarkRect)
 514                 {
 515                     mpDrawView->SetAllMarkedRect(aRect);
 516                     maMarkRect = mpDrawView->GetAllMarkedRect();
 517                     Invalidate( SID_RULER_OBJECT );
 518                 }
 519             }
 520             else
 521             {
 522                 long nLeft = std::max(0L, rLRSpace.GetLeft() - aPagePos.X());
 523                 long nRight = std::max(0L, rLRSpace.GetRight() + aPagePos.X() +
 524                                       aPageSize.Width() - aViewSize.Width());
 525
 526                 sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 527                 sal_uInt16 i;
 528                 for ( i = 0; i < nPageCnt; i++)
 529                 {
 530                     SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
 531                     SdUndoAction* pUndo = new SdPageLRUndoAction(GetDoc(),
 532                                             pPage,
 533                                             pPage->GetLftBorder(),
 534                                             pPage->GetRgtBorder(),
 535                                             nLeft, nRight);
 536                     pUndoGroup->AddAction(pUndo);
 537                     pPage->SetLftBorder(nLeft);
 538                     pPage->SetRgtBorder(nRight);
 539                 }
 540                 nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 541
 542                 for (i = 0; i < nPageCnt; i++)
 543                 {
 544                     SdPage* pPage = GetDoc()->GetMasterSdPage(i, mePageKind);
 545                     SdUndoAction* pUndo = new SdPageLRUndoAction(GetDoc(),
 546                                             pPage,
 547                                             pPage->GetLftBorder(),
 548                                             pPage->GetRgtBorder(),
 549                                             nLeft, nRight);
 550                     pUndoGroup->AddAction(pUndo);
 551                     pPage->SetLftBorder(nLeft);
 552                     pPage->SetRgtBorder(nRight);
 553                 }
 554                 InvalidateWindows();
 555             }
 556
 557             // give the undo group to the undo manager
 558             GetViewFrame()->GetObjectShell()->GetUndoManager()->
 559                                                 AddUndoAction(pUndoGroup);
 560             break;
 561         }
 562         case SID_ATTR_LONG_ULSPACE:
 563         {
 564             SdUndoGroup* pUndoGroup = new SdUndoGroup(GetDoc());
 565             pUndoGroup->SetComment(SdResId(STR_UNDO_CHANGE_PAGEBORDER));
 566
 567             const SvxLongULSpaceItem& rULSpace = static_cast<const SvxLongULSpaceItem&>(
 568                     pArgs->Get(GetPool().GetWhich(SID_ATTR_LONG_ULSPACE)));
 569
 570             if( mpDrawView->IsTextEdit() )
 571             {
 572                 Rectangle aRect = maMarkRect;
 573                 aRect.SetPos(aRect.TopLeft() + aPagePos);
 574                 aRect.Top()  = rULSpace.GetUpper();
 575                 aRect.Bottom() = aViewSize.Height() - rULSpace.GetLower();
 576                 aRect.SetPos(aRect.TopLeft() - aPagePos);
 577
 578                 if ( aRect != maMarkRect)
 579                 {
 580                     mpDrawView->SetAllMarkedRect(aRect);
 581                     maMarkRect = mpDrawView->GetAllMarkedRect();
 582                     Invalidate( SID_RULER_OBJECT );
 583                 }
 584             }
 585             else
 586             {
 587                 long nUpper = std::max(0L, rULSpace.GetUpper() - aPagePos.Y());
 588                 long nLower = std::max(0L, rULSpace.GetLower() + aPagePos.Y() +
 589                                       aPageSize.Height() - aViewSize.Height());
 590
 591                 sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 592                 sal_uInt16 i;
 593                 for ( i = 0; i < nPageCnt; i++)
 594                 {
 595                     SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
 596                     SdUndoAction* pUndo = new SdPageULUndoAction(GetDoc(),
 597                                             pPage,
 598                                             pPage->GetUppBorder(),
 599                                             pPage->GetLwrBorder(),
 600                                             nUpper, nLower);
 601                     pUndoGroup->AddAction(pUndo);
 602                     pPage->SetUppBorder(nUpper);
 603                     pPage->SetLwrBorder(nLower);
 604                 }
 605                 nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 606
 607                 for (i = 0; i < nPageCnt; i++)
 608                 {
 609                     SdPage* pPage = GetDoc()->GetMasterSdPage(i, mePageKind);
 610                     SdUndoAction* pUndo = new SdPageULUndoAction(GetDoc(),
 611                                             pPage,
 612                                             pPage->GetUppBorder(),
 613                                             pPage->GetLwrBorder(),
 614                                             nUpper, nLower);
 615                     pUndoGroup->AddAction(pUndo);
 616                     pPage->SetUppBorder(nUpper);
 617                     pPage->SetLwrBorder(nLower);
 618                 }
 619                 InvalidateWindows();
 620             }
 621
 622             // give the undo group to the undo manager
 623             GetViewFrame()->GetObjectShell()->GetUndoManager()->
 624                                                 AddUndoAction(pUndoGroup);
 625
 626             break;
 627         }
 628
 629         case SID_RULER_OBJECT:
 630         {
 631             Rectangle aRect = maMarkRect;
 632             aRect.SetPos(aRect.TopLeft() + aPagePos);
 633
 634             const SvxObjectItem& rOI = static_cast<const SvxObjectItem&>(
 635                     pArgs->Get(GetPool().GetWhich(SID_RULER_OBJECT)));
 636
 637             if ( rOI.GetStartX() != rOI.GetEndX() )
 638             {
 639                 aRect.Left()  = rOI.GetStartX();
 640                 aRect.Right() = rOI.GetEndX();
 641             }
 642             if ( rOI.GetStartY() != rOI.GetEndY() )
 643             {
 644                 aRect.Top()    = rOI.GetStartY();
 645                 aRect.Bottom() = rOI.GetEndY();
 646             }
 647             aRect.SetPos(aRect.TopLeft() - aPagePos);
 648             if ( aRect != maMarkRect)
 649             {
 650                 mpDrawView->SetAllMarkedRect(aRect);
 651                 maMarkRect = mpDrawView->GetAllMarkedRect();
 652                 Invalidate( SID_RULER_OBJECT );
 653             }
 654             break;
 655         }
 656
 657         case SID_ATTR_TABSTOP:
 658         {
 659             if( mpDrawView->IsTextEdit() )
 660             {
 661                 const SvxTabStopItem& rItem = static_cast<const SvxTabStopItem&>(
 662                             pArgs->Get( EE_PARA_TABS ));
 663
 664                 SfxItemSet aEditAttr( GetPool(), EE_PARA_TABS, EE_PARA_TABS );
 665
 666                 aEditAttr.Put( rItem );
 667                 mpDrawView->SetAttributes( aEditAttr );
 668
 669                 Invalidate(SID_ATTR_TABSTOP);
 670             }
 671             break;
 672         }
 673
 674         case SID_ATTR_PARA_LINESPACE:
 675         {
 676             sal_uInt16 nSlot = SID_ATTR_PARA_LINESPACE;
 677             SvxLineSpacingItem aParaLineSP = static_cast<const SvxLineSpacingItem&>(pArgs->Get(
 678                 GetPool().GetWhich(nSlot)));
 679
 680             SfxItemSet aEditAttr( GetPool(), EE_PARA_SBL, EE_PARA_SBL );
 681             aParaLineSP.SetWhich( EE_PARA_SBL );
 682
 683             aEditAttr.Put( aParaLineSP );
 684             mpDrawView->SetAttributes( aEditAttr );
 685
 686             Invalidate(SID_ATTR_PARA_LINESPACE);
 687         }
 688         break;
 689         case SID_ATTR_PARA_ADJUST_LEFT:
 690         {
 691             SvxAdjustItem aItem( SVX_ADJUST_LEFT, EE_PARA_JUST );
 692             SfxItemSet aEditAttr( GetPool(), EE_PARA_JUST, EE_PARA_JUST );
 693
 694             aEditAttr.Put( aItem );
 695             mpDrawView->SetAttributes( aEditAttr );
 696
 697             Invalidate(SID_ATTR_PARA_ADJUST_LEFT);
 698         }
 699         break;
 700         case SID_ATTR_PARA_ADJUST_CENTER:
 701         {
 702             SvxAdjustItem aItem( SVX_ADJUST_CENTER, EE_PARA_JUST );
 703             SfxItemSet aEditAttr( GetPool(), EE_PARA_JUST, EE_PARA_JUST );
 704
 705             aEditAttr.Put( aItem );
 706             mpDrawView->SetAttributes( aEditAttr );
 707
 708             Invalidate(SID_ATTR_PARA_ADJUST_CENTER);
 709         }
 710         break;
 711         case SID_ATTR_PARA_ADJUST_RIGHT:
 712         {
 713             SvxAdjustItem aItem( SVX_ADJUST_RIGHT, EE_PARA_JUST );
 714             SfxItemSet aEditAttr( GetPool(), EE_PARA_JUST, EE_PARA_JUST );
 715
 716             aEditAttr.Put( aItem );
 717             mpDrawView->SetAttributes( aEditAttr );
 718
 719             Invalidate(SID_ATTR_PARA_ADJUST_RIGHT);
 720         }
 721         break;
 722         case SID_ATTR_PARA_ADJUST_BLOCK:
 723         {
 724             SvxAdjustItem aItem( SVX_ADJUST_BLOCK, EE_PARA_JUST );
 725             SfxItemSet aEditAttr( GetPool(), EE_PARA_JUST, EE_PARA_JUST );
 726
 727             aEditAttr.Put( aItem );
 728             mpDrawView->SetAttributes( aEditAttr );
 729
 730             Invalidate(SID_ATTR_PARA_ADJUST_BLOCK);
 731         }
 732         break;
 733         case SID_ATTR_PARA_ULSPACE:
 734         {
 735             sal_uInt16 nSlot = SID_ATTR_PARA_ULSPACE;
 736             SvxULSpaceItem aULSP = static_cast<const SvxULSpaceItem&>(pArgs->Get(
 737                 GetPool().GetWhich(nSlot)));
 738             SfxItemSet aEditAttr( GetPool(), EE_PARA_ULSPACE, EE_PARA_ULSPACE );
 739             aULSP.SetWhich( EE_PARA_ULSPACE );
 740
 741             aEditAttr.Put( aULSP );
 742             mpDrawView->SetAttributes( aEditAttr );
 743
 744             Invalidate(SID_ATTR_PARA_ULSPACE);
 745         }
 746         break;
 747
 748         case SID_ATTR_PARA_LRSPACE:
 749         {
 750             sal_uInt16 nSlot = SID_ATTR_PARA_LRSPACE;
 751             SvxLRSpaceItem aLRSpace = static_cast<const SvxLRSpaceItem&>(pArgs->Get(
 752                 GetPool().GetWhich(nSlot)));
 753
 754             SfxItemSet aEditAttr( GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE );
 755             aLRSpace.SetWhich( EE_PARA_LRSPACE );
 756
 757             aEditAttr.Put( aLRSpace );
 758             mpDrawView->SetAttributes( aEditAttr );
 759
 760             Invalidate(SID_ATTR_PARA_LRSPACE);
 761             break;
 762         }
 763         case SID_ATTR_LRSPACE:
 764         {
 765             if( mpDrawView->IsTextEdit() )
 766             {
 767                 sal_uInt16 nId = SID_ATTR_PARA_LRSPACE;
 768                 const SvxLRSpaceItem& rItem = static_cast<const SvxLRSpaceItem&>(
 769                             pArgs->Get( nId ));
 770
 771                 static const sal_uInt16 aWhichTable[]=
 772                 {
 773                     EE_PARA_OUTLLEVEL, EE_PARA_OUTLLEVEL,
 774                     EE_PARA_LRSPACE, EE_PARA_LRSPACE,
 775                     EE_PARA_NUMBULLET, EE_PARA_NUMBULLET,
 776                     0, 0
 777                 };
 778
 779                 SfxItemSet aEditAttr( GetDoc()->GetPool(),
 780                                       aWhichTable );
 781                 mpDrawView->GetAttributes( aEditAttr );
 782
 783                 nId = EE_PARA_LRSPACE;
 784                 SvxLRSpaceItem aLRSpaceItem( rItem.GetLeft(),
 785                         rItem.GetRight(), rItem.GetTextLeft(),
 786                         rItem.GetTextFirstLineOfst(), nId );
 787
 788                 const sal_Int16 nOutlineLevel = static_cast<const SfxInt16Item&>(aEditAttr.Get( EE_PARA_OUTLLEVEL )).GetValue();
 789                 const SvxLRSpaceItem& rOrigLRSpaceItem = static_cast<const SvxLRSpaceItem&>( aEditAttr.Get( EE_PARA_LRSPACE ));
 790                 const SvxNumBulletItem& rNumBulletItem = static_cast<const SvxNumBulletItem&>( aEditAttr.Get( EE_PARA_NUMBULLET ) );
 791                 if( nOutlineLevel != -1 &&
 792                     rNumBulletItem.GetNumRule() &&
 793                     rNumBulletItem.GetNumRule()->GetLevelCount() > nOutlineLevel )
 794                 {
 795                     const SvxNumberFormat& rFormat = rNumBulletItem.GetNumRule()->GetLevel(nOutlineLevel);
 796                     SvxNumberFormat aFormat(rFormat);
 797
 798                     // left margin gets distributed onto LRSpace item
 799                     // and number format AbsLSpace - this fixes
 800                     // n#707779 (previously, LRSpace left indent could
 801                     // become negative - EditEngine really does not
 802                     // like that.
 803                     const short nAbsLSpace=aFormat.GetAbsLSpace();
 804                     const long  nTxtLeft=rItem.GetTextLeft();
 805                     const long  nLeftIndent=std::max(0L,nTxtLeft - nAbsLSpace);
 806                     aLRSpaceItem.SetTextLeft(nLeftIndent);
 807                     // control for clipped left indent - remainder
 808                     // reduces number format first line indent
 809                     aFormat.SetAbsLSpace(nTxtLeft - nLeftIndent);
 810
 811                     // negative first line indent goes to the number
 812                     // format, positive to the lrSpace item
 813                     if( rItem.GetTextFirstLineOfst() < 0 )
 814                     {
 815                         aFormat.SetFirstLineOffset(
 816                             rItem.GetTextFirstLineOfst()
 817                             - rOrigLRSpaceItem.GetTextFirstLineOfst()
 818                             + aFormat.GetCharTextDistance());
 819                         aLRSpaceItem.SetTextFirstLineOfst(0);
 820                     }
 821                     else
 822                     {
 823                         aFormat.SetFirstLineOffset(0);
 824                         aLRSpaceItem.SetTextFirstLineOfst(
 825                             rItem.GetTextFirstLineOfst()
 826                             - aFormat.GetFirstLineOffset()
 827                             + aFormat.GetCharTextDistance());
 828                     }
 829
 830                     if( rFormat != aFormat )
 831                     {
 832                         // put all items
 833                         SvxNumBulletItem aNumBulletItem(rNumBulletItem);
 834                         aNumBulletItem.GetNumRule()->SetLevel(nOutlineLevel,aFormat);
 835                         aEditAttr.Put( aNumBulletItem );
 836                         aEditAttr.Put( aLRSpaceItem );
 837                         mpDrawView->SetAttributes( aEditAttr );
 838
 839                         Invalidate(SID_ATTR_PARA_LRSPACE);
 840                         break;
 841                     }
 842                 }
 843
 844                 // only put lrSpace item
 845                 SfxItemSet aEditAttrReduced( GetDoc()->GetPool(),
 846                                              EE_PARA_LRSPACE, EE_PARA_LRSPACE );
 847                 aEditAttrReduced.Put( aLRSpaceItem );
 848                 mpDrawView->SetAttributes( aEditAttrReduced );
 849
 850                 Invalidate(SID_ATTR_PARA_LRSPACE);
 851             }
 852             break;
 853         }
 854     }
 855 }
 856
 857 void  DrawViewShell::GetRulerState(SfxItemSet& rSet)
 858 {
 859     Point aOrigin;
 860
 861     if (mpDrawView->GetSdrPageView())
 862     {
 863         aOrigin = mpDrawView->GetSdrPageView()->GetPageOrigin();
 864     }
 865
 866     Size aViewSize = GetActiveWindow()->GetViewSize();
 867
 868     const Point aPagePos( GetActiveWindow()->GetViewOrigin() );
 869     Size aPageSize = mpActualPage->GetSize();
 870
 871     Rectangle aRect(aPagePos, Point( aViewSize.Width() - (aPagePos.X() + aPageSize.Width()),
 872                                      aViewSize.Height() - (aPagePos.Y() + aPageSize.Height())));
 873
 874     if( mpDrawView->IsTextEdit() )
 875     {
 876         Point aPnt1 = GetActiveWindow()->GetWinViewPos();
 877         Rectangle aMinMaxRect = Rectangle( aPnt1, Size(ULONG_MAX, ULONG_MAX) );
 878         rSet.Put( SfxRectangleItem(SID_RULER_LR_MIN_MAX, aMinMaxRect) );
 879     }
 880     else
 881     {
 882         rSet.Put( SfxRectangleItem(SID_RULER_LR_MIN_MAX, aRect) );
 883     }
 884
 885     SvxLongLRSpaceItem aLRSpace(aPagePos.X() + mpActualPage->GetLftBorder(),
 886                                 aRect.Right() + mpActualPage->GetRgtBorder(),
 887                                 GetPool().GetWhich(SID_ATTR_LONG_LRSPACE));
 888     SvxLongULSpaceItem aULSpace(aPagePos.Y() + mpActualPage->GetUppBorder(),
 889                                 aRect.Bottom() + mpActualPage->GetLwrBorder(),
 890                                 GetPool().GetWhich(SID_ATTR_LONG_ULSPACE));
 891     rSet.Put(SvxPagePosSizeItem(Point(0,0) - aPagePos, aViewSize.Width(),
 892                                                        aViewSize.Height()));
 893     SfxPointItem aPointItem( SID_RULER_NULL_OFFSET, aPagePos + aOrigin );
 894
 895     SvxProtectItem aProtect( SID_RULER_PROTECT );
 896
 897     maMarkRect = mpDrawView->GetAllMarkedRect();
 898
 899     const bool bRTL = GetDoc() && GetDoc()->GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB;
 900     rSet.Put(SfxBoolItem(SID_RULER_TEXT_RIGHT_TO_LEFT, bRTL));
 901
 902     if( mpDrawView->AreObjectsMarked() )
 903     {
 904         if( mpDrawView->IsTextEdit() )
 905         {
 906             SdrObject* pObj = mpDrawView->GetMarkedObjectList().GetMark( 0 )->GetMarkedSdrObj();
 907             if( pObj->GetObjInventor() == SdrInventor)
 908             {
 909                 SfxItemSet aEditAttr( GetDoc()->GetPool() );
 910                 mpDrawView->GetAttributes( aEditAttr );
 911                 if( aEditAttr.GetItemState( EE_PARA_TABS ) >= SfxItemState::DEFAULT )
 912                 {
 913                     const SvxTabStopItem& rItem = static_cast<const SvxTabStopItem&>( aEditAttr.Get( EE_PARA_TABS ) );
 914                     rSet.Put( rItem );
 915
 916                     const SvxLRSpaceItem& rLRSpaceItem = static_cast<const SvxLRSpaceItem&>( aEditAttr.Get( EE_PARA_LRSPACE ) );
 917                     sal_uInt16 nId = SID_ATTR_PARA_LRSPACE;
 918                     SvxLRSpaceItem aLRSpaceItem( rLRSpaceItem.GetLeft(),
 919                             rLRSpaceItem.GetRight(), rLRSpaceItem.GetTextLeft(),
 920                             rLRSpaceItem.GetTextFirstLineOfst(), nId );
 921
 922                     const sal_Int16 nOutlineLevel = static_cast<const SfxInt16Item&>( aEditAttr.Get( EE_PARA_OUTLLEVEL )).GetValue();
 923                     const SvxNumBulletItem& rNumBulletItem = static_cast<const SvxNumBulletItem&>( aEditAttr.Get( EE_PARA_NUMBULLET ) );
 924                     if( nOutlineLevel != -1 &&
 925                         rNumBulletItem.GetNumRule() &&
 926                         rNumBulletItem.GetNumRule()->GetLevelCount() > nOutlineLevel )
 927                     {
 928                         const SvxNumberFormat& rFormat = rNumBulletItem.GetNumRule()->GetLevel(nOutlineLevel);
 929                         aLRSpaceItem.SetTextLeft(rFormat.GetAbsLSpace() + rLRSpaceItem.GetTextLeft());
 930                         aLRSpaceItem.SetTextFirstLineOfst(
 931                             rLRSpaceItem.GetTextFirstLineOfst() + rFormat.GetFirstLineOffset()
 932                             - rFormat.GetCharTextDistance());
 933                     }
 934
 935                     rSet.Put( aLRSpaceItem );
 936
 937                     Point aPos( aPagePos + maMarkRect.TopLeft() );
 938
 939                     if ( aEditAttr.GetItemState( SDRATTR_TEXT_LEFTDIST ) == SfxItemState::SET )
 940                     {
 941                         const SdrMetricItem& rTLDItem = static_cast<const SdrMetricItem&>(
 942                                                               aEditAttr.Get( SDRATTR_TEXT_LEFTDIST ));
 943                         long nLD = rTLDItem.GetValue();
 944                         aPos.X() += nLD;
 945                     }
 946
 947                     aPointItem.SetValue( aPos );
 948
 949                     aLRSpace.SetLeft( aPagePos.X() + maMarkRect.Left() );
 950
 951                     if ( aEditAttr.GetItemState( SDRATTR_TEXT_LEFTDIST ) == SfxItemState::SET )
 952                     {
 953                         const SdrMetricItem& rTLDItem = static_cast<const SdrMetricItem&>(
 954                                                               aEditAttr.Get( SDRATTR_TEXT_LEFTDIST ));
 955                         long nLD = rTLDItem.GetValue();
 956                         aLRSpace.SetLeft( aLRSpace.GetLeft() + nLD );
 957                     }
 958
 959                     aLRSpace.SetRight( aRect.Right() + aPageSize.Width() - maMarkRect.Right() );
 960                     aULSpace.SetUpper( aPagePos.Y() + maMarkRect.Top() );
 961                     aULSpace.SetLower( aRect.Bottom() + aPageSize.Height() - maMarkRect.Bottom() );
 962
 963                     rSet.DisableItem( SID_RULER_OBJECT );
 964
 965                     // lock page margins
 966                     aProtect.SetSizeProtect( true );
 967                     aProtect.SetPosProtect( true );
 968                 }
 969
 970                 if( aEditAttr.GetItemState( EE_PARA_WRITINGDIR ) >= SfxItemState::DEFAULT )
 971                 {
 972                     const SvxFrameDirectionItem& rItem = static_cast<const SvxFrameDirectionItem&>( aEditAttr.Get( EE_PARA_WRITINGDIR ) );
 973                     rSet.Put(SfxBoolItem(SID_RULER_TEXT_RIGHT_TO_LEFT, rItem.GetValue() == ::com::sun::star::text::WritingMode_RL_TB));
 974                 }
 975             }
 976         }
 977         else
 978         {
 979             rSet.DisableItem( EE_PARA_TABS );
 980             rSet.DisableItem( SID_RULER_TEXT_RIGHT_TO_LEFT );
 981
 982             if( mpDrawView->IsResizeAllowed(true) )
 983             {
 984                 Rectangle aResizeRect( maMarkRect );
 985
 986                 aResizeRect.SetPos(aResizeRect.TopLeft() + aPagePos);
 987                 SvxObjectItem aObjItem(aResizeRect.Left(), aResizeRect.Right(),
 988                                        aResizeRect.Top(), aResizeRect.Bottom());
 989                 rSet.Put(aObjItem);
 990                 rSet.DisableItem( EE_PARA_TABS );
 991             }
 992             else
 993             {
 994                 rSet.DisableItem( SID_RULER_OBJECT );
 995             }
 996         }
 997     }
 998     else
 999     {
1000         rSet.DisableItem( SID_RULER_OBJECT );
1001         rSet.DisableItem( EE_PARA_TABS );
1002     }
1003
1004     rSet.Put( aLRSpace );
1005     rSet.Put( aULSpace );
1006
1007     rSet.Put( aPointItem );
1008     rSet.Put( aProtect );
1009 }
1010
1011 void  DrawViewShell::ExecStatusBar(SfxRequest& rReq)
1012 {
1013     // nothing is executed during a slide show!
1014     if(HasCurrentFunction(SID_PRESENTATION))
1015         return;
1016
1017     CheckLineTo (rReq);
1018
1019     switch ( rReq.GetSlot() )
1020     {
1021         case SID_ATTR_SIZE:
1022         {
1023             GetViewFrame()->GetDispatcher()->Execute( SID_ATTR_TRANSFORM, SfxCallMode::ASYNCHRON );
1024         }
1025         break;
1026
1027         case SID_STATUS_LAYOUT:
1028         {
1029             GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION_LAYOUT, SfxCallMode::ASYNCHRON );
1030         }
1031         break;
1032     }
1033 }
1034
1035 /**
1036  * set state of snap object entries in popup
1037  */
1038 void  DrawViewShell::GetSnapItemState( SfxItemSet &rSet )
1039 {
1040     SdrPageView* pPV;
1041     Point   aMPos = GetActiveWindow()->PixelToLogic(maMousePos);
1042     sal_uInt16  nHitLog = (sal_uInt16) GetActiveWindow()->PixelToLogic(
1043         Size(FuPoor::HITPIX,0)).Width();
1044     sal_uInt16  nHelpLine;
1045
1046     if ( mpDrawView->PickHelpLine(aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) )
1047     {
1048         const SdrHelpLine& rHelpLine = (pPV->GetHelpLines())[nHelpLine];
1049
1050         if ( rHelpLine.GetKind() == SDRHELPLINE_POINT )
1051         {
1052             rSet.Put( SfxStringItem( SID_SET_SNAPITEM,
1053                                 SD_RESSTR( STR_POPUP_EDIT_SNAPPOINT)) );
1054             rSet.Put( SfxStringItem( SID_DELETE_SNAPITEM,
1055                                 SD_RESSTR( STR_POPUP_DELETE_SNAPPOINT)) );
1056         }
1057         else
1058         {
1059             rSet.Put( SfxStringItem( SID_SET_SNAPITEM,
1060                                 SD_RESSTR( STR_POPUP_EDIT_SNAPLINE)) );
1061             rSet.Put( SfxStringItem( SID_DELETE_SNAPITEM,
1062                                 SD_RESSTR( STR_POPUP_DELETE_SNAPLINE)) );
1063         }
1064     }
1065 }
1066
1067 } // end of namespace sd
1068
1069 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */