blob: a1cb5ce527be3a4a788b9ac563c07eea8de6a13c [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include "fuediglu.hxx"
#include <svl/eitem.hxx>
#include <svx/dialogs.hrc>
#include <sfx2/request.hxx>
#include "app.hrc"
#include "strings.hrc"
#include "res_bmp.hrc"
#ifndef SD_WINDOW_SHELL_HXX
#include "Window.hxx"
#endif
#include "drawdoc.hxx"
#ifndef SD_FRAMW_VIEW_HXX
#include "FrameView.hxx"
#endif
#include "View.hxx"
#include "ViewShell.hxx"
#include "ViewShellBase.hxx"
#include "ToolBarManager.hxx"
namespace sd {
/*************************************************************************
|*
|* Konstruktor
|*
\************************************************************************/
FuEditGluePoints::FuEditGluePoints (
ViewShell* pViewSh,
::sd::Window* pWin,
::sd::View* pView,
SdDrawDocument* pDoc,
SfxRequest& rReq)
: FuDraw(pViewSh, pWin, pView, pDoc, rReq),
meLastSdrViewEditMode(SDREDITMODE_EDIT),
//Solution: Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
//and SHIFT+ENTER key to decide the postion and draw the new insert point
maOldPoint(0, 0),
mbBeginInsertPoint(false)
{
}
FunctionReference FuEditGluePoints::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq, bool bPermanent )
{
FuEditGluePoints* pFunc;
FunctionReference xFunc( pFunc = new FuEditGluePoints( pViewSh, pWin, pView, pDoc, rReq ) );
xFunc->DoExecute(rReq);
pFunc->SetPermanent( bPermanent );
return xFunc;
}
void FuEditGluePoints::DoExecute( SfxRequest& rReq )
{
FuDraw::DoExecute( rReq );
mpView->SetInsGluePointMode(false);
mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBar(
ToolBarManager::TBG_FUNCTION,
ToolBarManager::msGluePointsToolBar);
}
/*************************************************************************
|*
|* Destruktor
|*
\************************************************************************/
FuEditGluePoints::~FuEditGluePoints()
{
mpView->BrkAction();
mpView->MarkGluePoints(0, true);
mpView->SetInsGluePointMode(false);
}
/*************************************************************************
|*
|* MouseButtonDown-event
|*
\************************************************************************/
bool FuEditGluePoints::MouseButtonDown(const MouseEvent& rMEvt)
{
mpView->SetActualOutDev( mpWindow );
bool bReturn = FuDraw::MouseButtonDown(rMEvt);
if (mpView->IsAction())
{
if (rMEvt.IsRight())
mpView->BckAction();
return true;
}
if (rMEvt.IsLeft())
{
bReturn = true;
mpWindow->CaptureMouse();
SdrViewEvent aVEvt;
SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
if (eHit == SDRHIT_HANDLE)
{
/******************************************************************
* Handle draggen
******************************************************************/
const SdrHdl* pHdl = aVEvt.mpHdl;
if (mpView->IsGluePointMarked(*aVEvt.mpObj, aVEvt.mnGlueId) && rMEvt.IsShift())
{
mpView->MarkGluePoint(aVEvt.mpObj, aVEvt.mnGlueId, true); // unmark
pHdl = NULL;
}
if (pHdl)
{
// Handle draggen
mpView->BegDragObj(aMDPos, aVEvt.mpHdl, mpView->getMinMovLog());
}
}
else if (eHit == SDRHIT_MARKEDOBJECT && mpView->IsInsGluePointMode())
{
/******************************************************************
* Klebepunkt einfuegen
******************************************************************/
mpView->BegInsGluePoint(aMDPos);
}
else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
{
/******************************************************************
* Klebepunkt selektieren
******************************************************************/
if (!rMEvt.IsShift())
mpView->MarkGluePoints(0, true);
mpView->BegMarkGluePoints(aMDPos);
}
else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
{
/******************************************************************
* Objekt verschieben
******************************************************************/
mpView->BegDragObj(aMDPos, NULL, mpView->getMinMovLog());
}
else if (eHit == SDRHIT_GLUEPOINT)
{
/******************************************************************
* Klebepunkt selektieren
******************************************************************/
if (!rMEvt.IsShift())
mpView->MarkGluePoints(0, true);
mpView->MarkGluePoint(aVEvt.mpObj, aVEvt.mnGlueId);
SdrHdl* pHdl = mpView->GetGluePointHdl(aVEvt.mpObj, aVEvt.mnGlueId);
if (pHdl)
{
mpView->BegDragObj(aMDPos, pHdl, mpView->getMinMovLog());
}
}
else
{
/******************************************************************
* Objekt selektieren oder draggen
******************************************************************/
if (!rMEvt.IsShift() && !rMEvt.IsMod2() && eHit == SDRHIT_UNMARKEDOBJECT)
{
mpView->UnmarkAllObj();
}
bool bMarked = false;
if (!rMEvt.IsMod1())
{
if (rMEvt.IsMod2())
{
bMarked = mpView->MarkNextObj(aMDPos, mpView->getHitTolLog(), rMEvt.IsShift());
}
else
{
bMarked = mpView->MarkObj(aMDPos, mpView->getHitTolLog(), rMEvt.IsShift());
}
}
if (bMarked &&
(!rMEvt.IsShift() || eHit == SDRHIT_MARKEDOBJECT))
{
// Objekt verschieben
mpView->BegDragObj(aMDPos, aVEvt.mpHdl, mpView->getMinMovLog());
}
else if (mpView->areSdrObjectsSelected())
{
/**************************************************************
* Klebepunkt selektieren
**************************************************************/
if (!rMEvt.IsShift())
mpView->MarkGluePoints(0, true);
mpView->BegMarkGluePoints(aMDPos);
}
else
{
/**************************************************************
* Objekt selektieren
**************************************************************/
mpView->BegMarkObj(aMDPos);
}
}
ForcePointer(&rMEvt);
}
return bReturn;
}
/*************************************************************************
|*
|* MouseMove-event
|*
\************************************************************************/
bool FuEditGluePoints::MouseMove(const MouseEvent& rMEvt)
{
mpView->SetActualOutDev( mpWindow );
FuDraw::MouseMove(rMEvt);
if (mpView->IsAction())
{
const basegfx::B2DPoint aPix(rMEvt.GetPosPixel().X(), rMEvt.GetPosPixel().Y());
const basegfx::B2DPoint aLogicPos(mpWindow->GetInverseViewTransformation() * aPix);
ForceScroll(aPix);
mpView->MovAction(aLogicPos);
}
ForcePointer(&rMEvt);
return true;
}
/*************************************************************************
|*
|* MouseButtonUp-event
|*
\************************************************************************/
bool FuEditGluePoints::MouseButtonUp(const MouseEvent& rMEvt)
{
mpView->SetActualOutDev( mpWindow );
bool bReturn = false;
if (mpView->IsAction())
{
bReturn = true;
mpView->EndAction();
}
FuDraw::MouseButtonUp(rMEvt);
Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
if (fabs(aMDPos.getX() - aPos.getX()) < mpView->getMinMovLog() &&
fabs(aMDPos.getY() - aPos.getY()) < mpView->getMinMovLog() &&
!rMEvt.IsShift() && !rMEvt.IsMod2())
{
SdrViewEvent aVEvt;
SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
if (eHit == SDRHIT_NONE)
{
// Klick auf der Stelle: deselektieren
mpView->UnmarkAllObj();
}
}
mpWindow->ReleaseMouse();
return bReturn;
}
/*************************************************************************
|*
|* Tastaturereignisse bearbeiten
|*
|* Wird ein KeyEvent bearbeitet, so ist der Return-Wert true, andernfalls
|* false.
|*
\************************************************************************/
bool FuEditGluePoints::KeyInput(const KeyEvent& rKEvt)
{
mpView->SetActualOutDev( mpWindow );
//Solution: Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
//and SHIFT+ENTER key to decide the position and draw the new insert point
bool bReturn = FuDraw::KeyInput(rKEvt);
switch (rKEvt.GetKeyCode().GetCode())
{
case KEY_UP:
case KEY_DOWN:
case KEY_LEFT:
case KEY_RIGHT:
{
if(rKEvt.GetKeyCode().IsShift()&& mpView->IsInsGluePointMode() ){
long nX = 0;
long nY = 0;
sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
if (nCode == KEY_UP)
{
// Scroll nach oben
nX = 0;
nY =-1;
}
else if (nCode == KEY_DOWN)
{
// Scroll nach unten
nX = 0;
nY = 1;
}
else if (nCode == KEY_LEFT)
{
// Scroll nach links
nX =-1;
nY = 0;
}
else if (nCode == KEY_RIGHT)
{
// Scroll nach rechts
nX = 1;
nY = 0;
}
const basegfx::B2DPoint aSelectCenterPixel(
mpWindow->GetViewTransformation() * mpView->getMarkedObjectSnapRange().getCenter());
const Point aPoint(mbBeginInsertPoint
? maOldPoint
: Point(basegfx::fround(aSelectCenterPixel.getX()), basegfx::fround(aSelectCenterPixel.getY())));
const Point ePoint(aPoint + Point(nX, nY));
mpWindow->SetPointerPosPixel(ePoint);
//simulate mouse move action
MouseEvent eMevt(ePoint, 1, 2, MOUSE_LEFT, 0);
MouseMove(eMevt);
// ??? Point aPix(eMevt.GetPosPixel());
maOldPoint = ePoint;
mbBeginInsertPoint = true;
bReturn = true;
}
}
break;
case KEY_RETURN:
if(rKEvt.GetKeyCode().IsShift() && mpView->IsInsGluePointMode() )
{
if(mbBeginInsertPoint)
{
mpWindow->SetPointerPosPixel(maOldPoint);
//simulate mouse button down action
MouseEvent aMevt(maOldPoint, 1, 3, MOUSE_LEFT, KEY_SHIFT);
// MT IA2: Not used?
// sal_uInt16 ubuttons = aMevt.GetButtons();
// sal_uInt16 uMod = aMevt.GetModifier();
MouseButtonDown(aMevt);
mpWindow->CaptureMouse();
//simulate mouse button up action
MouseEvent rMEvt(maOldPoint, 1, 17, MOUSE_LEFT, KEY_SHIFT);
MouseButtonUp(rMEvt);
bReturn= sal_True;
}
}
break;
}
if(!bReturn)
bReturn = FuDraw::KeyInput(rKEvt);
return bReturn;
}
//Solution: Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
//and SHIFT+ENTER key to decide the position and draw the new insert point
void FuEditGluePoints::ForcePointer(const MouseEvent* pMEvt)
{
if(mbBeginInsertPoint && pMEvt)
{
MouseEvent aMEvt(pMEvt->GetPosPixel(), pMEvt->GetClicks(),
pMEvt->GetMode(), pMEvt->GetButtons(), pMEvt->GetModifier() & ~KEY_SHIFT);
FuDraw::ForcePointer(&aMEvt);
}
else
{
FuDraw::ForcePointer(pMEvt);
}
}
/*************************************************************************
|*
|* Command-event
|*
\************************************************************************/
bool FuEditGluePoints::Command(const CommandEvent& rCEvt)
{
mpView->SetActualOutDev( mpWindow );
return FuPoor::Command( rCEvt );
}
/*************************************************************************
|*
|* Funktion aktivieren
|*
\************************************************************************/
void FuEditGluePoints::Activate()
{
meLastSdrViewEditMode = mpView->GetViewEditMode();
mpView->SetViewEditMode(SDREDITMODE_GLUEPOINTEDIT);
FuDraw::Activate();
}
/*************************************************************************
|*
|* Funktion deaktivieren
|*
\************************************************************************/
void FuEditGluePoints::Deactivate()
{
mpView->SetViewEditMode(meLastSdrViewEditMode);
FuDraw::Deactivate();
}
/*************************************************************************
|*
|* Request verarbeiten
|*
\************************************************************************/
void FuEditGluePoints::ReceiveRequest(SfxRequest& rReq)
{
switch (rReq.GetSlot())
{
case SID_GLUE_INSERT_POINT:
{
mpView->SetInsGluePointMode(!mpView->IsInsGluePointMode());
}
break;
case SID_GLUE_ESCDIR_LEFT:
{
mpView->SetMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_LEFT,
!mpView->IsMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_LEFT ) );
}
break;
case SID_GLUE_ESCDIR_RIGHT:
{
mpView->SetMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_RIGHT,
!mpView->IsMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_RIGHT ) );
}
break;
case SID_GLUE_ESCDIR_TOP:
{
mpView->SetMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_TOP,
!mpView->IsMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_TOP ) );
}
break;
case SID_GLUE_ESCDIR_BOTTOM:
{
mpView->SetMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_BOTTOM,
!mpView->IsMarkedGluePointsEscDir( sdr::glue::GluePoint::ESCAPE_DIRECTION_BOTTOM ) );
}
break;
case SID_GLUE_PERCENT:
{
const SfxItemSet* pSet = rReq.GetArgs();
const SfxPoolItem& rItem = pSet->Get(SID_GLUE_PERCENT);
bool bPercent = ((const SfxBoolItem&) rItem).GetValue();
mpView->SetMarkedGluePointsPercent(bPercent);
}
break;
case SID_GLUE_HORZALIGN_CENTER:
{
mpView->SetMarkedGluePointsAlign(false, sdr::glue::GluePoint::Alignment_Center);
}
break;
case SID_GLUE_HORZALIGN_LEFT:
{
mpView->SetMarkedGluePointsAlign(false, sdr::glue::GluePoint::Alignment_Minimum);
}
break;
case SID_GLUE_HORZALIGN_RIGHT:
{
mpView->SetMarkedGluePointsAlign(false, sdr::glue::GluePoint::Alignment_Maximum);
}
break;
case SID_GLUE_VERTALIGN_CENTER:
{
mpView->SetMarkedGluePointsAlign(true, sdr::glue::GluePoint::Alignment_Center);
}
break;
case SID_GLUE_VERTALIGN_TOP:
{
mpView->SetMarkedGluePointsAlign(true, sdr::glue::GluePoint::Alignment_Minimum);
}
break;
case SID_GLUE_VERTALIGN_BOTTOM:
{
mpView->SetMarkedGluePointsAlign(true, sdr::glue::GluePoint::Alignment_Maximum);
}
break;
}
// Zum Schluss Basisklasse rufen
FuPoor::ReceiveRequest(rReq);
}
} // end of namespace sd