xref: /AOO41X/main/sd/source/ui/func/fupoor.cxx (revision 79aad27f7f29270c03e208e3d687e8e3850af11d)

/**************************************************************
 *
 * 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 "fupoor.hxx"

#include <svx/svxids.hrc>
#include <svl/aeitem.hxx>
#include <svx/svdpagv.hxx>
#include <svx/svdoole2.hxx>
#include <svx/svdograf.hxx>
#include <vcl/seleng.hxx>
#include <sfx2/app.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/request.hxx>
#include <vcl/dialog.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/drawing/XLayer.hpp>
#include <com/sun/star/drawing/XLayerManager.hpp>
#include <com/sun/star/container/XChild.hpp>

#ifndef SD_FRAMW_VIEW_HXX
#include "FrameView.hxx"
#endif
#include "app.hrc"
#include "fusel.hxx"
#include "sdpage.hxx"
#include "drawview.hxx"
#include "DrawViewShell.hxx"
#ifndef SD_WINDOW_SHELL_HXX
#include "Window.hxx"
#endif
#include "drawdoc.hxx"
#include "DrawDocShell.hxx"
#include "zoomlist.hxx"
#include "Client.hxx"
#include "slideshow.hxx"
#include "LayerTabBar.hxx"

#include <sfx2/viewfrm.hxx>

// #97016# IV
#include <svx/svditer.hxx>

// #98533#
#include <editeng/editeng.hxx>

using namespace ::com::sun::star;
using ::com::sun::star::uno::Reference;

namespace sd {

TYPEINIT0( FuPoor );

/*************************************************************************
|*
|* Konstruktor
|*
\************************************************************************/

FuPoor::FuPoor (
    ViewShell* pViewSh,
    ::sd::Window* pWin,
    ::sd::View* pView,
    SdDrawDocument* pDrDoc,
    SfxRequest& rReq)
    : mpView(pView),
	  mpViewShell(pViewSh),
	  mpWindow(pWin),
	  mpDocSh( pDrDoc->GetDocSh() ),
	  mpDoc(pDrDoc),
      nSlotId( rReq.GetSlot() ),
	  nSlotValue(0),
	  pDialog(NULL),
	  bIsInDragMode(sal_False),
	  bNoScrollUntilInside (sal_True),
	  bScrollable (sal_False),
	  bDelayActive (sal_False),
	  bFirstMouseMove (sal_False),
	  // #95491# remember MouseButton state
	  mnCode(0)
{
	ReceiveRequest(rReq);

	aScrollTimer.SetTimeoutHdl( LINK(this, FuPoor, ScrollHdl) );
	aScrollTimer.SetTimeout(SELENG_AUTOREPEAT_INTERVAL);

	aDragTimer.SetTimeoutHdl( LINK(this, FuPoor, DragHdl) );
	aDragTimer.SetTimeout(SELENG_DRAGDROP_TIMEOUT);

	aDelayToScrollTimer.SetTimeoutHdl( LINK(this, FuPoor, DelayHdl) );
	aDelayToScrollTimer.SetTimeout(2000);
}

/*************************************************************************
|*
|* Destruktor
|*
\************************************************************************/

FuPoor::~FuPoor()
{
	aDragTimer.Stop();
	aScrollTimer.Stop();
	aDelayToScrollTimer.Stop ();

	if (pDialog)
		delete pDialog;
}

/*************************************************************************
|*
|* Function aktivieren
|*
\************************************************************************/

void FuPoor::Activate()
{
	if (pDialog)
	{
		pDialog->Show();
	}
}

/*************************************************************************
|*
|* Function deaktivieren
|*
\************************************************************************/

void FuPoor::Deactivate()
{
	aDragTimer.Stop();
	aScrollTimer.Stop();
	aDelayToScrollTimer.Stop ();
		bScrollable  =
		bDelayActive = sal_False;

	if (pDialog)
	{
		pDialog->Hide();
	}

	if (mpWindow) mpWindow->ReleaseMouse ();
}

/*************************************************************************
|*
|* Scrollen bei Erreichen des Fensterrandes; wird von
|* MouseMove aufgerufen
|*
\************************************************************************/

void FuPoor::ForceScroll(const Point& aPixPos)
{
	aScrollTimer.Stop();

	if ( !mpView->IsDragHelpLine() && !mpView->IsSetPageOrg() &&
			!SlideShow::IsRunning( mpViewShell->GetViewShellBase() ) )
	{
/*		Size aSize = mpWindow->GetSizePixel();
		short dx = 0, dy = 0;

		if ( aPixPos.X() <= 0			   ) dx = -1;
		if ( aPixPos.X() >= aSize.Width()  ) dx =  1;
		if ( aPixPos.Y() <= 0			   ) dy = -1;
		if ( aPixPos.Y() >= aSize.Height() ) dy =  1;
*/
		Point aPos = mpWindow->OutputToScreenPixel(aPixPos);
		const Rectangle& rRect = mpViewShell->GetAllWindowRect();

		if ( bNoScrollUntilInside )
		{
			if ( rRect.IsInside(aPos) )
				bNoScrollUntilInside = sal_False;
		}
		else
		{
			short dx = 0, dy = 0;

			if ( aPos.X() <= rRect.Left()	) dx = -1;
			if ( aPos.X() >= rRect.Right()	) dx =	1;
			if ( aPos.Y() <= rRect.Top()	) dy = -1;
			if ( aPos.Y() >= rRect.Bottom() ) dy =	1;

			if ( dx != 0 || dy != 0 )
			{
				if (bScrollable)
				{
					// Scrollaktion in abgeleiteter Klasse
					ScrollStart();
					mpViewShell->ScrollLines(dx, dy);
					ScrollEnd();
					aScrollTimer.Start();
				}
				else if (! bDelayActive) StartDelayToScrollTimer ();
			}
		}
	}
}

/*************************************************************************
|*
|* Timer-Handler fuer Fensterscrolling
|*
\************************************************************************/

IMPL_LINK_INLINE_START( FuPoor, ScrollHdl, Timer *, EMPTYARG )
{
	Point aPnt(mpWindow->GetPointerPosPixel());

	// #95491# use remembered MouseButton state to create correct
	// MouseEvents for this artifical MouseMove.
	MouseMove(MouseEvent(aPnt, 1, 0, GetMouseButtonCode()));

	return 0;
}
IMPL_LINK_INLINE_END( FuPoor, ScrollHdl, Timer *, pTimer )

/*************************************************************************
|*
|* Tastaturereignisse bearbeiten
|*
|* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
|* sal_False.
|*
\************************************************************************/

sal_Bool FuPoor::KeyInput(const KeyEvent& rKEvt)
{
	sal_uInt16          nCode = rKEvt.GetKeyCode().GetCode();
	sal_Bool            bReturn = sal_False;
	sal_Bool            bSlideShow = SlideShow::IsRunning( mpViewShell->GetViewShellBase() );

	switch (nCode)
	{
		// #97016# IV
		case KEY_RETURN:
		{
			if(rKEvt.GetKeyCode().IsMod1())
			{
				if(mpViewShell && mpViewShell->ISA(DrawViewShell))
				{
					DrawViewShell* pDrawViewShell =
                        static_cast<DrawViewShell*>(mpViewShell);
					SdPage* pActualPage = pDrawViewShell->GetActualPage();
					SdrTextObj* pCandidate = 0L;

					if(pActualPage)
					{
						SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS);

						while(aIter.IsMore() && !pCandidate)
						{
							SdrObject* pObj = aIter.Next();

							if(pObj && pObj->ISA(SdrTextObj))
							{
								sal_uInt32 nInv(pObj->GetObjInventor());
								sal_uInt16 nKnd(pObj->GetObjIdentifier());

								if(SdrInventor == nInv &&
									(OBJ_TITLETEXT == nKnd || OBJ_OUTLINETEXT == nKnd || OBJ_TEXT == nKnd))
								{
									pCandidate = (SdrTextObj*)pObj;
								}
							}
						}
					}

					if(pCandidate)
					{
						mpView->UnMarkAll();
						mpView->MarkObj(pCandidate, mpView->GetSdrPageView());

						mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
							SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON);
					}
					else
					{
						// insert a new page with the same page layout
						mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
							SID_INSERTPAGE_QUICK, SFX_CALLMODE_ASYNCHRON);
					}

					// consumed
					bReturn = sal_True;
				}
			}
			else
			{
                // #98255# activate OLE object on RETURN for selected object
				// #98198# activate text edit on RETURN for selected object
				const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();

				if( !mpView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
				{
                    SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();

        			if( pObj && pObj->ISA( SdrOle2Obj ) && !mpDocSh->IsUIActive() )
			        {
                        //HMHmpView->HideMarkHdl();
                        mpViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
			        }
			        else if( pObj && pObj->IsEmptyPresObj() && pObj->ISA( SdrGrafObj ) )
			        {
				        mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_GRAPHIC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
			        }
                    else
                    {
    					mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
                    }

					// consumed
					bReturn = sal_True;
				}
			}
		}
		break;

		// #97016# II
		case KEY_TAB:
		{
			// #98994# handle Mod1 and Mod2 to get travelling running on different systems
			if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
			{
				// #97016# II do something with a selected handle?
				const SdrHdlList& rHdlList = mpView->GetHdlList();
				sal_Bool bForward(!rKEvt.GetKeyCode().IsShift());

				((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);

				// guarantee visibility of focused handle
				SdrHdl* pHdl = rHdlList.GetFocusHdl();

				if(pHdl)
				{
					Point aHdlPosition(pHdl->GetPos());
					Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
					mpView->MakeVisible(aVisRect, *mpWindow);
				}

				// consumed
				bReturn = sal_True;
			}
		}
		break;

		case KEY_ESCAPE:
		{
			bReturn = FuPoor::cancel();
		}
		break;

		case KEY_ADD:
		{
			if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
			{
				// Zoom vergroessern
				mpViewShell->SetZoom(mpWindow->GetZoom() * 3 / 2);

				if (mpViewShell->ISA(DrawViewShell))
					static_cast<DrawViewShell*>(mpViewShell)
                        ->SetZoomOnPage(sal_False);

				bReturn = sal_True;
			}
		}
		break;

		case KEY_SUBTRACT:
		{
			if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
			{
				// Zoom verringern
				mpViewShell->SetZoom(mpWindow->GetZoom() * 2 / 3);

				if (mpViewShell->ISA(DrawViewShell))
					static_cast<DrawViewShell*>(mpViewShell)
                        ->SetZoomOnPage(sal_False);

				bReturn = sal_True;
			}
		}
		break;

		case KEY_MULTIPLY:
		{
			if (!mpView->IsTextEdit() && !bSlideShow)
			{
				// Zoom auf Seite
				mpViewShell->GetViewFrame()->GetDispatcher()->
				Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
				bReturn = sal_True;
			}
		}
		break;

		case KEY_DIVIDE:
		{
			if (!mpView->IsTextEdit() && !bSlideShow)
			{
				// Zoom auf selektierte Objekte
				mpViewShell->GetViewFrame()->GetDispatcher()->
				Execute(SID_SIZE_OPTIMAL, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
				bReturn = sal_True;
			}
		}
		break;

		case KEY_POINT:
		{
			ZoomList* pZoomList = mpViewShell->GetZoomList();

			if (!mpView->IsTextEdit() && pZoomList->IsNextPossible() && !bSlideShow && !mpDocSh->IsUIActive())
			{
				// Naechstes ZoomRect einstellen
				mpViewShell->SetZoomRect(pZoomList->GetNextZoomRect());
				bReturn = sal_True;
			}
		}
		break;

		case KEY_COMMA:
		{
			ZoomList* pZoomList = mpViewShell->GetZoomList();

			if (!mpView->IsTextEdit() && pZoomList->IsPreviousPossible() && !bSlideShow && !mpDocSh->IsUIActive())
			{
				// Vorheriges ZoomRect einstellen
				mpViewShell->SetZoomRect(pZoomList->GetPreviousZoomRect());
				bReturn = sal_True;
			}
		}
		break;

		case KEY_HOME:
		{
			if (!mpView->IsTextEdit()
                && mpViewShell->ISA(DrawViewShell)
                && !bSlideShow)
			{
			   // Sprung zu erster Seite
			   static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(0);
			   bReturn = sal_True;
			}
		}
		break;

		case KEY_END:
		{
			if (!mpView->IsTextEdit()
                && mpViewShell->ISA(DrawViewShell)
                && !bSlideShow)
			{
				// Sprung zu letzter Seite
				SdPage* pPage =
                    static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
				static_cast<DrawViewShell*>(mpViewShell)
                    ->SwitchPage(mpDoc->GetSdPageCount(
                        pPage->GetPageKind()) - 1);
				bReturn = sal_True;
			}
		}
		break;

		case KEY_PAGEUP:
		{
		    if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
		        break;

			if(mpViewShell->ISA(DrawViewShell) && !bSlideShow)
			{
                // The page-up key switches layers or pages depending on the
                // modifier key.
                if ( ! rKEvt.GetKeyCode().GetAllModifier())
                {
                    // With no modifier pressed we move to the previous
                    // slide.
                    mpView->SdrEndTextEdit();

                    // Previous page.
                    bReturn = sal_True;
                    SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
                    sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;

                    if (nSdPage > 0)
                    {
                        // Switch the page and send events regarding
                        // deactivation the old page and activating the new
                        // one.
                        TabControl* pPageTabControl =
                            static_cast<DrawViewShell*>(mpViewShell)
                            ->GetPageTabControl();
                        if (pPageTabControl->IsReallyShown())
                            pPageTabControl->SendDeactivatePageEvent ();
                        static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage - 1);
                        if (pPageTabControl->IsReallyShown())
                            pPageTabControl->SendActivatePageEvent ();
                    }
                }
                else if (rKEvt.GetKeyCode().IsMod1())
                {
                    // With the CONTROL modifier we switch layers.
                    if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
                    {
                        // Moves to the previous layer.
                        SwitchLayer (-1);
                    }
                }
            }
		}
		break;

		case KEY_PAGEDOWN:
		{
		    if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
		        break;
            if(mpViewShell->ISA(DrawViewShell) && !bSlideShow)
            {
                // The page-down key switches layers or pages depending on the
                // modifier key.
                if ( ! rKEvt.GetKeyCode().GetAllModifier())
                {
                    // With no modifier pressed we move to the next slide.
                    mpView->SdrEndTextEdit();

                    // Next page.
                    bReturn = sal_True;
                    SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
                    sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;

                    if (nSdPage < mpDoc->GetSdPageCount(pPage->GetPageKind()) - 1)
                    {
                        // Switch the page and send events regarding
                        // deactivation the old page and activating the new
                        // one.
                        TabControl* pPageTabControl =
                            static_cast<DrawViewShell*>(mpViewShell)->GetPageTabControl();
                        if (pPageTabControl->IsReallyShown())
                            pPageTabControl->SendDeactivatePageEvent ();
                        static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage + 1);
                        if (pPageTabControl->IsReallyShown())
                            pPageTabControl->SendActivatePageEvent ();
                    }
                }
                else if (rKEvt.GetKeyCode().IsMod1())
                {
                    // With the CONTROL modifier we switch layers.
                    if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
                    {
                        // With the layer mode active pressing page-down
                        // moves to the next layer.
                        SwitchLayer (+1);
                    }
                }
            }
        }
        break;

		// #97016# II change select state when focus is on poly point
		case KEY_SPACE:
		{
			const SdrHdlList& rHdlList = mpView->GetHdlList();
			SdrHdl* pHdl = rHdlList.GetFocusHdl();

			if(pHdl)
			{
				if(pHdl->GetKind() == HDL_POLY)
				{
					// rescue ID of point with focus
					sal_uInt32 nPol(pHdl->GetPolyNum());
					sal_uInt32 nPnt(pHdl->GetPointNum());

					if(mpView->IsPointMarked(*pHdl))
					{
						if(rKEvt.GetKeyCode().IsShift())
						{
							mpView->UnmarkPoint(*pHdl);
						}
					}
					else
					{
						if(!rKEvt.GetKeyCode().IsShift())
						{
							mpView->UnmarkAllPoints();
						}

						mpView->MarkPoint(*pHdl);
					}

					if(0L == rHdlList.GetFocusHdl())
					{
						// restore point with focus
						SdrHdl* pNewOne = 0L;

						for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
						{
							SdrHdl* pAct = rHdlList.GetHdl(a);

							if(pAct
								&& pAct->GetKind() == HDL_POLY
								&& pAct->GetPolyNum() == nPol
								&& pAct->GetPointNum() == nPnt)
							{
								pNewOne = pAct;
							}
						}

						if(pNewOne)
						{
							((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
						}
					}

					bReturn = sal_True;
				}
			}
		}
		break;

		case KEY_UP:
		case KEY_DOWN:
		case KEY_LEFT:
		case KEY_RIGHT:
		{
			if (!mpView->IsTextEdit() && !bSlideShow)
			{
				long nX = 0;
				long nY = 0;

				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;
				}

				if (mpView->AreObjectsMarked() && !rKEvt.GetKeyCode().IsMod1() &&
					!mpDocSh->IsReadOnly())
				{
					// #97016# II
					const SdrHdlList& rHdlList = mpView->GetHdlList();
					SdrHdl* pHdl = rHdlList.GetFocusHdl();

					// #109007#
					sal_Bool bIsMoveOfConnectedHandle(sal_False);
					sal_Bool bOldSuppress = false;
					SdrEdgeObj* pEdgeObj = 0L;

					if(pHdl && pHdl->GetObj() && pHdl->GetObj()->ISA(SdrEdgeObj) && 0 == pHdl->GetPolyNum())
					{
						pEdgeObj = (SdrEdgeObj*)pHdl->GetObj();

						if(0L == pHdl->GetPointNum())
						{
							if(pEdgeObj->GetConnection(sal_True).GetObject())
							{
								bIsMoveOfConnectedHandle = sal_True;
							}
						}
						if(1L == pHdl->GetPointNum())
						{
							if(pEdgeObj->GetConnection(sal_False).GetObject())
							{
								bIsMoveOfConnectedHandle = sal_True;
							}
						}
					}

					// #109007#
					if(pEdgeObj)
					{
						// Suppress default connects to inside object and object center
						bOldSuppress = pEdgeObj->GetSuppressDefaultConnect();
						pEdgeObj->SetSuppressDefaultConnect(sal_True);
					}

					// #109007#
					if(bIsMoveOfConnectedHandle)
					{
						sal_uInt16 nMarkHdSiz(mpView->GetMarkHdlSizePixel());
						Size aHalfConSiz(nMarkHdSiz + 1, nMarkHdSiz + 1);
						aHalfConSiz = mpWindow->PixelToLogic(aHalfConSiz);

						if(100 < aHalfConSiz.Width())
							nX *= aHalfConSiz.Width();
						else
							nX *= 100;

						if(100 < aHalfConSiz.Height())
							nY *= aHalfConSiz.Height();
						else
							nY *= 100;
					}
					else if(rKEvt.GetKeyCode().IsMod2())
					{
						// #97016# move in 1 pixel distance
						Size aLogicSizeOnePixel = (mpWindow) ? mpWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
						nX *= aLogicSizeOnePixel.Width();
						nY *= aLogicSizeOnePixel.Height();
					}
					else if(rKEvt.GetKeyCode().IsShift())
					{
						nX *= 1000;
						nY *= 1000;
					}
					else
					{
						// old, fixed move distance
						nX *= 100;
						nY *= 100;
					}

					if(0L == pHdl)
					{
						// #67368# only take action when move is allowed
						if(mpView->IsMoveAllowed())
						{
							// #90129# restrict movement to WorkArea
							const Rectangle& rWorkArea = mpView->GetWorkArea();

							if(!rWorkArea.IsEmpty())
							{
								Rectangle aMarkRect(mpView->GetMarkedObjRect());
								aMarkRect.Move(nX, nY);

								if(!aMarkRect.IsInside(rWorkArea))
								{
									if(aMarkRect.Left() < rWorkArea.Left())
									{
										nX += rWorkArea.Left() - aMarkRect.Left();
									}

									if(aMarkRect.Right() > rWorkArea.Right())
									{
										nX -= aMarkRect.Right() - rWorkArea.Right();
									}

									if(aMarkRect.Top() < rWorkArea.Top())
									{
										nY += rWorkArea.Top() - aMarkRect.Top();
									}

									if(aMarkRect.Bottom() > rWorkArea.Bottom())
									{
										nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
									}
								}
							}

							// no handle selected
							if(0 != nX || 0 != nY)
							{
								mpView->MoveAllMarked(Size(nX, nY));

								// #97016# II
								mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
							}
						}
					}
					else
					{
						// move handle with index nHandleIndex
						if(pHdl && (nX || nY))
						{
							// now move the Handle (nX, nY)
							Point aStartPoint(pHdl->GetPos());
							Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
							const SdrDragStat& rDragStat = mpView->GetDragStat();

							// start dragging
							mpView->BegDragObj(aStartPoint, 0, pHdl, 0);

					        if(mpView->IsDragObj())
							{
								FASTBOOL bWasNoSnap = rDragStat.IsNoSnap();
								sal_Bool bWasSnapEnabled = mpView->IsSnapEnabled();

								// switch snapping off
								if(!bWasNoSnap)
									((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
								if(bWasSnapEnabled)
									mpView->SetSnapEnabled(sal_False);

								mpView->MovAction(aEndPoint);
								mpView->EndDragObj();

								// restore snap
								if(!bWasNoSnap)
									((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
								if(bWasSnapEnabled)
									mpView->SetSnapEnabled(bWasSnapEnabled);
							}

							// make moved handle visible
							Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
							mpView->MakeVisible(aVisRect, *mpWindow);
						}
					}

					// #109007#
					if(pEdgeObj)
					{
						// Restore original suppress value
						pEdgeObj->SetSuppressDefaultConnect(bOldSuppress);
					}
				}
				else
				{
					// Seite scrollen
					ScrollStart();
					mpViewShell->ScrollLines(nX, nY);
					ScrollEnd();
				}

				bReturn = sal_True;
			}
		}
		break;
	}

	if (bReturn)
	{
		mpWindow->ReleaseMouse();
	}

	// #98198# when a text-editable object is selected and the
	// input character is printable, activate text edit on that object
	// and feed character to object
	if(!bReturn && !mpDocSh->IsReadOnly())
	{
		if(!mpView->IsTextEdit() && mpViewShell)
		{
			const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();

			if(1 == rMarkList.GetMarkCount())
			{
				SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();

                // #i118485# allow TextInput for OLEs, too
				if(pObj->ISA(SdrTextObj) && pObj->HasTextEdit())
				{
					// #98533# use common IsSimpleCharInput from
					// the EditEngine.
					sal_Bool bPrintable(EditEngine::IsSimpleCharInput(rKEvt));

					if(bPrintable)
					{
						// try to activate textedit mode for the selected object
						SfxStringItem aInputString(SID_ATTR_CHAR, String(rKEvt.GetCharCode()));

						mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
							SID_ATTR_CHAR,
							SFX_CALLMODE_ASYNCHRON,
							&aInputString,
							0L);

						// consumed
						bReturn = sal_True;
					}
				}
			}
			else
			{
				// #99039# test if there is a title object there. If yes, try to
				// set it to edit mode and start typing...
				if(mpViewShell->ISA(DrawViewShell)
                    && EditEngine::IsSimpleCharInput(rKEvt))
				{
					DrawViewShell* pDrawViewShell =
                        static_cast<DrawViewShell*>(mpViewShell);
					SdPage* pActualPage = pDrawViewShell->GetActualPage();
					SdrTextObj* pCandidate = 0L;

					if(pActualPage)
					{
						SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS);

						while(aIter.IsMore() && !pCandidate)
						{
							SdrObject* pObj = aIter.Next();

							if(pObj && pObj->ISA(SdrTextObj))
							{
								sal_uInt32 nInv(pObj->GetObjInventor());
								sal_uInt16 nKnd(pObj->GetObjIdentifier());

								if(SdrInventor == nInv && OBJ_TITLETEXT == nKnd)
								{
									pCandidate = (SdrTextObj*)pObj;
								}
							}
						}
					}

					// when candidate found and candidate is untouched, start editing text...
					if(pCandidate && pCandidate->IsEmptyPresObj())
					{
						mpView->UnMarkAll();
						mpView->MarkObj(pCandidate, mpView->GetSdrPageView());
						SfxStringItem aInputString(SID_ATTR_CHAR, String(rKEvt.GetCharCode()));

						mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
							SID_ATTR_CHAR,
							SFX_CALLMODE_ASYNCHRON,
							&aInputString,
							0L);

						// consumed
						bReturn = sal_True;
					}
				}
			}
		}
	}

	return(bReturn);
}

sal_Bool FuPoor::MouseMove(const MouseEvent& )
{
	return sal_False;
}

// #97016# II
void FuPoor::SelectionHasChanged()
{
	const SdrHdlList& rHdlList = mpView->GetHdlList();
	((SdrHdlList&)rHdlList).ResetFocusHdl();
}

/*************************************************************************
|*
|* Cut object to clipboard
|*
\************************************************************************/

void FuPoor::DoCut()
{
	if (mpView)
	{
		mpView->DoCut(mpWindow);
	}
}

/*************************************************************************
|*
|* Copy object to clipboard
|*
\************************************************************************/

void FuPoor::DoCopy()
{
	if (mpView)
	{
		mpView->DoCopy(mpWindow);
	}
}

/*************************************************************************
|*
|* Paste object from clipboard
|*
\************************************************************************/

void FuPoor::DoPaste()
{
	if (mpView)
	{
		mpView->DoPaste(mpWindow);
	}
}

/*************************************************************************
|*
|* Timer-Handler fuer Drag&Drop
|*
\************************************************************************/

IMPL_LINK( FuPoor, DragHdl, Timer *, EMPTYARG )
{
	if( mpView )
	{
		sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
		SdrHdl* pHdl = mpView->PickHandle(aMDPos);

		if ( pHdl==NULL && mpView->IsMarkedHit(aMDPos, nHitLog)
			 && !mpView->IsPresObjSelected(sal_False, sal_True) )
		{
			mpWindow->ReleaseMouse();
			bIsInDragMode = sal_True;
			mpView->StartDrag( aMDPos, mpWindow );
		}
	}
	return 0;
}

/*************************************************************************
|*
|* Command-event
|*
\************************************************************************/

sal_Bool FuPoor::Command(const CommandEvent& rCEvt)
{
	return( mpView->Command(rCEvt,mpWindow) );
}

/*************************************************************************
|*
|* Timer-Handler fuer Fensterscrolling
|*
\************************************************************************/

IMPL_LINK_INLINE_START( FuPoor, DelayHdl, Timer *, EMPTYARG )
{
	aDelayToScrollTimer.Stop ();
	bScrollable = sal_True;

	Point aPnt(mpWindow->GetPointerPosPixel());

	// #95491# use remembered MouseButton state to create correct
	// MouseEvents for this artifical MouseMove.
	MouseMove(MouseEvent(aPnt, 1, 0, GetMouseButtonCode()));

	return 0;
}
IMPL_LINK_INLINE_END( FuPoor, DelayHdl, Timer *, pTimer )

/*************************************************************************
|*
|* Handler fuer Maustaste
|*
\************************************************************************/

sal_Bool FuPoor::MouseButtonUp (const MouseEvent& rMEvt)
{
	// #95491# remember button state for creation of own MouseEvents
	SetMouseButtonCode(rMEvt.GetButtons());

	aDelayToScrollTimer.Stop ();
	return bScrollable	=
		bDelayActive = sal_False;
}

sal_Bool FuPoor::MouseButtonDown(const MouseEvent& rMEvt)
{
	// #95491# remember button state for creation of own MouseEvents
	SetMouseButtonCode(rMEvt.GetButtons());

	return sal_False;
}

/*************************************************************************
|*
|* Handler fuer Maustaste
|*
\************************************************************************/

void FuPoor::StartDelayToScrollTimer ()
{
	bDelayActive = sal_True;
	aDelayToScrollTimer.Start ();
}

/*************************************************************************
|*
|* Help-event
|*
\************************************************************************/

sal_Bool FuPoor::RequestHelp(const HelpEvent& rHEvt)
{
	sal_Bool bReturn = sal_False;

	SdrPageView* pPV = mpView->GetSdrPageView();

	if (pPV)
	{
		SdPage* pPage = (SdPage*) pPV->GetPage();

		if (pPage)
		{
			bReturn = pPage->RequestHelp(mpWindow, mpView, rHEvt);
		}
	}

	return(bReturn);
}

void FuPoor::Paint(const Rectangle&, ::sd::Window* )
{
}

/*************************************************************************
|*
|* Request verarbeiten
|*
\************************************************************************/

void FuPoor::ReceiveRequest(SfxRequest& rReq)
{
	const SfxItemSet* pSet = rReq.GetArgs();

	if (pSet)
	{
		if( pSet->GetItemState( nSlotId ) == SFX_ITEM_SET )
		{
			const SfxPoolItem& rItem = pSet->Get( nSlotId );

			if( rItem.ISA( SfxAllEnumItem ) )
			{
				nSlotValue = ( ( const SfxAllEnumItem& ) rItem ).GetValue();
			}
		}
	}
}

/*************************************************************************
|*
|* #97016#
|*
\************************************************************************/

SdrObject* FuPoor::CreateDefaultObject(const sal_uInt16, const Rectangle& )
{
	// empty base implementation
	return 0L;
}

void FuPoor::ImpForceQuadratic(Rectangle& rRect)
{
	if(rRect.GetWidth() > rRect.GetHeight())
	{
		rRect = Rectangle(
			Point(rRect.Left() + ((rRect.GetWidth() - rRect.GetHeight()) / 2), rRect.Top()),
			Size(rRect.GetHeight(), rRect.GetHeight()));
	}
	else
	{
		rRect = Rectangle(
			Point(rRect.Left(), rRect.Top() + ((rRect.GetHeight() - rRect.GetWidth()) / 2)),
			Size(rRect.GetWidth(), rRect.GetWidth()));
	}
}




void FuPoor::SwitchLayer (sal_Int32 nOffset)
{
    if(mpViewShell && mpViewShell->ISA(DrawViewShell))
    {
        DrawViewShell* pDrawViewShell =
            static_cast<DrawViewShell*>(mpViewShell);

        // Calculate the new index.
        sal_Int32 nIndex = pDrawViewShell->GetActiveTabLayerIndex() + nOffset;

        // Make sure the new index lies inside the range of valid indices.
        if (nIndex < 0)
            nIndex = 0;
        else if (nIndex >= pDrawViewShell->GetTabLayerCount ())
            nIndex = pDrawViewShell->GetTabLayerCount() - 1;

        // Set the new active layer.
        if (nIndex != pDrawViewShell->GetActiveTabLayerIndex ())
        {
            LayerTabBar* pLayerTabControl =
                static_cast<DrawViewShell*>(mpViewShell)->GetLayerTabControl();
            if (pLayerTabControl != NULL)
                pLayerTabControl->SendDeactivatePageEvent ();

            pDrawViewShell->SetActiveTabLayerIndex (nIndex);

            if (pLayerTabControl != NULL)
                pLayerTabControl->SendActivatePageEvent ();
        }
    }
}

/** is called when the currenct function should be aborted. <p>
	This is used when a function gets a KEY_ESCAPE but can also
	be called directly.

	@returns true if a active function was aborted
*/
bool FuPoor::cancel()
{
	if ( !this->ISA(FuSelection) )
	{
		mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON);
		return true;
	}

	return false;
}

// #i33136#
bool FuPoor::doConstructOrthogonal() const
{
	return (
		SID_DRAW_XLINE == nSlotId ||
		SID_DRAW_CIRCLEARC == nSlotId ||
		SID_DRAW_SQUARE == nSlotId ||
		SID_DRAW_SQUARE_NOFILL == nSlotId ||
		SID_DRAW_SQUARE_ROUND == nSlotId ||
		SID_DRAW_SQUARE_ROUND_NOFILL == nSlotId ||
		SID_DRAW_CIRCLE == nSlotId ||
		SID_DRAW_CIRCLE_NOFILL == nSlotId ||
		SID_DRAW_CIRCLEPIE == nSlotId ||
		SID_DRAW_CIRCLEPIE_NOFILL == nSlotId ||
		SID_DRAW_CIRCLECUT == nSlotId ||
		SID_DRAW_CIRCLECUT_NOFILL == nSlotId ||
		SID_DRAW_XPOLYGON == nSlotId ||
		SID_DRAW_XPOLYGON_NOFILL == nSlotId ||
		SID_3D_CUBE == nSlotId ||
		SID_3D_SPHERE == nSlotId ||
		SID_3D_SHELL == nSlotId ||
		SID_3D_HALF_SPHERE == nSlotId ||
		SID_3D_TORUS == nSlotId ||
		SID_3D_CYLINDER == nSlotId ||
		SID_3D_CONE == nSlotId ||
		SID_3D_PYRAMID == nSlotId);
}

void FuPoor::DoExecute( SfxRequest& )
{
}

} // end of namespace sd