You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2372 lines
71 KiB
2372 lines
71 KiB
|
|
/*
|
|
Copyright (c) 2003,2004,2005 Clarence Dang <dang@kde.org>
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#define DEBUG_KP_TOOL_SELECTION 0
|
|
|
|
|
|
#include <kptoolselection.h>
|
|
|
|
#include <tqapplication.h>
|
|
#include <tqbitmap.h>
|
|
#include <tqcursor.h>
|
|
#include <tqpainter.h>
|
|
#include <tqpopupmenu.h>
|
|
#include <tqtimer.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include <kpcommandhistory.h>
|
|
#include <kpdefs.h>
|
|
#include <kpdocument.h>
|
|
#include <kpmainwindow.h>
|
|
#include <kpselection.h>
|
|
#include <kptooltoolbar.h>
|
|
#include <kptoolwidgetopaqueortransparent.h>
|
|
#include <kpview.h>
|
|
#include <kpviewmanager.h>
|
|
|
|
|
|
kpToolSelection::kpToolSelection (Mode mode,
|
|
const TQString &text,
|
|
const TQString &description,
|
|
int key,
|
|
kpMainWindow *mainWindow,
|
|
const char *name)
|
|
: kpTool (text, description, key, mainWindow, name),
|
|
m_mode (mode),
|
|
m_currentPullFromDocumentCommand (0),
|
|
m_currentMoveCommand (0),
|
|
m_currentResizeScaleCommand (0),
|
|
m_toolWidgetOpaqueOrTransparent (0),
|
|
m_currentCreateTextCommand (0),
|
|
m_createNOPTimer (new TQTimer (this)),
|
|
m_RMBMoveUpdateGUITimer (new TQTimer (this))
|
|
{
|
|
connect (m_createNOPTimer, TQ_SIGNAL (timeout ()),
|
|
this, TQ_SLOT (delayedDraw ()));
|
|
connect (m_RMBMoveUpdateGUITimer, TQ_SIGNAL (timeout ()),
|
|
this, TQ_SLOT (slotRMBMoveUpdateGUI ()));
|
|
}
|
|
|
|
kpToolSelection::~kpToolSelection ()
|
|
{
|
|
}
|
|
|
|
|
|
// private
|
|
void kpToolSelection::pushOntoDocument ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelection::pushOntoDocument() CALLED" << endl;
|
|
#endif
|
|
mainWindow ()->slotDeselect ();
|
|
}
|
|
|
|
|
|
// protected
|
|
bool kpToolSelection::onSelectionToMove () const
|
|
{
|
|
kpView *v = viewManager ()->viewUnderCursor ();
|
|
if (!v)
|
|
return 0;
|
|
|
|
return v->mouseOnSelectionToMove (m_currentViewPoint);
|
|
}
|
|
|
|
// protected
|
|
int kpToolSelection::onSelectionResizeHandle () const
|
|
{
|
|
kpView *v = viewManager ()->viewUnderCursor ();
|
|
if (!v)
|
|
return 0;
|
|
|
|
return v->mouseOnSelectionResizeHandle (m_currentViewPoint);
|
|
}
|
|
|
|
// protected
|
|
bool kpToolSelection::onSelectionToSelectText () const
|
|
{
|
|
kpView *v = viewManager ()->viewUnderCursor ();
|
|
if (!v)
|
|
return 0;
|
|
|
|
return v->mouseOnSelectionToSelectText (m_currentViewPoint);
|
|
}
|
|
|
|
|
|
// public
|
|
TQString kpToolSelection::haventBegunDrawUserMessage () const
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 0
|
|
kdDebug () << "kpToolSelection::haventBegunDrawUserMessage()"
|
|
" cancelledShapeButStillHoldingButtons="
|
|
<< m_cancelledShapeButStillHoldingButtons
|
|
<< endl;
|
|
#endif
|
|
|
|
if (m_cancelledShapeButStillHoldingButtons)
|
|
return i18n ("Let go of all the mouse buttons.");
|
|
|
|
kpSelection *sel = document ()->selection ();
|
|
if (sel && onSelectionResizeHandle () && !controlOrShiftPressed ())
|
|
{
|
|
if (m_mode == Text)
|
|
return i18n ("Left drag to resize text box.");
|
|
else
|
|
return i18n ("Left drag to scale selection.");
|
|
}
|
|
else if (sel && sel->contains (m_currentPoint))
|
|
{
|
|
if (m_mode == Text)
|
|
{
|
|
if (onSelectionToSelectText () && !controlOrShiftPressed ())
|
|
return i18n ("Left click to change cursor position.");
|
|
else
|
|
return i18n ("Left drag to move text box.");
|
|
}
|
|
else
|
|
{
|
|
return i18n ("Left drag to move selection.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_mode == Text)
|
|
return i18n ("Left drag to create text box.");
|
|
else
|
|
return i18n ("Left drag to create selection.");
|
|
}
|
|
}
|
|
|
|
|
|
// virtual
|
|
void kpToolSelection::begin ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::begin()" << endl;
|
|
#endif
|
|
|
|
kpToolToolBar *tb = toolToolBar ();
|
|
|
|
if (tb)
|
|
{
|
|
m_toolWidgetOpaqueOrTransparent = tb->toolWidgetOpaqueOrTransparent ();
|
|
|
|
if (m_toolWidgetOpaqueOrTransparent)
|
|
{
|
|
connect (m_toolWidgetOpaqueOrTransparent, TQ_SIGNAL (isOpaqueChanged (bool)),
|
|
this, TQ_SLOT (slotIsOpaqueChanged ()));
|
|
m_toolWidgetOpaqueOrTransparent->show ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_toolWidgetOpaqueOrTransparent = 0;
|
|
}
|
|
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
viewManager ()->setSelectionBorderFinished (true);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
|
|
m_startDragFromSelectionTopLeft = TQPoint ();
|
|
m_dragType = Unknown;
|
|
m_dragHasBegun = false;
|
|
m_hadSelectionBeforeDrag = false; // arbitrary
|
|
m_resizeScaleType = 0;
|
|
|
|
m_currentPullFromDocumentCommand = 0;
|
|
m_currentMoveCommand = 0;
|
|
m_currentResizeScaleCommand = 0;
|
|
m_currentCreateTextCommand = 0;
|
|
|
|
m_cancelledShapeButStillHoldingButtons = false;
|
|
|
|
setUserMessage (haventBegunDrawUserMessage ());
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::end ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::end()" << endl;
|
|
#endif
|
|
|
|
if (document ()->selection ())
|
|
pushOntoDocument ();
|
|
|
|
if (m_toolWidgetOpaqueOrTransparent)
|
|
{
|
|
disconnect (m_toolWidgetOpaqueOrTransparent, TQ_SIGNAL (isOpaqueChanged (bool)),
|
|
this, TQ_SLOT (slotIsOpaqueChanged ()));
|
|
m_toolWidgetOpaqueOrTransparent = 0;
|
|
}
|
|
|
|
viewManager ()->unsetCursor ();
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::reselect ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::reselect()" << endl;
|
|
#endif
|
|
|
|
if (document ()->selection ())
|
|
pushOntoDocument ();
|
|
}
|
|
|
|
|
|
// virtual
|
|
void kpToolSelection::beginDraw ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::beginDraw() m_startPoint="
|
|
<< m_startPoint
|
|
<< " TQCursor::pos() view startPoint="
|
|
<< m_viewUnderStartPoint->mapFromGlobal (TQCursor::pos ())
|
|
<< endl;
|
|
#endif
|
|
|
|
m_createNOPTimer->stop ();
|
|
m_RMBMoveUpdateGUITimer->stop ();
|
|
|
|
|
|
// In case the cursor was wrong to start with
|
|
// (forgot to call kpTool::somethingBelowTheCursorChanged()),
|
|
// make sure it is correct during this operation.
|
|
hover (m_currentPoint);
|
|
|
|
// Currently used only to end the current text
|
|
if (hasBegunShape ())
|
|
endShape (m_currentPoint, TQRect (m_startPoint/* TODO: wrong */, m_currentPoint).normalize ());
|
|
|
|
m_dragType = Create;
|
|
m_dragHasBegun = false;
|
|
|
|
kpSelection *sel = document ()->selection ();
|
|
m_hadSelectionBeforeDrag = bool (sel);
|
|
|
|
if (sel)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\thas sel region rect=" << sel->boundingRect () << endl;
|
|
#endif
|
|
TQRect selectionRect = sel->boundingRect ();
|
|
|
|
if (onSelectionResizeHandle () && !controlOrShiftPressed ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tis resize/scale" << endl;
|
|
#endif
|
|
|
|
m_startDragFromSelectionTopLeft = m_currentPoint - selectionRect.topLeft ();
|
|
m_dragType = ResizeScale;
|
|
m_resizeScaleType = onSelectionResizeHandle ();
|
|
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
viewManager ()->setSelectionBorderFinished (true);
|
|
viewManager ()->setTextCursorEnabled (false);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
}
|
|
else if (sel->contains (m_currentPoint))
|
|
{
|
|
if (m_mode == Text && onSelectionToSelectText () && !controlOrShiftPressed ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tis select cursor pos" << endl;
|
|
#endif
|
|
|
|
m_dragType = SelectText;
|
|
|
|
viewManager ()->setTextCursorPosition (sel->textRowForPoint (m_currentPoint),
|
|
sel->textColForPoint (m_currentPoint));
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tis move" << endl;
|
|
#endif
|
|
|
|
m_startDragFromSelectionTopLeft = m_currentPoint - selectionRect.topLeft ();
|
|
m_dragType = Move;
|
|
|
|
if (m_mouseButton == 0)
|
|
{
|
|
setSelectionBorderForMove ();
|
|
}
|
|
else
|
|
{
|
|
// Don't hide sel border momentarily if user is just
|
|
// right _clicking_ selection
|
|
m_RMBMoveUpdateGUITimer->start (100, true/*single shot*/);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tis new sel" << endl;
|
|
#endif
|
|
|
|
pushOntoDocument ();
|
|
}
|
|
}
|
|
|
|
// creating new selection?
|
|
if (m_dragType == Create)
|
|
{
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
viewManager ()->setSelectionBorderFinished (false);
|
|
viewManager ()->setTextCursorEnabled (false);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
|
|
m_createNOPTimer->start (200, true/*single shot*/);
|
|
}
|
|
|
|
if (m_dragType != SelectText)
|
|
{
|
|
setUserMessage (cancelUserMessage ());
|
|
}
|
|
}
|
|
|
|
|
|
// protected
|
|
const TQCursor &kpToolSelection::cursor () const
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelection::cursor()"
|
|
<< " m_currentPoint=" << m_currentPoint
|
|
<< " TQCursor::pos() view under cursor="
|
|
<< (viewUnderCursor () ?
|
|
viewUnderCursor ()->mapFromGlobal (TQCursor::pos ()) :
|
|
KP_INVALID_POINT)
|
|
<< " controlOrShiftPressed=" << controlOrShiftPressed ()
|
|
<< endl;
|
|
#endif
|
|
|
|
kpSelection *sel = document () ? document ()->selection () : 0;
|
|
|
|
if (sel && onSelectionResizeHandle () && !controlOrShiftPressed ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tonSelectionResizeHandle="
|
|
<< onSelectionResizeHandle () << endl;
|
|
#endif
|
|
switch (onSelectionResizeHandle ())
|
|
{
|
|
case (kpView::Top | kpView::Left):
|
|
case (kpView::Bottom | kpView::Right):
|
|
return TQt::sizeFDiagCursor;
|
|
|
|
case (kpView::Bottom | kpView::Left):
|
|
case (kpView::Top | kpView::Right):
|
|
return TQt::sizeBDiagCursor;
|
|
|
|
case kpView::Top:
|
|
case kpView::Bottom:
|
|
return TQt::sizeVerCursor;
|
|
|
|
case kpView::Left:
|
|
case kpView::Right:
|
|
return TQt::sizeHorCursor;
|
|
}
|
|
|
|
return TQt::arrowCursor;
|
|
}
|
|
else if (sel && sel->contains (m_currentPoint))
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tsel contains currentPoint; selecting text? "
|
|
<< onSelectionToSelectText () << endl;
|
|
#endif
|
|
|
|
if (m_mode == Text && onSelectionToSelectText () && !controlOrShiftPressed ())
|
|
return TQt::ibeamCursor;
|
|
else
|
|
return TQt::sizeAllCursor;
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tnot on sel" << endl;
|
|
#endif
|
|
return TQt::crossCursor;
|
|
}
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::hover (const TQPoint &point)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelection::hover" << point << endl;
|
|
#endif
|
|
|
|
viewManager ()->setCursor (cursor ());
|
|
|
|
setUserShapePoints (point, KP_INVALID_POINT, false/*don't set size*/);
|
|
if (document () && document ()->selection ())
|
|
{
|
|
setUserShapeSize (document ()->selection ()->width (),
|
|
document ()->selection ()->height ());
|
|
}
|
|
else
|
|
{
|
|
setUserShapeSize (KP_INVALID_SIZE);
|
|
}
|
|
|
|
TQString mess = haventBegunDrawUserMessage ();
|
|
if (mess != userMessage ())
|
|
setUserMessage (mess);
|
|
}
|
|
|
|
// protected
|
|
void kpToolSelection::popupRMBMenu ()
|
|
{
|
|
TQPopupMenu *pop = mainWindow () ? mainWindow ()->selectionToolRMBMenu () : 0;
|
|
if (!pop)
|
|
return;
|
|
|
|
// WARNING: enters event loop - may re-enter view/tool event handlers
|
|
pop->exec (TQCursor::pos ());
|
|
|
|
// Cursor may have moved while menu up, triggering mouseMoveEvents
|
|
// for the menu - not the view. Update cursor position now.
|
|
somethingBelowTheCursorChanged ();
|
|
}
|
|
|
|
// protected
|
|
void kpToolSelection::setSelectionBorderForMove ()
|
|
{
|
|
// don't show border while moving
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
viewManager ()->setSelectionBorderVisible (false);
|
|
viewManager ()->setSelectionBorderFinished (true);
|
|
viewManager ()->setTextCursorEnabled (false);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
}
|
|
|
|
// protected slot
|
|
void kpToolSelection::slotRMBMoveUpdateGUI ()
|
|
{
|
|
// (just in case not called from single shot)
|
|
m_RMBMoveUpdateGUITimer->stop ();
|
|
|
|
setSelectionBorderForMove ();
|
|
|
|
kpSelection * const sel = document () ? document ()->selection () : 0;
|
|
if (sel)
|
|
setUserShapePoints (sel->topLeft ());
|
|
}
|
|
|
|
// protected slot
|
|
void kpToolSelection::delayedDraw ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelection::delayedDraw() hasBegunDraw="
|
|
<< hasBegunDraw ()
|
|
<< " currentPoint=" << m_currentPoint
|
|
<< " lastPoint=" << m_lastPoint
|
|
<< " startPoint=" << m_startPoint
|
|
<< endl;
|
|
#endif
|
|
|
|
// (just in case not called from single shot)
|
|
m_createNOPTimer->stop ();
|
|
|
|
if (hasBegunDraw ())
|
|
{
|
|
draw (m_currentPoint, m_lastPoint,
|
|
TQRect (m_startPoint, m_currentPoint).normalize ());
|
|
}
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::draw (const TQPoint &inThisPoint, const TQPoint & /*lastPoint*/,
|
|
const TQRect &inNormalizedRect)
|
|
{
|
|
TQPoint thisPoint = inThisPoint;
|
|
TQRect normalizedRect = inNormalizedRect;
|
|
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelection::draw" << thisPoint
|
|
<< " startPoint=" << m_startPoint
|
|
<< " normalizedRect=" << normalizedRect << endl;
|
|
#endif
|
|
|
|
|
|
// OPT: return when thisPoint == m_lastPoint so that e.g. when creating
|
|
// Points sel, press modifiers doesn't add multiple points in same
|
|
// place
|
|
|
|
|
|
bool nextDragHasBegun = true;
|
|
|
|
|
|
if (m_dragType == Create)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tnot moving - resizing rect to" << normalizedRect
|
|
<< endl;
|
|
kdDebug () << "\t\tcreateNOPTimer->isActive()="
|
|
<< m_createNOPTimer->isActive ()
|
|
<< " viewManhattanLength from startPoint="
|
|
<< m_viewUnderStartPoint->transformDocToViewX ((thisPoint - m_startPoint).manhattanLength ())
|
|
<< endl;
|
|
#endif
|
|
|
|
if (m_createNOPTimer->isActive ())
|
|
{
|
|
if (m_viewUnderStartPoint->transformDocToViewX ((thisPoint - m_startPoint).manhattanLength ()) <= 6)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tsuppress accidental movement" << endl;
|
|
#endif
|
|
thisPoint = m_startPoint;
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tit's a \"big\" intended move - stop timer" << endl;
|
|
#endif
|
|
m_createNOPTimer->stop ();
|
|
}
|
|
}
|
|
|
|
|
|
// Prevent unintentional 1-pixel selections
|
|
if (!m_dragHasBegun && thisPoint == m_startPoint)
|
|
{
|
|
if (m_mode != kpToolSelection::Text)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tnon-text NOP - return" << endl;
|
|
#endif
|
|
setUserShapePoints (thisPoint);
|
|
return;
|
|
}
|
|
else // m_mode == kpToolSelection::Text
|
|
{
|
|
// Attempt to deselect text box by clicking?
|
|
if (m_hadSelectionBeforeDrag)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\ttext box deselect - NOP - return" << endl;
|
|
#endif
|
|
setUserShapePoints (thisPoint);
|
|
return;
|
|
}
|
|
|
|
// Drag-wise, this is a NOP so we'd normally return (hence
|
|
// m_dragHasBegun would not change). However, as a special
|
|
// case, allow user to create a text box using a single
|
|
// click. But don't set m_dragHasBegun for next iteration
|
|
// since it would be untrue.
|
|
//
|
|
// This makes sure that a single click creation of text box
|
|
// works even if draw() is invoked more than once at the
|
|
// same position (esp. with accidental drag suppression
|
|
// (above)).
|
|
nextDragHasBegun = false;
|
|
}
|
|
}
|
|
|
|
|
|
switch (m_mode)
|
|
{
|
|
case kpToolSelection::Rectangle:
|
|
{
|
|
const TQRect usefulRect = normalizedRect.intersect (document ()->rect ());
|
|
document ()->setSelection (kpSelection (kpSelection::Rectangle, usefulRect,
|
|
mainWindow ()->selectionTransparency ()));
|
|
|
|
setUserShapePoints (m_startPoint,
|
|
TQPoint (TQMAX (0, TQMIN (m_currentPoint.x (), document ()->width () - 1)),
|
|
TQMAX (0, TQMIN (m_currentPoint.y (), document ()->height () - 1))));
|
|
break;
|
|
}
|
|
case kpToolSelection::Text:
|
|
{
|
|
const kpTextStyle textStyle = mainWindow ()->textStyle ();
|
|
|
|
int minimumWidth, minimumHeight;
|
|
|
|
// Just a click?
|
|
if (!m_dragHasBegun && thisPoint == m_startPoint)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tclick creating text box" << endl;
|
|
#endif
|
|
|
|
// (Click creating text box with RMB would not be obvious
|
|
// since RMB menu most likely hides text box immediately
|
|
// afterwards)
|
|
if (m_mouseButton == 1)
|
|
break;
|
|
|
|
|
|
minimumWidth = kpSelection::preferredMinimumWidthForTextStyle (textStyle);
|
|
if (thisPoint.x () >= m_startPoint.x ())
|
|
{
|
|
if (m_startPoint.x () + minimumWidth - 1 >= document ()->width ())
|
|
{
|
|
minimumWidth = TQMAX (kpSelection::minimumWidthForTextStyle (textStyle),
|
|
document ()->width () - m_startPoint.x ());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_startPoint.x () - minimumWidth + 1 < 0)
|
|
{
|
|
minimumWidth = TQMAX (kpSelection::minimumWidthForTextStyle (textStyle),
|
|
m_startPoint.x () + 1);
|
|
}
|
|
}
|
|
|
|
minimumHeight = kpSelection::preferredMinimumHeightForTextStyle (textStyle);
|
|
if (thisPoint.y () >= m_startPoint.y ())
|
|
{
|
|
if (m_startPoint.y () + minimumHeight - 1 >= document ()->height ())
|
|
{
|
|
minimumHeight = TQMAX (kpSelection::minimumHeightForTextStyle (textStyle),
|
|
document ()->height () - m_startPoint.y ());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_startPoint.y () - minimumHeight + 1 < 0)
|
|
{
|
|
minimumHeight = TQMAX (kpSelection::minimumHeightForTextStyle (textStyle),
|
|
m_startPoint.y () + 1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tdrag creating text box" << endl;
|
|
#endif
|
|
minimumWidth = kpSelection::minimumWidthForTextStyle (textStyle);
|
|
minimumHeight = kpSelection::minimumHeightForTextStyle (textStyle);
|
|
}
|
|
|
|
|
|
if (normalizedRect.width () < minimumWidth)
|
|
{
|
|
if (thisPoint.x () >= m_startPoint.x ())
|
|
normalizedRect.setWidth (minimumWidth);
|
|
else
|
|
normalizedRect.setX (normalizedRect.right () - minimumWidth + 1);
|
|
}
|
|
|
|
if (normalizedRect.height () < minimumHeight)
|
|
{
|
|
if (thisPoint.y () >= m_startPoint.y ())
|
|
normalizedRect.setHeight (minimumHeight);
|
|
else
|
|
normalizedRect.setY (normalizedRect.bottom () - minimumHeight + 1);
|
|
}
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tnormalizedRect=" << normalizedRect
|
|
<< " kpSelection::preferredMinimumSize="
|
|
<< TQSize (minimumWidth, minimumHeight)
|
|
<< endl;
|
|
#endif
|
|
|
|
TQValueVector <TQString> textLines (1, TQString ());
|
|
kpSelection sel (normalizedRect, textLines, textStyle);
|
|
|
|
if (!m_currentCreateTextCommand)
|
|
{
|
|
m_currentCreateTextCommand = new kpToolSelectionCreateCommand (
|
|
i18n ("Text: Create Box"),
|
|
sel,
|
|
mainWindow ());
|
|
}
|
|
else
|
|
m_currentCreateTextCommand->setFromSelection (sel);
|
|
|
|
viewManager ()->setTextCursorPosition (0, 0);
|
|
document ()->setSelection (sel);
|
|
|
|
TQPoint actualEndPoint = KP_INVALID_POINT;
|
|
if (m_startPoint == normalizedRect.topLeft ())
|
|
actualEndPoint = normalizedRect.bottomRight ();
|
|
else if (m_startPoint == normalizedRect.bottomRight ())
|
|
actualEndPoint = normalizedRect.topLeft ();
|
|
else if (m_startPoint == normalizedRect.topRight ())
|
|
actualEndPoint = normalizedRect.bottomLeft ();
|
|
else if (m_startPoint == normalizedRect.bottomLeft ())
|
|
actualEndPoint = normalizedRect.topRight ();
|
|
|
|
setUserShapePoints (m_startPoint, actualEndPoint);
|
|
break;
|
|
}
|
|
case kpToolSelection::Ellipse:
|
|
document ()->setSelection (kpSelection (kpSelection::Ellipse, normalizedRect,
|
|
mainWindow ()->selectionTransparency ()));
|
|
setUserShapePoints (m_startPoint, m_currentPoint);
|
|
break;
|
|
case kpToolSelection::FreeForm:
|
|
TQPointArray points;
|
|
|
|
if (document ()->selection ())
|
|
points = document ()->selection ()->points ();
|
|
|
|
|
|
// (not detached so will modify "points" directly but
|
|
// still need to call kpDocument::setSelection() to
|
|
// update screen)
|
|
|
|
if (!m_dragHasBegun)
|
|
{
|
|
// We thought the drag at startPoint was a NOP
|
|
// but it turns out that it wasn't...
|
|
points.putPoints (points.count (), 1, m_startPoint.x (), m_startPoint.y ());
|
|
}
|
|
|
|
// TODO: there should be an upper limit on this before drawing the
|
|
// polygon becomes too slow
|
|
points.putPoints (points.count (), 1, thisPoint.x (), thisPoint.y ());
|
|
|
|
|
|
document ()->setSelection (kpSelection (points, mainWindow ()->selectionTransparency ()));
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tfreeform; #points=" << document ()->selection ()->points ().count () << endl;
|
|
#endif
|
|
|
|
setUserShapePoints (m_currentPoint);
|
|
break;
|
|
}
|
|
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
}
|
|
else if (m_dragType == Move)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tmoving selection" << endl;
|
|
#endif
|
|
|
|
kpSelection *sel = document ()->selection ();
|
|
|
|
TQRect targetSelRect = TQRect (thisPoint.x () - m_startDragFromSelectionTopLeft.x (),
|
|
thisPoint.y () - m_startDragFromSelectionTopLeft.y (),
|
|
sel->width (),
|
|
sel->height ());
|
|
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tstartPoint=" << m_startPoint
|
|
<< " thisPoint=" << thisPoint
|
|
<< " startDragFromSel=" << m_startDragFromSelectionTopLeft
|
|
<< " targetSelRect=" << targetSelRect
|
|
<< endl;
|
|
#endif
|
|
|
|
// Try to make sure selection still intersects document so that it's
|
|
// reachable.
|
|
|
|
if (targetSelRect.right () < 0)
|
|
targetSelRect.moveBy (-targetSelRect.right (), 0);
|
|
else if (targetSelRect.left () >= document ()->width ())
|
|
targetSelRect.moveBy (document ()->width () - targetSelRect.left () - 1, 0);
|
|
|
|
if (targetSelRect.bottom () < 0)
|
|
targetSelRect.moveBy (0, -targetSelRect.bottom ());
|
|
else if (targetSelRect.top () >= document ()->height ())
|
|
targetSelRect.moveBy (0, document ()->height () - targetSelRect.top () - 1);
|
|
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\t\tafter ensure sel rect clickable=" << targetSelRect << endl;
|
|
#endif
|
|
|
|
|
|
if (!m_dragHasBegun &&
|
|
targetSelRect.topLeft () + m_startDragFromSelectionTopLeft == m_startPoint)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\t\t\tnop" << endl;
|
|
#endif
|
|
|
|
|
|
if (!m_RMBMoveUpdateGUITimer->isActive ())
|
|
{
|
|
// (slotRMBMoveUpdateGUI() calls similar line)
|
|
setUserShapePoints (sel->topLeft ());
|
|
}
|
|
|
|
// Prevent both NOP drag-moves
|
|
return;
|
|
}
|
|
|
|
|
|
if (m_RMBMoveUpdateGUITimer->isActive ())
|
|
{
|
|
m_RMBMoveUpdateGUITimer->stop ();
|
|
slotRMBMoveUpdateGUI ();
|
|
}
|
|
|
|
|
|
if (!sel->pixmap () && !m_currentPullFromDocumentCommand)
|
|
{
|
|
m_currentPullFromDocumentCommand = new kpToolSelectionPullFromDocumentCommand (
|
|
TQString()/*uninteresting child of macro cmd*/,
|
|
mainWindow ());
|
|
m_currentPullFromDocumentCommand->execute ();
|
|
}
|
|
|
|
if (!m_currentMoveCommand)
|
|
{
|
|
m_currentMoveCommand = new kpToolSelectionMoveCommand (
|
|
TQString()/*uninteresting child of macro cmd*/,
|
|
mainWindow ());
|
|
m_currentMoveCommandIsSmear = false;
|
|
}
|
|
|
|
|
|
//viewManager ()->setQueueUpdates ();
|
|
//viewManager ()->setFastUpdates ();
|
|
|
|
if (m_shiftPressed)
|
|
m_currentMoveCommandIsSmear = true;
|
|
|
|
if (!m_dragHasBegun && (m_controlPressed || m_shiftPressed))
|
|
m_currentMoveCommand->copyOntoDocument ();
|
|
|
|
m_currentMoveCommand->moveTo (targetSelRect.topLeft ());
|
|
|
|
if (m_shiftPressed)
|
|
m_currentMoveCommand->copyOntoDocument ();
|
|
|
|
//viewManager ()->restoreFastUpdates ();
|
|
//viewManager ()->restoreQueueUpdates ();
|
|
|
|
TQPoint start = m_currentMoveCommand->originalSelection ().topLeft ();
|
|
TQPoint end = targetSelRect.topLeft ();
|
|
setUserShapePoints (start, end, false/*don't set size*/);
|
|
setUserShapeSize (end.x () - start.x (), end.y () - start.y ());
|
|
}
|
|
else if (m_dragType == ResizeScale)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tresize/scale" << endl;
|
|
#endif
|
|
|
|
kpSelection *sel = document ()->selection ();
|
|
|
|
if (!m_dragHasBegun && thisPoint == m_startPoint)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tnop" << endl;
|
|
#endif
|
|
|
|
setUserShapePoints (TQPoint (sel->width (), sel->height ()));
|
|
return;
|
|
}
|
|
|
|
|
|
if (!sel->pixmap () && !m_currentPullFromDocumentCommand)
|
|
{
|
|
m_currentPullFromDocumentCommand = new kpToolSelectionPullFromDocumentCommand (
|
|
TQString()/*uninteresting child of macro cmd*/,
|
|
mainWindow ());
|
|
m_currentPullFromDocumentCommand->execute ();
|
|
}
|
|
|
|
if (!m_currentResizeScaleCommand)
|
|
{
|
|
m_currentResizeScaleCommand = new kpToolSelectionResizeScaleCommand (mainWindow ());
|
|
}
|
|
|
|
|
|
kpSelection originalSelection = m_currentResizeScaleCommand->originalSelection ();
|
|
const int oldWidth = originalSelection.width ();
|
|
const int oldHeight = originalSelection.height ();
|
|
|
|
|
|
// Determine new width.
|
|
|
|
int userXSign = 0;
|
|
if (m_resizeScaleType & kpView::Left)
|
|
userXSign = -1;
|
|
else if (m_resizeScaleType & kpView::Right)
|
|
userXSign = +1;
|
|
|
|
int newWidth = oldWidth + userXSign * (thisPoint.x () - m_startPoint.x ());
|
|
|
|
newWidth = TQMAX (originalSelection.minimumWidth (), newWidth);
|
|
|
|
|
|
// Determine new height.
|
|
|
|
int userYSign = 0;
|
|
if (m_resizeScaleType & kpView::Top)
|
|
userYSign = -1;
|
|
else if (m_resizeScaleType & kpView::Bottom)
|
|
userYSign = +1;
|
|
|
|
int newHeight = oldHeight + userYSign * (thisPoint.y () - m_startPoint.y ());
|
|
|
|
newHeight = TQMAX (originalSelection.minimumHeight (), newHeight);
|
|
|
|
|
|
// Keep aspect ratio?
|
|
if (m_shiftPressed && !sel->isText ())
|
|
{
|
|
// Width changed more than height? At equality, favour width.
|
|
// Fix width, change height.
|
|
if ((userXSign ? double (newWidth) / oldWidth : 0) >=
|
|
(userYSign ? double (newHeight) / oldHeight : 0))
|
|
{
|
|
newHeight = newWidth * oldHeight / oldWidth;
|
|
newHeight = TQMAX (originalSelection.minimumHeight (),
|
|
newHeight);
|
|
}
|
|
// Height changed more than width?
|
|
// Fix height, change width.
|
|
else
|
|
{
|
|
newWidth = newHeight * oldWidth / oldHeight;
|
|
newWidth = TQMAX (originalSelection.minimumWidth (), newWidth);
|
|
}
|
|
}
|
|
|
|
|
|
// Adjust x/y to new width/height for left/top resizes.
|
|
|
|
int newX = originalSelection.x ();
|
|
int newY = originalSelection.y ();
|
|
|
|
if (m_resizeScaleType & kpView::Left)
|
|
{
|
|
newX -= (newWidth - originalSelection.width ());
|
|
}
|
|
|
|
if (m_resizeScaleType & kpView::Top)
|
|
{
|
|
newY -= (newHeight - originalSelection.height ());
|
|
}
|
|
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\t\tnewX=" << newX
|
|
<< " newY=" << newY
|
|
<< " newWidth=" << newWidth
|
|
<< " newHeight=" << newHeight
|
|
<< endl;
|
|
#endif
|
|
|
|
|
|
viewManager ()->setFastUpdates ();
|
|
m_currentResizeScaleCommand->resizeAndMoveTo (newWidth, newHeight,
|
|
TQPoint (newX, newY),
|
|
true/*smooth scale delayed*/);
|
|
viewManager ()->restoreFastUpdates ();
|
|
|
|
setUserShapePoints (TQPoint (originalSelection.width (),
|
|
originalSelection.height ()),
|
|
TQPoint (newWidth,
|
|
newHeight),
|
|
false/*don't set size*/);
|
|
setUserShapeSize (newWidth - originalSelection.width (),
|
|
newHeight - originalSelection.height ());
|
|
}
|
|
|
|
|
|
m_dragHasBegun = nextDragHasBegun;
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::cancelShape ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::cancelShape() mouseButton=" << m_mouseButton << endl;
|
|
#endif
|
|
|
|
m_createNOPTimer->stop ();
|
|
m_RMBMoveUpdateGUITimer->stop ();
|
|
|
|
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
if (m_dragType == Move)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\twas drag moving - undo drag and undo acquire" << endl;
|
|
#endif
|
|
|
|
if (m_currentMoveCommand)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tundo currentMoveCommand" << endl;
|
|
#endif
|
|
m_currentMoveCommand->finalize ();
|
|
m_currentMoveCommand->unexecute ();
|
|
delete m_currentMoveCommand;
|
|
m_currentMoveCommand = 0;
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
}
|
|
else if (m_dragType == Create)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\twas creating sel - kill" << endl;
|
|
#endif
|
|
|
|
// TODO: should we give the user back the selection s/he had before (if any)?
|
|
document ()->selectionDelete ();
|
|
|
|
if (m_currentCreateTextCommand)
|
|
{
|
|
delete m_currentCreateTextCommand;
|
|
m_currentCreateTextCommand = 0;
|
|
}
|
|
}
|
|
else if (m_dragType == ResizeScale)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\twas resize/scale sel - kill" << endl;
|
|
#endif
|
|
|
|
if (m_currentResizeScaleCommand)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tundo currentResizeScaleCommand" << endl;
|
|
#endif
|
|
m_currentResizeScaleCommand->finalize (); // (unneeded but let's be safe)
|
|
m_currentResizeScaleCommand->unexecute ();
|
|
delete m_currentResizeScaleCommand;
|
|
m_currentResizeScaleCommand = 0;
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
}
|
|
|
|
|
|
if (m_currentPullFromDocumentCommand)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\tundo pullFromDocumentCommand" << endl;
|
|
#endif
|
|
m_currentPullFromDocumentCommand->unexecute ();
|
|
delete m_currentPullFromDocumentCommand;
|
|
m_currentPullFromDocumentCommand = 0;
|
|
}
|
|
|
|
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
viewManager ()->setSelectionBorderFinished (true);
|
|
viewManager ()->setTextCursorEnabled (m_mode == Text && true);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
|
|
|
|
m_dragType = Unknown;
|
|
m_cancelledShapeButStillHoldingButtons = true;
|
|
setUserMessage (i18n ("Let go of all the mouse buttons."));
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::releasedAllButtons ()
|
|
{
|
|
m_cancelledShapeButStillHoldingButtons = false;
|
|
setUserMessage (haventBegunDrawUserMessage ());
|
|
}
|
|
|
|
// virtual
|
|
void kpToolSelection::endDraw (const TQPoint & /*thisPoint*/, const TQRect & /*normalizedRect*/)
|
|
{
|
|
m_createNOPTimer->stop ();
|
|
m_RMBMoveUpdateGUITimer->stop ();
|
|
|
|
|
|
viewManager ()->setQueueUpdates ();
|
|
{
|
|
if (m_currentCreateTextCommand)
|
|
{
|
|
commandHistory ()->addCommand (m_currentCreateTextCommand, false/*no exec*/);
|
|
m_currentCreateTextCommand = 0;
|
|
}
|
|
|
|
kpMacroCommand *cmd = 0;
|
|
if (m_currentMoveCommand)
|
|
{
|
|
if (m_currentMoveCommandIsSmear)
|
|
{
|
|
cmd = new kpMacroCommand (i18n ("%1: Smear")
|
|
.arg (document ()->selection ()->name ()),
|
|
mainWindow ());
|
|
}
|
|
else
|
|
{
|
|
cmd = new kpMacroCommand ((document ()->selection ()->isText () ?
|
|
i18n ("Text: Move Box") :
|
|
i18n ("Selection: Move")),
|
|
mainWindow ());
|
|
}
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
else if (m_currentResizeScaleCommand)
|
|
{
|
|
cmd = new kpMacroCommand (m_currentResizeScaleCommand->kpNamedCommand::name (),
|
|
mainWindow ());
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
|
|
if (m_currentPullFromDocumentCommand)
|
|
{
|
|
if (!m_currentMoveCommand && !m_currentResizeScaleCommand)
|
|
{
|
|
kdError () << "kpToolSelection::endDraw() pull without move nor resize/scale" << endl;
|
|
delete m_currentPullFromDocumentCommand;
|
|
m_currentPullFromDocumentCommand = 0;
|
|
}
|
|
else
|
|
{
|
|
kpSelection selection;
|
|
|
|
if (m_currentMoveCommand)
|
|
selection = m_currentMoveCommand->originalSelection ();
|
|
else if (m_currentResizeScaleCommand)
|
|
selection = m_currentResizeScaleCommand->originalSelection ();
|
|
|
|
// just the border
|
|
selection.setPixmap (TQPixmap ());
|
|
|
|
kpCommand *createCommand = new kpToolSelectionCreateCommand (
|
|
i18n ("Selection: Create"),
|
|
selection,
|
|
mainWindow ());
|
|
|
|
if (kpToolSelectionCreateCommand::nextUndoCommandIsCreateBorder (commandHistory ()))
|
|
commandHistory ()->setNextUndoCommand (createCommand);
|
|
else
|
|
commandHistory ()->addCommand (createCommand,
|
|
false/*no exec - user already dragged out sel*/);
|
|
|
|
|
|
cmd->addCommand (m_currentPullFromDocumentCommand);
|
|
m_currentPullFromDocumentCommand = 0;
|
|
}
|
|
}
|
|
|
|
if (m_currentMoveCommand)
|
|
{
|
|
m_currentMoveCommand->finalize ();
|
|
cmd->addCommand (m_currentMoveCommand);
|
|
m_currentMoveCommand = 0;
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
|
|
if (m_currentResizeScaleCommand)
|
|
{
|
|
m_currentResizeScaleCommand->finalize ();
|
|
cmd->addCommand (m_currentResizeScaleCommand);
|
|
m_currentResizeScaleCommand = 0;
|
|
|
|
if (document ()->selection ()->isText ())
|
|
viewManager ()->setTextCursorBlinkState (true);
|
|
}
|
|
|
|
if (cmd)
|
|
commandHistory ()->addCommand (cmd, false/*no exec*/);
|
|
|
|
viewManager ()->setSelectionBorderVisible (true);
|
|
viewManager ()->setSelectionBorderFinished (true);
|
|
viewManager ()->setTextCursorEnabled (m_mode == Text && true);
|
|
}
|
|
viewManager ()->restoreQueueUpdates ();
|
|
|
|
|
|
m_dragType = Unknown;
|
|
setUserMessage (haventBegunDrawUserMessage ());
|
|
|
|
|
|
if (m_mouseButton == 1/*right*/)
|
|
popupRMBMenu ();
|
|
}
|
|
|
|
|
|
// protected virtual [base kpTool]
|
|
void kpToolSelection::keyPressEvent (TQKeyEvent *e)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 0
|
|
kdDebug () << "kpToolSelection::keyPressEvent(e->text='" << e->text () << "')" << endl;
|
|
#endif
|
|
|
|
|
|
e->ignore ();
|
|
|
|
|
|
if (document ()->selection () &&
|
|
!hasBegunDraw () &&
|
|
e->key () == TQt::Key_Escape)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 0
|
|
kdDebug () << "\tescape pressed with sel when not begun draw - deselecting" << endl;
|
|
#endif
|
|
|
|
pushOntoDocument ();
|
|
e->accept ();
|
|
}
|
|
|
|
|
|
if (!e->isAccepted ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 0
|
|
kdDebug () << "\tkey processing did not accept (text was '"
|
|
<< e->text ()
|
|
<< "') - passing on event to kpTool"
|
|
<< endl;
|
|
#endif
|
|
|
|
kpTool::keyPressEvent (e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
// private slot
|
|
void kpToolSelection::selectionTransparencyChanged (const TQString & /*name*/)
|
|
{
|
|
#if 0
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::selectionTransparencyChanged(" << name << ")" << endl;
|
|
#endif
|
|
|
|
if (mainWindow ()->settingSelectionTransparency ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\trecursion - abort setting selection transparency: "
|
|
<< mainWindow ()->settingSelectionTransparency () << endl;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (document ()->selection ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\thave sel - set transparency" << endl;
|
|
#endif
|
|
|
|
kpSelectionTransparency oldST = document ()->selection ()->transparency ();
|
|
kpSelectionTransparency st = mainWindow ()->selectionTransparency ();
|
|
|
|
// TODO: This "NOP" check causes us a great deal of trouble e.g.:
|
|
//
|
|
// Select a solid red rectangle.
|
|
// Switch to transparent and set red as the background colour.
|
|
// (the selection is now invisible)
|
|
// Invert Colours.
|
|
// (the selection is now cyan)
|
|
// Change the background colour to green.
|
|
// (no command is added to undo this as the selection does not change)
|
|
// Undo.
|
|
// The rectangle is no longer invisible.
|
|
//
|
|
//if (document ()->selection ()->setTransparency (st, true/*check harder for no change in mask*/))
|
|
|
|
document ()->selection ()->setTransparency (st);
|
|
if (true)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\t\twhich changed the pixmap" << endl;
|
|
#endif
|
|
|
|
commandHistory ()->addCommand (new kpToolSelectionTransparencyCommand (
|
|
i18n ("Selection: Transparency"), // name,
|
|
st, oldST,
|
|
mainWindow ()),
|
|
false/* no exec*/);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// TODO: I've duplicated the code (see below 3x) to make sure
|
|
// kpSelectionTransparency(oldST)::transparentColor() is defined
|
|
// and not taken from kpDocument (where it may not be defined because
|
|
// the transparency may be opaque).
|
|
//
|
|
// That way kpToolSelectionTransparencyCommand can force set colours.
|
|
}
|
|
|
|
|
|
// protected slot virtual
|
|
void kpToolSelection::slotIsOpaqueChanged ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::slotIsOpaqueChanged()" << endl;
|
|
#endif
|
|
|
|
if (mainWindow ()->settingSelectionTransparency ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\trecursion - abort setting selection transparency: "
|
|
<< mainWindow ()->settingSelectionTransparency () << endl;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (document ()->selection ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\thave sel - set transparency" << endl;
|
|
#endif
|
|
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
if (hasBegunShape ())
|
|
endShapeInternal ();
|
|
|
|
kpSelectionTransparency st = mainWindow ()->selectionTransparency ();
|
|
kpSelectionTransparency oldST = st;
|
|
oldST.setOpaque (!oldST.isOpaque ());
|
|
|
|
document ()->selection ()->setTransparency (st);
|
|
commandHistory ()->addCommand (new kpToolSelectionTransparencyCommand (
|
|
st.isOpaque () ?
|
|
i18n ("Selection: Opaque") :
|
|
i18n ("Selection: Transparent"),
|
|
st, oldST,
|
|
mainWindow ()),
|
|
false/* no exec*/);
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
}
|
|
|
|
// protected slot virtual [base kpTool]
|
|
void kpToolSelection::slotBackgroundColorChanged (const kpColor &)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::slotBackgroundColorChanged()" << endl;
|
|
#endif
|
|
|
|
if (mainWindow ()->settingSelectionTransparency ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\trecursion - abort setting selection transparency: "
|
|
<< mainWindow ()->settingSelectionTransparency () << endl;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (document ()->selection ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\thave sel - set transparency" << endl;
|
|
#endif
|
|
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
kpSelectionTransparency st = mainWindow ()->selectionTransparency ();
|
|
kpSelectionTransparency oldST = st;
|
|
oldST.setTransparentColor (oldBackgroundColor ());
|
|
|
|
document ()->selection ()->setTransparency (st);
|
|
commandHistory ()->addCommand (new kpToolSelectionTransparencyCommand (
|
|
i18n ("Selection: Transparency Color"),
|
|
st, oldST,
|
|
mainWindow ()),
|
|
false/* no exec*/);
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
}
|
|
|
|
// protected slot virtual [base kpTool]
|
|
void kpToolSelection::slotColorSimilarityChanged (double, int)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelection::slotColorSimilarityChanged()" << endl;
|
|
#endif
|
|
|
|
if (mainWindow ()->settingSelectionTransparency ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\trecursion - abort setting selection transparency: "
|
|
<< mainWindow ()->settingSelectionTransparency () << endl;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (document ()->selection ())
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\thave sel - set transparency" << endl;
|
|
#endif
|
|
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
kpSelectionTransparency st = mainWindow ()->selectionTransparency ();
|
|
kpSelectionTransparency oldST = st;
|
|
oldST.setColorSimilarity (oldColorSimilarity ());
|
|
|
|
document ()->selection ()->setTransparency (st);
|
|
commandHistory ()->addCommand (new kpToolSelectionTransparencyCommand (
|
|
i18n ("Selection: Transparency Color Similarity"),
|
|
st, oldST,
|
|
mainWindow ()),
|
|
false/* no exec*/);
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionCreateCommand
|
|
*/
|
|
|
|
kpToolSelectionCreateCommand::kpToolSelectionCreateCommand (const TQString &name,
|
|
const kpSelection &fromSelection,
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (name, mainWindow),
|
|
m_fromSelection (0),
|
|
m_textRow (0), m_textCol (0)
|
|
{
|
|
setFromSelection (fromSelection);
|
|
}
|
|
|
|
kpToolSelectionCreateCommand::~kpToolSelectionCreateCommand ()
|
|
{
|
|
delete m_fromSelection;
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
int kpToolSelectionCreateCommand::size () const
|
|
{
|
|
return kpPixmapFX::selectionSize (m_fromSelection);
|
|
}
|
|
|
|
|
|
// public static
|
|
bool kpToolSelectionCreateCommand::nextUndoCommandIsCreateBorder (
|
|
kpCommandHistory *commandHistory)
|
|
{
|
|
if (!commandHistory)
|
|
return false;
|
|
|
|
kpCommand *cmd = commandHistory->nextUndoCommand ();
|
|
if (!cmd)
|
|
return false;
|
|
|
|
kpToolSelectionCreateCommand *c = dynamic_cast <kpToolSelectionCreateCommand *> (cmd);
|
|
if (!c)
|
|
return false;
|
|
|
|
const kpSelection *sel = c->fromSelection ();
|
|
if (!sel)
|
|
return false;
|
|
|
|
return (!sel->pixmap ());
|
|
}
|
|
|
|
|
|
// public
|
|
const kpSelection *kpToolSelectionCreateCommand::fromSelection () const
|
|
{
|
|
return m_fromSelection;
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionCreateCommand::setFromSelection (const kpSelection &fromSelection)
|
|
{
|
|
delete m_fromSelection;
|
|
m_fromSelection = new kpSelection (fromSelection);
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionCreateCommand::execute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionCreateCommand::execute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionCreateCommand::execute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
if (m_fromSelection)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\tusing fromSelection" << endl;
|
|
kdDebug () << "\t\thave sel=" << doc->selection ()
|
|
<< " pixmap=" << (doc->selection () ? doc->selection ()->pixmap () : 0)
|
|
<< endl;
|
|
#endif
|
|
if (!m_fromSelection->isText ())
|
|
{
|
|
if (m_fromSelection->transparency () != m_mainWindow->selectionTransparency ())
|
|
m_mainWindow->setSelectionTransparency (m_fromSelection->transparency ());
|
|
}
|
|
else
|
|
{
|
|
if (m_fromSelection->textStyle () != m_mainWindow->textStyle ())
|
|
m_mainWindow->setTextStyle (m_fromSelection->textStyle ());
|
|
}
|
|
|
|
m_mainWindow->viewManager ()->setTextCursorPosition (m_textRow, m_textCol);
|
|
doc->setSelection (*m_fromSelection);
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
}
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionCreateCommand::unexecute ()
|
|
{
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionCreateCommand::unexecute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
if (!doc->selection ())
|
|
{
|
|
// Was just a border that got deselected?
|
|
if (m_fromSelection && !m_fromSelection->pixmap ())
|
|
return;
|
|
|
|
kdError () << "kpToolSelectionCreateCommand::unexecute() without sel region" << endl;
|
|
return;
|
|
}
|
|
|
|
m_textRow = m_mainWindow->viewManager ()->textCursorRow ();
|
|
m_textCol = m_mainWindow->viewManager ()->textCursorCol ();
|
|
|
|
doc->selectionDelete ();
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionPullFromDocumentCommand
|
|
*/
|
|
|
|
kpToolSelectionPullFromDocumentCommand::kpToolSelectionPullFromDocumentCommand (const TQString &name,
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (name, mainWindow),
|
|
m_backgroundColor (mainWindow ? mainWindow->backgroundColor () : kpColor::invalid),
|
|
m_originalSelectionRegion (0)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionPullFromDocumentCommand::<ctor>() mainWindow="
|
|
<< m_mainWindow
|
|
<< endl;
|
|
#endif
|
|
}
|
|
|
|
kpToolSelectionPullFromDocumentCommand::~kpToolSelectionPullFromDocumentCommand ()
|
|
{
|
|
delete m_originalSelectionRegion;
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
int kpToolSelectionPullFromDocumentCommand::size () const
|
|
{
|
|
return kpPixmapFX::selectionSize (m_originalSelectionRegion);
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionPullFromDocumentCommand::execute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionPullFromDocumentCommand::execute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionPullFromDocumentCommand::execute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
kpViewManager *vm = m_mainWindow ? m_mainWindow->viewManager () : 0;
|
|
if (vm)
|
|
vm->setQueueUpdates ();
|
|
|
|
// In case the user CTRL+Z'ed, selected a random region to throw us off
|
|
// and then CTRL+Shift+Z'ed putting us here. Make sure we pull from the
|
|
// originally requested region - not the random one.
|
|
if (m_originalSelectionRegion)
|
|
{
|
|
if (m_originalSelectionRegion->transparency () != m_mainWindow->selectionTransparency ())
|
|
m_mainWindow->setSelectionTransparency (m_originalSelectionRegion->transparency ());
|
|
|
|
doc->setSelection (*m_originalSelectionRegion);
|
|
}
|
|
else
|
|
{
|
|
// must have selection region but not pixmap
|
|
if (!doc->selection () || doc->selection ()->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionPullFromDocumentCommand::execute() sel="
|
|
<< doc->selection ()
|
|
<< " pixmap="
|
|
<< (doc->selection () ? doc->selection ()->pixmap () : 0)
|
|
<< endl;
|
|
if (vm)
|
|
vm->restoreQueueUpdates ();
|
|
return;
|
|
}
|
|
}
|
|
|
|
doc->selectionPullFromDocument (m_backgroundColor);
|
|
|
|
if (vm)
|
|
vm->restoreQueueUpdates ();
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionPullFromDocumentCommand::unexecute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionPullFromDocumentCommand::unexecute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionPullFromDocumentCommand::unexecute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
// must have selection pixmap
|
|
if (!doc->selection () || !doc->selection ()->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionPullFromDocumentCommand::unexecute() sel="
|
|
<< doc->selection ()
|
|
<< " pixmap="
|
|
<< (doc->selection () ? doc->selection ()->pixmap () : 0)
|
|
<< endl;
|
|
return;
|
|
}
|
|
|
|
|
|
// We can have faith that this is the state of the selection after
|
|
// execute(), rather than after the user tried to throw us off by
|
|
// simply selecting another region as to do that, a destroy command
|
|
// must have been used.
|
|
doc->selectionCopyOntoDocument (false/*use opaque pixmap*/);
|
|
doc->selection ()->setPixmap (TQPixmap ());
|
|
|
|
delete m_originalSelectionRegion;
|
|
m_originalSelectionRegion = new kpSelection (*doc->selection ());
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionTransparencyCommand
|
|
*/
|
|
|
|
kpToolSelectionTransparencyCommand::kpToolSelectionTransparencyCommand (const TQString &name,
|
|
const kpSelectionTransparency &st,
|
|
const kpSelectionTransparency &oldST,
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (name, mainWindow),
|
|
m_st (st),
|
|
m_oldST (oldST)
|
|
{
|
|
}
|
|
|
|
kpToolSelectionTransparencyCommand::~kpToolSelectionTransparencyCommand ()
|
|
{
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
int kpToolSelectionTransparencyCommand::size () const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionTransparencyCommand::execute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionTransparencyCommand::execute()" << endl;
|
|
#endif
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
return;
|
|
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
m_mainWindow->setSelectionTransparency (m_st, true/*force colour change*/);
|
|
|
|
if (doc->selection ())
|
|
doc->selection ()->setTransparency (m_st);
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionTransparencyCommand::unexecute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionTransparencyCommand::unexecute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
return;
|
|
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
m_mainWindow->setSelectionTransparency (m_oldST, true/*force colour change*/);
|
|
|
|
if (doc->selection ())
|
|
doc->selection ()->setTransparency (m_oldST);
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionMoveCommand
|
|
*/
|
|
|
|
kpToolSelectionMoveCommand::kpToolSelectionMoveCommand (const TQString &name,
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (name, mainWindow)
|
|
{
|
|
kpDocument *doc = document ();
|
|
if (doc && doc->selection ())
|
|
{
|
|
m_startPoint = m_endPoint = doc->selection ()->topLeft ();
|
|
}
|
|
}
|
|
|
|
kpToolSelectionMoveCommand::~kpToolSelectionMoveCommand ()
|
|
{
|
|
}
|
|
|
|
|
|
// public
|
|
kpSelection kpToolSelectionMoveCommand::originalSelection () const
|
|
{
|
|
kpDocument *doc = document ();
|
|
if (!doc || !doc->selection ())
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::originalSelection() doc="
|
|
<< doc
|
|
<< " sel="
|
|
<< (doc ? doc->selection () : 0)
|
|
<< endl;
|
|
return kpSelection (kpSelection::Rectangle, TQRect ());
|
|
}
|
|
|
|
kpSelection selection = *doc->selection();
|
|
selection.moveTo (m_startPoint);
|
|
|
|
return selection;
|
|
}
|
|
|
|
|
|
// public virtual [base kpComand]
|
|
int kpToolSelectionMoveCommand::size () const
|
|
{
|
|
return kpPixmapFX::pixmapSize (m_oldDocumentPixmap) +
|
|
kpPixmapFX::pointArraySize (m_copyOntoDocumentPoints);
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionMoveCommand::execute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionMoveCommand::execute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::execute() no doc" << endl;
|
|
return;
|
|
}
|
|
|
|
kpSelection *sel = doc->selection ();
|
|
|
|
// have to have pulled pixmap by now
|
|
if (!sel || !sel->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::execute() but haven't pulled pixmap yet: "
|
|
<< "sel=" << sel << " sel->pixmap=" << (sel ? sel->pixmap () : 0)
|
|
<< endl;
|
|
return;
|
|
}
|
|
|
|
kpViewManager *vm = m_mainWindow ? m_mainWindow->viewManager () : 0;
|
|
|
|
if (vm)
|
|
vm->setQueueUpdates ();
|
|
|
|
TQPointArray::ConstIterator copyOntoDocumentPointsEnd = m_copyOntoDocumentPoints.end ();
|
|
for (TQPointArray::ConstIterator it = m_copyOntoDocumentPoints.begin ();
|
|
it != copyOntoDocumentPointsEnd;
|
|
it++)
|
|
{
|
|
sel->moveTo (*it);
|
|
doc->selectionCopyOntoDocument ();
|
|
}
|
|
|
|
sel->moveTo (m_endPoint);
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
|
|
if (vm)
|
|
vm->restoreQueueUpdates ();
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionMoveCommand::unexecute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "kpToolSelectionMoveCommand::unexecute()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::unexecute() no doc" << endl;
|
|
return;
|
|
}
|
|
|
|
kpSelection *sel = doc->selection ();
|
|
|
|
// have to have pulled pixmap by now
|
|
if (!sel || !sel->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::unexecute() but haven't pulled pixmap yet: "
|
|
<< "sel=" << sel << " sel->pixmap=" << (sel ? sel->pixmap () : 0)
|
|
<< endl;
|
|
return;
|
|
}
|
|
|
|
kpViewManager *vm = m_mainWindow ? m_mainWindow->viewManager () : 0;
|
|
|
|
if (vm)
|
|
vm->setQueueUpdates ();
|
|
|
|
if (!m_oldDocumentPixmap.isNull ())
|
|
doc->setPixmapAt (m_oldDocumentPixmap, m_documentBoundingRect.topLeft ());
|
|
#if DEBUG_KP_TOOL_SELECTION && 1
|
|
kdDebug () << "\tmove to startPoint=" << m_startPoint << endl;
|
|
#endif
|
|
sel->moveTo (m_startPoint);
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
|
|
if (vm)
|
|
vm->restoreQueueUpdates ();
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionMoveCommand::moveTo (const TQPoint &point, bool moveLater)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION && 0
|
|
kdDebug () << "kpToolSelectionMoveCommand::moveTo" << point
|
|
<< " moveLater=" << moveLater
|
|
<<endl;
|
|
#endif
|
|
|
|
if (!moveLater)
|
|
{
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::moveTo() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
kpSelection *sel = doc->selection ();
|
|
|
|
// have to have pulled pixmap by now
|
|
if (!sel)
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::moveTo() no sel region" << endl;
|
|
return;
|
|
}
|
|
|
|
if (!sel->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::moveTo() no sel pixmap" << endl;
|
|
return;
|
|
}
|
|
|
|
if (point == sel->topLeft ())
|
|
return;
|
|
|
|
sel->moveTo (point);
|
|
}
|
|
|
|
m_endPoint = point;
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionMoveCommand::moveTo (int x, int y, bool moveLater)
|
|
{
|
|
moveTo (TQPoint (x, y), moveLater);
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionMoveCommand::copyOntoDocument ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionMoveCommand::copyOntoDocument()" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
return;
|
|
|
|
kpSelection *sel = doc->selection ();
|
|
|
|
// have to have pulled pixmap by now
|
|
if (!sel)
|
|
{
|
|
kdError () << "\tkpToolSelectionMoveCommand::copyOntoDocument() without sel region" << endl;
|
|
return;
|
|
}
|
|
|
|
if (!sel->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionMoveCommand::moveTo() no sel pixmap" << endl;
|
|
return;
|
|
}
|
|
|
|
if (m_oldDocumentPixmap.isNull ())
|
|
m_oldDocumentPixmap = *doc->pixmap ();
|
|
|
|
TQRect selBoundingRect = sel->boundingRect ();
|
|
m_documentBoundingRect.unite (selBoundingRect);
|
|
|
|
doc->selectionCopyOntoDocument ();
|
|
|
|
m_copyOntoDocumentPoints.putPoints (m_copyOntoDocumentPoints.count (),
|
|
1,
|
|
selBoundingRect.x (),
|
|
selBoundingRect.y ());
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionMoveCommand::finalize ()
|
|
{
|
|
if (!m_oldDocumentPixmap.isNull () && !m_documentBoundingRect.isNull ())
|
|
{
|
|
m_oldDocumentPixmap = kpTool::neededPixmap (m_oldDocumentPixmap,
|
|
m_documentBoundingRect);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionResizeScaleCommand
|
|
*/
|
|
|
|
kpToolSelectionResizeScaleCommand::kpToolSelectionResizeScaleCommand (
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (mainWindow->document ()->selection ()->isText () ?
|
|
i18n ("Text: Resize Box") :
|
|
i18n ("Selection: Smooth Scale"),
|
|
mainWindow),
|
|
m_smoothScaleTimer (new TQTimer (this))
|
|
{
|
|
m_originalSelection = *selection ();
|
|
|
|
m_newTopLeft = selection ()->topLeft ();
|
|
m_newWidth = selection ()->width ();
|
|
m_newHeight = selection ()->height ();
|
|
|
|
connect (m_smoothScaleTimer, TQ_SIGNAL (timeout ()),
|
|
this, TQ_SLOT (resizeScaleAndMove ()));
|
|
}
|
|
|
|
kpToolSelectionResizeScaleCommand::~kpToolSelectionResizeScaleCommand ()
|
|
{
|
|
}
|
|
|
|
|
|
// public virtual
|
|
int kpToolSelectionResizeScaleCommand::size () const
|
|
{
|
|
return m_originalSelection.size ();
|
|
}
|
|
|
|
|
|
// public
|
|
kpSelection kpToolSelectionResizeScaleCommand::originalSelection () const
|
|
{
|
|
return m_originalSelection;
|
|
}
|
|
|
|
|
|
// public
|
|
TQPoint kpToolSelectionResizeScaleCommand::topLeft () const
|
|
{
|
|
return m_newTopLeft;
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionResizeScaleCommand::moveTo (const TQPoint &point)
|
|
{
|
|
if (point == m_newTopLeft)
|
|
return;
|
|
|
|
m_newTopLeft = point;
|
|
selection ()->moveTo (m_newTopLeft);
|
|
}
|
|
|
|
|
|
// public
|
|
int kpToolSelectionResizeScaleCommand::width () const
|
|
{
|
|
return m_newWidth;
|
|
}
|
|
|
|
// public
|
|
int kpToolSelectionResizeScaleCommand::height () const
|
|
{
|
|
return m_newHeight;
|
|
}
|
|
|
|
// public
|
|
void kpToolSelectionResizeScaleCommand::resize (int width, int height,
|
|
bool delayed)
|
|
{
|
|
if (width == m_newWidth && height == m_newHeight)
|
|
return;
|
|
|
|
m_newWidth = width;
|
|
m_newHeight = height;
|
|
|
|
resizeScaleAndMove (delayed);
|
|
}
|
|
|
|
|
|
// public
|
|
void kpToolSelectionResizeScaleCommand::resizeAndMoveTo (int width, int height,
|
|
const TQPoint &point,
|
|
bool delayed)
|
|
{
|
|
if (width == m_newWidth && height == m_newHeight &&
|
|
point == m_newTopLeft)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_newWidth = width;
|
|
m_newHeight = height;
|
|
m_newTopLeft = point;
|
|
|
|
resizeScaleAndMove (delayed);
|
|
}
|
|
|
|
|
|
// protected
|
|
void kpToolSelectionResizeScaleCommand::killSmoothScaleTimer ()
|
|
{
|
|
m_smoothScaleTimer->stop ();
|
|
}
|
|
|
|
|
|
// protected
|
|
void kpToolSelectionResizeScaleCommand::resizeScaleAndMove (bool delayed)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionResizeScaleCommand::resizeScaleAndMove(delayed="
|
|
<< delayed << ")" << endl;
|
|
#endif
|
|
|
|
killSmoothScaleTimer ();
|
|
|
|
kpSelection newSel;
|
|
|
|
if (selection ()->isText ())
|
|
{
|
|
newSel = m_originalSelection;
|
|
newSel.textResize (m_newWidth, m_newHeight);
|
|
}
|
|
else
|
|
{
|
|
newSel = kpSelection (kpSelection::Rectangle,
|
|
TQRect (m_originalSelection.x (),
|
|
m_originalSelection.y (),
|
|
m_newWidth,
|
|
m_newHeight),
|
|
kpPixmapFX::scale (*m_originalSelection.pixmap (),
|
|
m_newWidth, m_newHeight,
|
|
!delayed/*if not delayed, smooth*/),
|
|
m_originalSelection.transparency ());
|
|
|
|
if (delayed)
|
|
{
|
|
// Call self with delayed==false in 200ms
|
|
m_smoothScaleTimer->start (200/*ms*/, true/*single shot*/);
|
|
}
|
|
}
|
|
|
|
newSel.moveTo (m_newTopLeft);
|
|
|
|
m_mainWindow->document ()->setSelection (newSel);
|
|
}
|
|
|
|
// protected slots
|
|
void kpToolSelectionResizeScaleCommand::resizeScaleAndMove ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionResizeScaleCommand::resizeScaleAndMove()" << endl;
|
|
#endif
|
|
resizeScaleAndMove (false/*no delay*/);
|
|
}
|
|
|
|
|
|
// public
|
|
void kpToolSelectionResizeScaleCommand::finalize ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionResizeScaleCommand::finalize()"
|
|
<< " smoothScaleTimer->isActive="
|
|
<< m_smoothScaleTimer->isActive ()
|
|
<< endl;
|
|
#endif
|
|
|
|
// Make sure the selection contains the final image and the timer won't
|
|
// fire afterwards.
|
|
if (m_smoothScaleTimer->isActive ())
|
|
{
|
|
resizeScaleAndMove ();
|
|
Q_ASSERT (!m_smoothScaleTimer->isActive ());
|
|
}
|
|
}
|
|
|
|
|
|
// public virtual [base kpToolResizeScaleCommand]
|
|
void kpToolSelectionResizeScaleCommand::execute ()
|
|
{
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
killSmoothScaleTimer ();
|
|
|
|
resizeScaleAndMove ();
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
|
|
// public virtual [base kpToolResizeScaleCommand]
|
|
void kpToolSelectionResizeScaleCommand::unexecute ()
|
|
{
|
|
TQApplication::setOverrideCursor (TQt::waitCursor);
|
|
|
|
killSmoothScaleTimer ();
|
|
|
|
m_mainWindow->document ()->setSelection (m_originalSelection);
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
|
|
TQApplication::restoreOverrideCursor ();
|
|
}
|
|
|
|
|
|
/*
|
|
* kpToolSelectionDestroyCommand
|
|
*/
|
|
|
|
kpToolSelectionDestroyCommand::kpToolSelectionDestroyCommand (const TQString &name,
|
|
bool pushOntoDocument,
|
|
kpMainWindow *mainWindow)
|
|
: kpNamedCommand (name, mainWindow),
|
|
m_pushOntoDocument (pushOntoDocument),
|
|
m_oldSelection (0)
|
|
{
|
|
}
|
|
|
|
kpToolSelectionDestroyCommand::~kpToolSelectionDestroyCommand ()
|
|
{
|
|
delete m_oldSelection;
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
int kpToolSelectionDestroyCommand::size () const
|
|
{
|
|
return kpPixmapFX::pixmapSize (m_oldDocPixmap) +
|
|
kpPixmapFX::selectionSize (m_oldSelection);
|
|
}
|
|
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionDestroyCommand::execute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionDestroyCommand::execute () CALLED" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionDestroyCommand::execute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
if (!doc->selection ())
|
|
{
|
|
kdError () << "kpToolSelectionDestroyCommand::execute() without sel region" << endl;
|
|
return;
|
|
}
|
|
|
|
m_textRow = m_mainWindow->viewManager ()->textCursorRow ();
|
|
m_textCol = m_mainWindow->viewManager ()->textCursorCol ();
|
|
|
|
m_oldSelection = new kpSelection (*doc->selection ());
|
|
if (m_pushOntoDocument)
|
|
{
|
|
m_oldDocPixmap = doc->getPixmapAt (doc->selection ()->boundingRect ());
|
|
doc->selectionPushOntoDocument ();
|
|
}
|
|
else
|
|
doc->selectionDelete ();
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
}
|
|
|
|
// public virtual [base kpCommand]
|
|
void kpToolSelectionDestroyCommand::unexecute ()
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionDestroyCommand::unexecute () CALLED" << endl;
|
|
#endif
|
|
|
|
kpDocument *doc = document ();
|
|
if (!doc)
|
|
{
|
|
kdError () << "kpToolSelectionDestroyCommand::unexecute() without doc" << endl;
|
|
return;
|
|
}
|
|
|
|
if (doc->selection ())
|
|
{
|
|
// not error because it's possible that the user dragged out a new
|
|
// region (without pulling pixmap), and then CTRL+Z
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "kpToolSelectionDestroyCommand::unexecute() already has sel region" << endl;
|
|
#endif
|
|
|
|
if (doc->selection ()->pixmap ())
|
|
{
|
|
kdError () << "kpToolSelectionDestroyCommand::unexecute() already has sel pixmap" << endl;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!m_oldSelection)
|
|
{
|
|
kdError () << "kpToolSelectionDestroyCommand::unexecute() without old sel" << endl;
|
|
return;
|
|
}
|
|
|
|
if (m_pushOntoDocument)
|
|
{
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\tunpush oldDocPixmap onto doc first" << endl;
|
|
#endif
|
|
doc->setPixmapAt (m_oldDocPixmap, m_oldSelection->topLeft ());
|
|
}
|
|
|
|
#if DEBUG_KP_TOOL_SELECTION
|
|
kdDebug () << "\tsetting selection to: rect=" << m_oldSelection->boundingRect ()
|
|
<< " pixmap=" << m_oldSelection->pixmap ()
|
|
<< " pixmap.isNull()=" << (m_oldSelection->pixmap ()
|
|
?
|
|
m_oldSelection->pixmap ()->isNull ()
|
|
:
|
|
true)
|
|
<< endl;
|
|
#endif
|
|
if (!m_oldSelection->isText ())
|
|
{
|
|
if (m_oldSelection->transparency () != m_mainWindow->selectionTransparency ())
|
|
m_mainWindow->setSelectionTransparency (m_oldSelection->transparency ());
|
|
}
|
|
else
|
|
{
|
|
if (m_oldSelection->textStyle () != m_mainWindow->textStyle ())
|
|
m_mainWindow->setTextStyle (m_oldSelection->textStyle ());
|
|
}
|
|
|
|
m_mainWindow->viewManager ()->setTextCursorPosition (m_textRow, m_textCol);
|
|
doc->setSelection (*m_oldSelection);
|
|
|
|
if (m_mainWindow->tool ())
|
|
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
|
|
|
|
delete m_oldSelection;
|
|
m_oldSelection = 0;
|
|
}
|
|
|
|
#include <kptoolselection.moc>
|