sc/source/ui/view/gridwin3.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "scitems.hxx"
  22 #include <editeng/eeitem.hxx>
  23
  24 #include <svx/svdoutl.hxx>
  25 #include <svx/svdotext.hxx>
  26 #include <svx/svdpagv.hxx>
  27 #include <editeng/sizeitem.hxx>
  28 #include <sfx2/bindings.hxx>
  29 #include <svl/ptitem.hxx>
  30
  31 #include "tabvwsh.hxx"
  32 #include "gridwin.hxx"
  33 #include "dbfunc.hxx"
  34 #include "viewdata.hxx"
  35 #include "output.hxx"
  36 #include "drawview.hxx"
  37 #include "fupoor.hxx"
  38
  39 #include "drawutil.hxx"
  40 #include "document.hxx"
  41 #include "drwlayer.hxx"
  42 #include <vcl/svapp.hxx>
  43 #include "userdat.hxx"
  44 #include "unitconv.hxx"
  45 #include <svx/svdpage.hxx>
  46
  47
  48 bool ScGridWindow::DrawMouseButtonDown(const MouseEvent& rMEvt)
  49 {
  50     bool bRet = false;
  51     FuPoor* pDraw = pViewData->GetView()->GetDrawFuncPtr();
  52     if (pDraw && !pViewData->IsRefMode())
  53     {
  54         pDraw->SetWindow( this );
  55         Point aLogicPos = PixelToLogic(rMEvt.GetPosPixel());
  56         if ( pDraw->IsDetectiveHit( aLogicPos ) )
  57         {
  58             //  auf Detektiv-Pfeilen gar nichts (Doppelklick wird bei ButtonUp ausgewertet)
  59             bRet = true;
  60         }
  61         else
  62         {
  63             bRet = pDraw->MouseButtonDown( rMEvt );
  64             if ( bRet )
  65                 UpdateStatusPosSize();
  66         }
  67     }
  68
  69     //  bei rechter Taste Draw-Aktion abbrechen
  70
  71     ScDrawView* pDrView = pViewData->GetScDrawView();
  72     if ( pDrView && !rMEvt.IsLeft() && !bRet )
  73     {
  74         pDrView->BrkAction();
  75         bRet = true;
  76     }
  77     return bRet;
  78 }
  79
  80 bool ScGridWindow::DrawMouseButtonUp(const MouseEvent& rMEvt)
  81 {
  82     ScViewFunc* pView = pViewData->GetView();
  83     bool bRet = false;
  84     FuPoor* pDraw = pView->GetDrawFuncPtr();
  85     if (pDraw && !pViewData->IsRefMode())
  86     {
  87         pDraw->SetWindow( this );
  88         bRet = pDraw->MouseButtonUp( rMEvt );
  89
  90         // execute "format paint brush" for drawing objects
  91         SfxItemSet* pDrawBrush = pView->GetDrawBrushSet();
  92         if ( pDrawBrush )
  93         {
  94             ScDrawView* pDrView = pViewData->GetScDrawView();
  95             if ( pDrView )
  96             {
  97                 bool bReplaceAll = true;
  98                 pDrView->SetAttrToMarked(*pDrawBrush, bReplaceAll);
  99             }
 100
 101             if ( !pView->IsPaintBrushLocked() )
 102                 pView->ResetBrushDocument();        // end paint brush mode if not locked
 103         }
 104     }
 105
 106     return bRet;
 107 }
 108
 109 bool ScGridWindow::DrawMouseMove(const MouseEvent& rMEvt)
 110 {
 111     FuPoor* pDraw = pViewData->GetView()->GetDrawFuncPtr();
 112     if (pDraw && !pViewData->IsRefMode())
 113     {
 114         pDraw->SetWindow( this );
 115         bool bRet = pDraw->MouseMove( rMEvt );
 116         if ( bRet )
 117             UpdateStatusPosSize();
 118         return bRet;
 119     }
 120     else
 121     {
 122         SetPointer( Pointer( POINTER_ARROW ) );
 123         return false;
 124     }
 125 }
 126
 127 void ScGridWindow::DrawEndAction()
 128 {
 129     ScDrawView* pDrView = pViewData->GetScDrawView();
 130     if ( pDrView && pDrView->IsAction() )
 131         pDrView->BrkAction();
 132
 133     FuPoor* pDraw = pViewData->GetView()->GetDrawFuncPtr();
 134     if (pDraw)
 135         pDraw->StopDragTimer();
 136
 137     //  ReleaseMouse beim Aufruf
 138 }
 139
 140 bool ScGridWindow::DrawCommand(const CommandEvent& rCEvt)
 141 {
 142     ScDrawView* pDrView = pViewData->GetScDrawView();
 143     FuPoor* pDraw = pViewData->GetView()->GetDrawFuncPtr();
 144     if (pDrView && pDraw && !pViewData->IsRefMode())
 145     {
 146         pDraw->SetWindow( this );
 147         sal_uInt8 nUsed = pDraw->Command( rCEvt );
 148         if( nUsed == SC_CMD_USED )
 149             nButtonDown = 0;                    // MouseButtonUp wird verschluckt...
 150         if( nUsed || pDrView->IsAction() )
 151             return true;
 152     }
 153
 154     return false;
 155 }
 156
 157 bool ScGridWindow::DrawKeyInput(const KeyEvent& rKEvt)
 158 {
 159     ScDrawView* pDrView = pViewData->GetScDrawView();
 160     FuPoor* pDraw = pViewData->GetView()->GetDrawFuncPtr();
 161     if (pDrView && pDraw && !pViewData->IsRefMode())
 162     {
 163         pDraw->SetWindow( this );
 164         bool bOldMarked = pDrView->AreObjectsMarked();
 165         if (pDraw->KeyInput( rKEvt ))
 166         {
 167             bool bLeaveDraw = false;
 168             bool bUsed = true;
 169             bool bNewMarked = pDrView->AreObjectsMarked();
 170             if ( !pViewData->GetView()->IsDrawSelMode() )
 171                 if ( !bNewMarked )
 172                 {
 173                     pViewData->GetViewShell()->SetDrawShell( false );
 174                     bLeaveDraw = true;
 175                     if ( !bOldMarked &&
 176                         rKEvt.GetKeyCode().GetCode() == KEY_DELETE )
 177                         bUsed = false;                  // nichts geloescht
 178                     if(bOldMarked)
 179                         GetFocus();
 180                 }
 181             if (!bLeaveDraw)
 182                 UpdateStatusPosSize();      // for moving/resizing etc. by keyboard
 183             return bUsed;
 184         }
 185     }
 186
 187     return false;
 188 }
 189
 190 void ScGridWindow::DrawRedraw( ScOutputData& rOutputData, ScUpdateMode eMode, sal_uLong nLayer )
 191 {
 192     // #109985#
 193     const ScViewOptions& rOpts = pViewData->GetOptions();
 194
 195     // use new flags at SdrPaintView for hiding objects
 196     const bool bDrawOle(VOBJ_MODE_SHOW == rOpts.GetObjMode(VOBJ_TYPE_OLE));
 197     const bool bDrawChart(VOBJ_MODE_SHOW == rOpts.GetObjMode(VOBJ_TYPE_CHART));
 198     const bool bDrawDraw(VOBJ_MODE_SHOW == rOpts.GetObjMode(VOBJ_TYPE_DRAW));
 199
 200     if(bDrawOle || bDrawChart || bDrawDraw)
 201     {
 202         ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 203
 204         if(pDrView)
 205         {
 206             pDrView->setHideOle(!bDrawOle);
 207             pDrView->setHideChart(!bDrawChart);
 208             pDrView->setHideDraw(!bDrawDraw);
 209             pDrView->setHideFormControl(!bDrawDraw);
 210         }
 211
 212         if(SC_UPDATE_CHANGED == eMode)
 213         {
 214             rOutputData.DrawingSingle((sal_uInt16)nLayer);
 215         }
 216         else
 217         {
 218             rOutputData.DrawSelectiveObjects((sal_uInt16)nLayer);
 219         }
 220     }
 221 }
 222
 223 void ScGridWindow::DrawSdrGrid( const Rectangle& rDrawingRect, OutputDevice* pContentDev )
 224 {
 225     //  Draw-Gitterlinien
 226
 227     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 228     if ( pDrView && pDrView->IsGridVisible() )
 229     {
 230         SdrPageView* pPV = pDrView->GetSdrPageView();
 231         OSL_ENSURE(pPV, "keine PageView");
 232         if (pPV)
 233         {
 234             pContentDev->SetLineColor(COL_GRAY);
 235
 236             pPV->DrawPageViewGrid( *pContentDev, rDrawingRect );
 237         }
 238     }
 239 }
 240
 241 MapMode ScGridWindow::GetDrawMapMode( bool bForce )
 242 {
 243     ScDocument* pDoc = pViewData->GetDocument();
 244     SCTAB nTab = pViewData->GetTabNo();
 245     bool bNegativePage = pDoc->IsNegativePage( nTab );
 246
 247     MapMode aDrawMode = pViewData->GetLogicMode();
 248
 249     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 250     if ( pDrView || bForce )
 251     {
 252         Fraction aScaleX;
 253         Fraction aScaleY;
 254         if (pDrView)
 255             pDrView->GetScale( aScaleX, aScaleY );
 256         else
 257         {
 258             SCCOL nEndCol = 0;
 259             SCROW nEndRow = 0;
 260             pDoc->GetTableArea( nTab, nEndCol, nEndRow );
 261             if (nEndCol<20) nEndCol = 20;
 262             if (nEndRow<20) nEndRow = 1000;
 263             ScDrawUtil::CalcScale( pDoc, nTab, 0,0, nEndCol,nEndRow, this,
 264                                     pViewData->GetZoomX(),pViewData->GetZoomY(),
 265                                     pViewData->GetPPTX(),pViewData->GetPPTY(),
 266                                     aScaleX,aScaleY );
 267         }
 268         aDrawMode.SetScaleX(aScaleX);
 269         aDrawMode.SetScaleY(aScaleY);
 270     }
 271     aDrawMode.SetOrigin(Point());
 272     Point aStartPos = pViewData->GetPixPos(eWhich);
 273     if ( bNegativePage )
 274     {
 275         //  RTL uses negative positions for drawing objects
 276         aStartPos.X() = -aStartPos.X() + GetOutputSizePixel().Width() - 1;
 277     }
 278     aDrawMode.SetOrigin( PixelToLogic( aStartPos, aDrawMode ) );
 279
 280     return aDrawMode;
 281 }
 282
 283 void ScGridWindow::DrawAfterScroll()
 284 {
 285     Update();       // immer, damit das Verhalten mit/ohne DrawingLayer gleich ist
 286
 287     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 288     if (pDrView)
 289     {
 290         OutlinerView* pOlView = pDrView->GetTextEditOutlinerView();
 291         if (pOlView && pOlView->GetWindow() == this)
 292             pOlView->ShowCursor(false);                 // ist beim Scrollen weggekommen
 293     }
 294 }
 295
 296 void ScGridWindow::CreateAnchorHandle(SdrHdlList& rHdl, const ScAddress& rAddress)
 297 {
 298     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 299     if (pDrView)
 300     {
 301         const ScViewOptions& rOpts = pViewData->GetOptions();
 302         if(rOpts.GetOption( VOPT_ANCHOR ))
 303         {
 304             bool bNegativePage = pViewData->GetDocument()->IsNegativePage( pViewData->GetTabNo() );
 305             Point aPos = pViewData->GetScrPos( rAddress.Col(), rAddress.Row(), eWhich, true );
 306             aPos = PixelToLogic(aPos);
 307             rHdl.AddHdl(new SdrHdl(aPos, bNegativePage ? HDL_ANCHOR_TR : HDL_ANCHOR));
 308         }
 309     }
 310 }
 311
 312 SdrObject* ScGridWindow::GetEditObject()
 313 {
 314     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 315     if (pDrView)
 316     {
 317         OutlinerView* pOlView = pDrView->GetTextEditOutlinerView();
 318         if (pOlView && pOlView->GetWindow() == this)
 319             return pDrView->GetTextEditObject();
 320     }
 321
 322     return NULL;
 323 }
 324
 325 void ScGridWindow::UpdateStatusPosSize()
 326 {
 327     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 328     if (!pDrView)
 329         return;         // shouldn't be called in that case
 330
 331     SdrPageView* pPV = pDrView->GetSdrPageView();
 332     if (!pPV)
 333         return;         // shouldn't be called in that case either
 334
 335     SfxItemSet aSet(pViewData->GetViewShell()->GetPool(), SID_ATTR_POSITION, SID_ATTR_SIZE);
 336
 337     //  Fill items for position and size:
 338     //  show action rectangle during action,
 339     //  position and size of selected object(s) if something is selected,
 340     //  mouse position otherwise
 341
 342     bool bActionItem = false;
 343     if ( pDrView->IsAction() )              // action rectangle
 344     {
 345         Rectangle aRect;
 346         pDrView->TakeActionRect( aRect );
 347         if ( !aRect.IsEmpty() )
 348         {
 349             // mouse position will have been adjusted for offset
 350             // at current position and zoom, restore that adjustment here
 351             // so status shows correct value
 352             aRect -= pDrView->GetGridOffset();
 353             pPV->LogicToPagePos(aRect);
 354             aSet.Put( SfxPointItem( SID_ATTR_POSITION, aRect.TopLeft() ) );
 355             aSet.Put( SvxSizeItem( SID_ATTR_SIZE,
 356                     Size( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() ) ) );
 357             bActionItem = true;
 358         }
 359     }
 360     if ( !bActionItem )
 361     {
 362         if ( pDrView->AreObjectsMarked() )      // selected objects
 363         {
 364             Rectangle aRect = pDrView->GetAllMarkedRect();
 365             // mouse position will have been adjusted for offset
 366             // at current position and zoom, restore that adjustment here
 367             // so status shows correct value
 368             aRect -=  pDrView->GetGridOffset();
 369             pPV->LogicToPagePos(aRect);
 370             aSet.Put( SfxPointItem( SID_ATTR_POSITION, aRect.TopLeft() ) );
 371             aSet.Put( SvxSizeItem( SID_ATTR_SIZE,
 372                     Size( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() ) ) );
 373         }
 374         else                                // mouse position
 375         {
 376             Point aPos = PixelToLogic(aCurMousePos);
 377             pPV->LogicToPagePos(aPos);
 378             aSet.Put( SfxPointItem( SID_ATTR_POSITION, aPos ) );
 379             aSet.Put( SvxSizeItem( SID_ATTR_SIZE, Size( 0, 0 ) ) );
 380         }
 381     }
 382
 383     pViewData->GetBindings().SetState(aSet);
 384 }
 385
 386 bool ScGridWindow::DrawHasMarkedObj()
 387 {
 388     ScDrawView* p = pViewData->GetScDrawView();
 389     return p && p->AreObjectsMarked();
 390 }
 391
 392 void ScGridWindow::DrawMarkDropObj( SdrObject* pObj )
 393 {
 394     ScDrawView* pDrView = pViewData->GetView()->GetScDrawView();
 395     if (pDrView)
 396         pDrView->MarkDropObj(pObj);
 397 }
 398
 399 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */