sc/source/ui/drawfunc/fuconstr.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 <editeng/outliner.hxx>
  21 #include <editeng/outlobj.hxx>
  22 #include <svx/svdotext.hxx>
  23 #include <svx/svdouno.hxx>
  24 #include <sfx2/dispatch.hxx>
  25
  26 #include "fuconstr.hxx"
  27 #include "fudraw.hxx"
  28 #include "tabvwsh.hxx"
  29 #include "futext.hxx"
  30 #include "sc.hrc"
  31 #include "drawview.hxx"
  32 #include "document.hxx"
  33 #include "gridwin.hxx"
  34
  35 //  Maximal erlaubte Mausbewegung um noch Drag&Drop zu starten
  36 //! fusel,fuconstr,futext - zusammenfassen!
  37 #define SC_MAXDRAGMOVE  3
  38
  39 /*************************************************************************
  40 |*
  41 |* Konstruktor
  42 |*
  43 \************************************************************************/
  44
  45 FuConstruct::FuConstruct(ScTabViewShell* pViewSh, vcl::Window* pWin, ScDrawView* pViewP,
  46                    SdrModel* pDoc, SfxRequest& rReq) :
  47     FuDraw(pViewSh, pWin, pViewP, pDoc, rReq)
  48 {
  49 }
  50
  51 /*************************************************************************
  52 |*
  53 |* Destruktor
  54 |*
  55 \************************************************************************/
  56
  57 FuConstruct::~FuConstruct()
  58 {
  59 }
  60
  61 sal_uInt8 FuConstruct::Command(const CommandEvent& rCEvt)
  62 {
  63     return FuDraw::Command( rCEvt );
  64 }
  65
  66 // Calculate and return offset at current zoom. rInOutPos is adjusted by
  67 // the calculated offset. rInOutPos now points to the position than when
  68 // scaled to 100% actually would be at the position you see at the current zoom
  69 // ( relative to the grid ) note: units are expected to be in 100th mm
  70 Point FuConstruct::CurrentGridSyncOffsetAndPos( Point& rInOutPos )
  71 {
  72     Point aRetGridOff;
  73     ScViewData& rViewData = pViewShell->GetViewData();
  74     ScDocument* pDoc = rViewData.GetDocument();
  75     if ( pDoc )
  76     {
  77         // rInOutPos mightn't be where you think it is if there is zoom
  78         // involved. Lets calculate where aPos would be at 100% zoom
  79         // that's the actual correct position for the object ( when you
  80         // restore the zoom.
  81         bool bNegative = pDoc->IsNegativePage(pView->GetTab());
  82         Rectangle aObjRect( rInOutPos, rInOutPos );
  83         ScRange aRange = pDoc->GetRange( pView->GetTab(), aObjRect );
  84         ScAddress aOldStt = aRange.aStart;
  85         Point aOldPos( pDoc->GetColOffset( aOldStt.Col(), aOldStt.Tab()  ), pDoc->GetRowOffset( aOldStt.Row(), aOldStt.Tab() ) );
  86         aOldPos.X() = sc::TwipsToHMM( aOldPos.X() );
  87         aOldPos.Y() = sc::TwipsToHMM( aOldPos.Y() );
  88         ScSplitPos eWhich = rViewData.GetActivePart();
  89         ScGridWindow* pGridWin = rViewData.GetActiveWin();
  90         // and equiv screen pos
  91         Point aScreenPos =  pViewShell->GetViewData().GetScrPos( aOldStt.Col(), aOldStt.Row(), eWhich, true );
  92         MapMode aDrawMode = pGridWin->GetDrawMapMode();
  93         Point aCurPosHmm = pGridWin->PixelToLogic(aScreenPos, aDrawMode );
  94         Point aOff = ( rInOutPos - aCurPosHmm );
  95         rInOutPos = aOldPos + aOff;
  96         aRetGridOff = aCurPosHmm - aOldPos;
  97         // fdo#64011 fix the X position when the sheet are RTL
  98         if ( bNegative )
  99         {
 100             aRetGridOff.setX( aCurPosHmm.getX() + aOldPos.getX() );
 101             rInOutPos.setX( aOff.getX() - aOldPos.getX() );
 102         }
 103     }
 104     return aRetGridOff;
 105 }
 106 /*************************************************************************
 107 |*
 108 |* MouseButtonDown-event
 109 |*
 110 \************************************************************************/
 111
 112 bool FuConstruct::MouseButtonDown(const MouseEvent& rMEvt)
 113 {
 114     // remember button state for creation of own MouseEvents
 115     SetMouseButtonCode(rMEvt.GetButtons());
 116
 117     bool bReturn = FuDraw::MouseButtonDown(rMEvt);
 118
 119     if ( pView->IsAction() )
 120     {
 121         if ( rMEvt.IsRight() )
 122             pView->BckAction();
 123         return true;
 124     }
 125
 126     aDragTimer.Start();
 127
 128     aMDPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 129
 130     if ( rMEvt.IsLeft() )
 131     {
 132         pWindow->CaptureMouse();
 133
 134         SdrHdl* pHdl = pView->PickHandle(aMDPos);
 135
 136         if ( pHdl != NULL || pView->IsMarkedHit(aMDPos) )
 137         {
 138             pView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, 1);
 139             bReturn = true;
 140         }
 141         else if ( pView->AreObjectsMarked() )
 142         {
 143             pView->UnmarkAll();
 144             bReturn = true;
 145         }
 146     }
 147
 148     bIsInDragMode = false;
 149
 150     return bReturn;
 151 }
 152
 153 /*************************************************************************
 154 |*
 155 |* MouseMove-event
 156 |*
 157 \************************************************************************/
 158
 159 bool FuConstruct::MouseMove(const MouseEvent& rMEvt)
 160 {
 161     FuDraw::MouseMove(rMEvt);
 162
 163     if (aDragTimer.IsActive() )
 164     {
 165         Point aOldPixel = pWindow->LogicToPixel( aMDPos );
 166         Point aNewPixel = rMEvt.GetPosPixel();
 167         if ( std::abs( aOldPixel.X() - aNewPixel.X() ) > SC_MAXDRAGMOVE ||
 168              std::abs( aOldPixel.Y() - aNewPixel.Y() ) > SC_MAXDRAGMOVE )
 169             aDragTimer.Stop();
 170     }
 171
 172     Point aPix(rMEvt.GetPosPixel());
 173     Point aPnt( pWindow->PixelToLogic(aPix) );
 174
 175     // if object is being created then more than likely the mouse
 176     // position has been 'adjusted' for the current zoom, need to
 177     // restore the mouse position here to ensure resize works as expected
 178     if ( pView->GetCreateObj() )
 179         aPnt -= pView->GetCreateObj()->GetGridOffset();
 180
 181     if ( pView->IsAction() )
 182     {
 183         ForceScroll(aPix);
 184         pView->MovAction(aPnt);
 185     }
 186     else
 187     {
 188         SdrHdl* pHdl=pView->PickHandle(aPnt);
 189
 190         if ( pHdl != NULL )
 191         {
 192             pViewShell->SetActivePointer(pHdl->GetPointer());
 193         }
 194         else if ( pView->IsMarkedHit(aPnt) )
 195         {
 196             pViewShell->SetActivePointer(Pointer(PointerStyle::Move));
 197         }
 198         else
 199         {
 200             pViewShell->SetActivePointer( aNewPointer );
 201         }
 202     }
 203     return true;
 204 }
 205
 206 /*************************************************************************
 207 |*
 208 |* MouseButtonUp-event
 209 |*
 210 \************************************************************************/
 211
 212 bool FuConstruct::MouseButtonUp(const MouseEvent& rMEvt)
 213 {
 214     // remember button state for creation of own MouseEvents
 215     SetMouseButtonCode(rMEvt.GetButtons());
 216
 217     bool bReturn = SimpleMouseButtonUp( rMEvt );
 218
 219     //      Doppelklick auf Textobjekt? (->fusel)
 220
 221     sal_uInt16 nClicks = rMEvt.GetClicks();
 222     if ( nClicks == 2 && rMEvt.IsLeft() )
 223     {
 224         if ( pView->AreObjectsMarked() )
 225         {
 226             const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 227             if (rMarkList.GetMarkCount() == 1)
 228             {
 229                 SdrMark* pMark = rMarkList.GetMark(0);
 230                 SdrObject* pObj = pMark->GetMarkedSdrObj();
 231
 232                 //  bei Uno-Controls nicht in Textmodus
 233                 if ( pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) )
 234                 {
 235                     OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
 236                     bool bVertical = ( pOPO && pOPO->IsVertical() );
 237                     sal_uInt16 nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
 238
 239                     pViewShell->GetViewData().GetDispatcher().
 240                         Execute(nTextSlotId, SfxCallMode::SLOT | SfxCallMode::RECORD);
 241
 242                     // jetzt den erzeugten FuText holen und in den EditModus setzen
 243                     FuPoor* pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
 244                     if ( pPoor && pPoor->GetSlotID() == nTextSlotId )    // hat keine RTTI
 245                     {
 246                         FuText* pText = static_cast<FuText*>(pPoor);
 247                         Point aMousePixel = rMEvt.GetPosPixel();
 248                         pText->SetInEditMode( pObj, &aMousePixel );
 249                     }
 250                     bReturn = true;
 251                 }
 252             }
 253         }
 254     }
 255
 256     FuDraw::MouseButtonUp(rMEvt);
 257
 258     return bReturn;
 259 }
 260
 261 //      SimpleMouseButtonUp - ohne Test auf Doppelklick
 262
 263 bool FuConstruct::SimpleMouseButtonUp(const MouseEvent& rMEvt)
 264 {
 265     bool    bReturn = true;
 266
 267     if (aDragTimer.IsActive() )
 268     {
 269         aDragTimer.Stop();
 270     }
 271
 272     Point   aPnt( pWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
 273
 274     if ( pView->IsDragObj() )
 275          pView->EndDragObj( rMEvt.IsMod1() );
 276
 277     else if ( pView->IsMarkObj() )
 278         pView->EndMarkObj();
 279
 280     else bReturn = false;
 281
 282     if ( !pView->IsAction() )
 283     {
 284         pWindow->ReleaseMouse();
 285
 286         if ( !pView->AreObjectsMarked() && rMEvt.GetClicks() < 2 )
 287         {
 288             pView->MarkObj(aPnt, -2, false, rMEvt.IsMod1());
 289
 290             SfxDispatcher& rDisp = pViewShell->GetViewData().GetDispatcher();
 291             if ( pView->AreObjectsMarked() )
 292                 rDisp.Execute(SID_OBJECT_SELECT, SfxCallMode::SLOT | SfxCallMode::RECORD);
 293             else
 294                 rDisp.Execute(aSfxRequest.GetSlot(), SfxCallMode::SLOT | SfxCallMode::RECORD);
 295         }
 296     }
 297
 298     return bReturn;
 299 }
 300
 301 /*************************************************************************
 302 |*
 303 |* Tastaturereignisse bearbeiten
 304 |*
 305 |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
 306 |* FALSE.
 307 |*
 308 \************************************************************************/
 309
 310 bool FuConstruct::KeyInput(const KeyEvent& rKEvt)
 311 {
 312     bool bReturn = false;
 313
 314     switch ( rKEvt.GetKeyCode().GetCode() )
 315     {
 316         case KEY_ESCAPE:
 317             if ( pView->IsAction() )
 318             {
 319                 pView->BrkAction();
 320                 pWindow->ReleaseMouse();
 321                 bReturn = true;
 322             }
 323             else                            // Zeichenmodus beenden
 324             {
 325                 pViewShell->GetViewData().GetDispatcher().
 326                     Execute(aSfxRequest.GetSlot(), SfxCallMode::SLOT | SfxCallMode::RECORD);
 327             }
 328             break;
 329
 330         case KEY_DELETE:
 331             pView->DeleteMarked();
 332             bReturn = true;
 333             break;
 334     }
 335
 336     if ( !bReturn )
 337     {
 338         bReturn = FuDraw::KeyInput(rKEvt);
 339     }
 340
 341     return bReturn;
 342 }
 343
 344 /*************************************************************************
 345 |*
 346 |* Function aktivieren
 347 |*
 348 \************************************************************************/
 349
 350 void FuConstruct::Activate()
 351 {
 352     FuDraw::Activate();
 353 }
 354
 355 /*************************************************************************
 356 |*
 357 |* Function deaktivieren
 358 |*
 359 \************************************************************************/
 360
 361 void FuConstruct::Deactivate()
 362 {
 363     FuDraw::Deactivate();
 364 }
 365
 366 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */