summaryrefslogtreecommitdiffstats
path: root/kolourpaint/kptool.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kolourpaint/kptool.cpp
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kolourpaint/kptool.cpp')
-rw-r--r--kolourpaint/kptool.cpp1666
1 files changed, 1666 insertions, 0 deletions
diff --git a/kolourpaint/kptool.cpp b/kolourpaint/kptool.cpp
new file mode 100644
index 00000000..8d337c5b
--- /dev/null
+++ b/kolourpaint/kptool.cpp
@@ -0,0 +1,1666 @@
+
+/*
+ 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 0
+
+
+#include <kptool.h>
+
+#include <limits.h>
+
+#include <qapplication.h>
+#include <qclipboard.h>
+#include <qcursor.h>
+#include <qevent.h>
+#include <qlayout.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+
+#include <kapplication.h>
+#include <kdebug.h>
+#include <kiconloader.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+
+#include <kpcolor.h>
+#include <kpcolortoolbar.h>
+#include <kpdefs.h>
+#include <kpmainwindow.h>
+#include <kppixmapfx.h>
+#include <kpsinglekeytriggersaction.h>
+#include <kptoolaction.h>
+#include <kptooltoolbar.h>
+#include <kpview.h>
+#include <kpviewmanager.h>
+
+
+//
+// kpTool
+//
+
+struct kpToolPrivate
+{
+};
+
+
+kpTool::kpTool (const QString &text, const QString &description,
+ int key,
+ kpMainWindow *mainWindow, const char *name)
+{
+ init (text, description, key, mainWindow, name);
+}
+
+kpTool::~kpTool ()
+{
+ // before destructing, stop using the tool
+ if (m_began)
+ endInternal ();
+
+ if (m_action)
+ {
+ if (m_mainWindow && m_mainWindow->actionCollection ())
+ m_mainWindow->actionCollection ()->remove (m_action);
+ else
+ delete m_action;
+ }
+
+ delete d;
+}
+
+
+// private
+void kpTool::init (const QString &text, const QString &description,
+ int key,
+ kpMainWindow *mainWindow, const char *name)
+{
+ d = new kpToolPrivate ();
+
+ m_key = key;
+ m_action = 0;
+ m_ignoreColorSignals = 0;
+ m_shiftPressed = false, m_controlPressed = false, m_altPressed = false; // set in beginInternal()
+ m_beganDraw = false;
+ m_text = text, m_description = description, m_name = name;
+ m_mainWindow = mainWindow;
+ m_began = false;
+ m_viewUnderStartPoint = 0;
+ m_userShapeStartPoint = KP_INVALID_POINT;
+ m_userShapeEndPoint = KP_INVALID_POINT;
+ m_userShapeSize = KP_INVALID_SIZE;
+
+ createAction ();
+}
+
+
+// private
+void kpTool::createAction ()
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool(" << name () << "::createAction()" << endl;
+#endif
+
+ if (!m_mainWindow)
+ {
+ kdError () << "kpTool::createAction() without mw" << endl;
+ return;
+ }
+
+ KActionCollection *ac = m_mainWindow->actionCollection ();
+ if (!ac)
+ {
+ kdError () << "kpTool::createAction() without ac" << endl;
+ return;
+ }
+
+
+ if (m_action)
+ {
+ // TODO: I don't think this will ever be executed as we are not called
+ // outside of the constructor.
+ #if DEBUG_KP_TOOL
+ kdDebug () << "\tdeleting existing" << endl;
+ #endif
+ ac->remove (m_action);
+ m_action = 0;
+ }
+
+
+ m_action = new kpToolAction (text (), iconName (), shortcutForKey (m_key),
+ this, SLOT (slotActionActivated ()),
+ m_mainWindow->actionCollection (), name ());
+ m_action->setExclusiveGroup (QString::fromLatin1 ("Tool Box Actions"));
+ m_action->setWhatsThis (description ());
+
+ connect (m_action, SIGNAL (toolTipChanged (const QString &)),
+ this, SLOT (slotActionToolTipChanged (const QString &)));
+}
+
+
+// protected slot
+void kpTool::slotActionToolTipChanged (const QString &string)
+{
+ emit actionToolTipChanged (string);
+}
+
+
+// public
+QString kpTool::text () const
+{
+ return m_text;
+}
+
+// public
+void kpTool::setText (const QString &text)
+{
+ m_text = text;
+
+ if (m_action)
+ m_action->setText (m_text);
+ else
+ createAction ();
+}
+
+
+// public static
+QString kpTool::toolTipForTextAndShortcut (const QString &text,
+ const KShortcut &shortcut)
+{
+ for (int i = 0; i < (int) shortcut.count (); i++)
+ {
+ const KKeySequence seq = shortcut.seq (i);
+ if (seq.count () == 1 && containsSingleKeyTrigger (seq))
+ {
+ return i18n ("<Tool Name> (<Single Accel Key>)",
+ "%1 (%2)")
+ .arg (text, seq.toString ());
+ }
+ }
+
+ return text;
+}
+
+// public static
+QString kpTool::toolTip () const
+{
+ return toolTipForTextAndShortcut (text (), shortcut ());
+}
+
+
+// public
+int kpTool::key () const
+{
+ return m_key;
+}
+
+// public
+void kpTool::setKey (int key)
+{
+ m_key = key;
+
+ if (m_action)
+ // TODO: this probably not wise since it nukes the user's settings
+ m_action->setShortcut (shortcutForKey (m_key));
+ else
+ createAction ();
+}
+
+// public static
+KShortcut kpTool::shortcutForKey (int key)
+{
+ KShortcut shortcut;
+
+ if (key)
+ {
+ shortcut.append (KKeySequence (KKey (key)));
+ // (CTRL+<key>, ALT+<key>, CTRL+ALT+<key>, CTRL+SHIFT+<key>
+ // all clash with global KDE shortcuts)
+ shortcut.append (KKeySequence (KKey (Qt::ALT + Qt::SHIFT + key)));
+ }
+
+ return shortcut;
+}
+
+// public
+KShortcut kpTool::shortcut () const
+{
+ return m_action ? m_action->shortcut () : KShortcut ();
+}
+
+
+// public static
+bool kpTool::keyIsText (int key)
+{
+ // TODO: should work like !QKeyEvent::text().isEmpty()
+ return !(key & (Qt::MODIFIER_MASK ^ Qt::SHIFT));
+}
+
+// public static
+bool kpTool::containsSingleKeyTrigger (const KKeySequence &seq)
+{
+ for (int i = 0; i < (int) seq.count (); i++)
+ {
+ const KKey key = seq.key (i);
+ if (keyIsText (key.keyCodeQt ()))
+ return true;
+ }
+
+ return false;
+}
+
+// public static
+bool kpTool::containsSingleKeyTrigger (const KShortcut &shortcut,
+ KShortcut *shortcutWithoutSingleKeyTriggers)
+{
+ if (shortcutWithoutSingleKeyTriggers)
+ *shortcutWithoutSingleKeyTriggers = shortcut;
+
+
+ KShortcut newShortcut;
+ bool needNewShortcut = false;
+
+ for (int i = 0; i < (int) shortcut.count (); i++)
+ {
+ const KKeySequence seq = shortcut.seq (i);
+
+ if (containsSingleKeyTrigger (seq))
+ {
+ needNewShortcut = true;
+ }
+ else
+ {
+ newShortcut.append (seq);
+ }
+ }
+
+
+ if (needNewShortcut && shortcutWithoutSingleKeyTriggers)
+ *shortcutWithoutSingleKeyTriggers = newShortcut;
+
+ return needNewShortcut;
+}
+
+
+// public
+bool kpTool::singleKeyTriggersEnabled () const
+{
+ return (m_action ? m_action->singleKeyTriggersEnabled () : true);
+}
+
+// public
+void kpTool::enableSingleKeyTriggers (bool enable)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool(" << name () << ")::enableSingleKeyTriggers("
+ << enable << ")" << endl;
+#endif
+
+ if (!m_action)
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tno action" << endl;
+ #endif
+ return;
+ }
+
+ m_action->enableSingleKeyTriggers (enable);
+}
+
+
+// public
+QString kpTool::description () const
+{
+ return m_description;
+}
+
+// public
+void kpTool::setDescription (const QString &description)
+{
+ m_description = description;
+
+ if (m_action)
+ m_action->setWhatsThis (m_description);
+ else
+ createAction ();
+}
+
+
+// public
+const char *kpTool::name () const
+{
+ return m_name;
+}
+
+
+// static
+QRect kpTool::neededRect (const QRect &rect, int lineWidth)
+{
+ int x1, y1, x2, y2;
+ rect.coords (&x1, &y1, &x2, &y2);
+
+ if (lineWidth < 1)
+ lineWidth = 1;
+
+ return QRect (QPoint (x1 - lineWidth + 1, y1 - lineWidth + 1),
+ QPoint (x2 + lineWidth - 1, y2 + lineWidth - 1));
+}
+
+// static
+QPixmap kpTool::neededPixmap (const QPixmap &pixmap, const QRect &boundingRect)
+{
+ return kpPixmapFX::getPixmapAt (pixmap, boundingRect);
+}
+
+
+// public
+bool kpTool::hasCurrentPoint () const
+{
+ return (viewUnderStartPoint () || viewUnderCursor ());
+}
+
+// public
+QPoint kpTool::currentPoint (bool zoomToDoc) const
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::currentPoint(zoomToDoc=" << zoomToDoc << ")" << endl;
+ kdDebug () << "\tviewUnderStartPoint="
+ << (viewUnderStartPoint () ? viewUnderStartPoint ()->name () : "(none)")
+ << " viewUnderCursor="
+ << (viewUnderCursor () ? viewUnderCursor ()->name () : "(none)")
+ << endl;
+#endif
+
+ kpView *v = viewUnderStartPoint ();
+ if (!v)
+ {
+ v = viewUnderCursor ();
+ if (!v)
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tno view - returning sentinel" << endl;
+ #endif
+ return KP_INVALID_POINT;
+ }
+ }
+
+
+ const QPoint globalPos = QCursor::pos ();
+ const QPoint viewPos = v->mapFromGlobal (globalPos);
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tglobalPos=" << globalPos
+ << " viewPos=" << viewPos
+ << endl;
+#endif
+ if (!zoomToDoc)
+ return viewPos;
+
+
+ const QPoint docPos = v->transformViewToDoc (viewPos);
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tdocPos=" << docPos << endl;
+#endif
+ return docPos;
+}
+
+
+// public slot
+void kpTool::somethingBelowTheCursorChanged ()
+{
+ somethingBelowTheCursorChanged (currentPoint (),
+ currentPoint (false/*view point*/));
+}
+
+// private
+// TODO: don't dup code from mouseMoveEvent()
+void kpTool::somethingBelowTheCursorChanged (const QPoint &currentPoint_,
+ const QPoint &currentViewPoint_)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::somethingBelowTheCursorChanged(docPoint="
+ << currentPoint_
+ << " viewPoint="
+ << currentViewPoint_
+ << ")" << endl;
+ kdDebug () << "\tviewUnderStartPoint="
+ << (viewUnderStartPoint () ? viewUnderStartPoint ()->name () : "(none)")
+ << " viewUnderCursor="
+ << (viewUnderCursor () ? viewUnderCursor ()->name () : "(none)")
+ << endl;
+ kdDebug () << "\tbegan draw=" << m_beganDraw << endl;
+#endif
+
+ m_currentPoint = currentPoint_;
+ m_currentViewPoint = currentViewPoint_;
+
+ if (m_beganDraw)
+ {
+ if (m_currentPoint != KP_INVALID_POINT)
+ {
+ draw (m_currentPoint, m_lastPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+ m_lastPoint = m_currentPoint;
+ }
+ }
+ else
+ {
+ hover (m_currentPoint);
+ }
+}
+
+
+void kpTool::beginInternal ()
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::beginInternal()" << endl;
+#endif
+
+ if (!m_began)
+ {
+ // clear leftover statusbar messages
+ setUserMessage ();
+ m_currentPoint = currentPoint ();
+ m_currentViewPoint = currentPoint (false/*view point*/);
+ setUserShapePoints (m_currentPoint);
+
+ // TODO: Audit all the code in this file - states like "m_began" &
+ // "m_beganDraw" should be set before calling user func.
+ // Also, m_currentPoint should be more frequently initialised.
+
+ // call user virtual func
+ begin ();
+
+ // we've starting using the tool...
+ m_began = true;
+
+ // but we haven't started drawing with it
+ m_beganDraw = false;
+
+
+ uint keyState = KApplication::keyboardModifiers ();
+
+ m_shiftPressed = (keyState & KApplication::ShiftModifier);
+ m_controlPressed = (keyState & KApplication::ControlModifier);
+
+ // TODO: Can't do much about ALT - unless it's always KApplication::Modifier1?
+ // Ditto for everywhere else where I set SHIFT & CTRL but not alt.
+ m_altPressed = false;
+ }
+}
+
+void kpTool::endInternal ()
+{
+ if (m_began)
+ {
+ // before we can stop using the tool, we must stop the current drawing operation (if any)
+ if (hasBegunShape ())
+ endShapeInternal (m_currentPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+
+ // call user virtual func
+ end ();
+
+ // clear leftover statusbar messages
+ setUserMessage ();
+ setUserShapePoints (currentPoint ());
+
+ // we've stopped using the tool...
+ m_began = false;
+
+ // and so we can't be drawing with it
+ m_beganDraw = false;
+
+ if (m_mainWindow)
+ {
+ kpToolToolBar *tb = m_mainWindow->toolToolBar ();
+ if (tb)
+ {
+ tb->hideAllToolWidgets ();
+ }
+ }
+
+ }
+}
+
+// virtual
+void kpTool::begin ()
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::begin() base implementation" << endl;
+#endif
+}
+
+// virtual
+void kpTool::end ()
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::end() base implementation" << endl;
+#endif
+}
+
+void kpTool::beginDrawInternal ()
+{
+ if (!m_beganDraw)
+ {
+ beginDraw ();
+
+ m_beganDraw = true;
+ emit beganDraw (m_currentPoint);
+ }
+}
+
+// virtual
+void kpTool::beginDraw ()
+{
+}
+
+// virtual
+void kpTool::hover (const QPoint &point)
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::hover" << point
+ << " base implementation"
+ << endl;
+#endif
+
+ setUserShapePoints (point);
+}
+
+// virtual
+void kpTool::globalDraw ()
+{
+}
+
+// virtual
+void kpTool::reselect ()
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::reselect() base implementation" << endl;
+#endif
+}
+
+
+// public
+QIconSet kpTool::iconSet (int forceSize) const
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool(" << name () << ")::iconSet(forceSize=" << forceSize << ")" << endl;
+#endif
+ // (robust in case BarIcon() default arg changes)
+ if (forceSize > 0)
+ return BarIconSet (name (), forceSize);
+ else
+ return BarIconSet (name ());
+}
+
+// public
+QString kpTool::iconName () const
+{
+ return name ();
+}
+
+// public
+kpToolAction *kpTool::action ()
+{
+ if (!m_action)
+ createAction ();
+
+ return m_action;
+}
+
+
+// protected slots
+void kpTool::slotActionActivated ()
+{
+ emit actionActivated ();
+}
+
+
+// virtual
+void kpTool::draw (const QPoint &, const QPoint &, const QRect &)
+{
+}
+
+// also called by kpView
+void kpTool::cancelShapeInternal ()
+{
+ if (hasBegunShape ())
+ {
+ m_beganDraw = false;
+ cancelShape ();
+ m_viewUnderStartPoint = 0;
+
+ emit cancelledShape (viewUnderCursor () ? m_currentPoint : KP_INVALID_POINT);
+
+ if (viewUnderCursor ())
+ hover (m_currentPoint);
+ else
+ {
+ m_currentPoint = KP_INVALID_POINT;
+ m_currentViewPoint = KP_INVALID_POINT;
+ hover (m_currentPoint);
+ }
+
+ if (returnToPreviousToolAfterEndDraw ())
+ {
+ kpToolToolBar *tb = mainWindow ()->toolToolBar ();
+
+ // (don't end up with no tool selected)
+ if (tb->previousTool ())
+ {
+ // endInternal() will be called by kpMainWindow (thanks to this line)
+ // so we won't have the view anymore
+ tb->selectPreviousTool ();
+ }
+ }
+ }
+}
+
+// virtual
+void kpTool::cancelShape ()
+{
+ kdWarning () << "Tool cannot cancel operation!" << endl;
+}
+
+void kpTool::releasedAllButtons ()
+{
+}
+
+void kpTool::endDrawInternal (const QPoint &thisPoint, const QRect &normalizedRect,
+ bool wantEndShape)
+{
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::endDrawInternal() wantEndShape=" << wantEndShape << endl;
+#endif
+
+ if (wantEndShape && !hasBegunShape ())
+ return;
+ else if (!wantEndShape && !hasBegunDraw ())
+ return;
+
+ m_beganDraw = false;
+
+ if (wantEndShape)
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tcalling endShape()" << endl;
+ #endif
+ endShape (thisPoint, normalizedRect);
+ }
+ else
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tcalling endDraw()" << endl;
+ #endif
+ endDraw (thisPoint, normalizedRect);
+ }
+ m_viewUnderStartPoint = 0;
+
+ emit endedDraw (m_currentPoint);
+ if (viewUnderCursor ())
+ hover (m_currentPoint);
+ else
+ {
+ m_currentPoint = KP_INVALID_POINT;
+ m_currentViewPoint = KP_INVALID_POINT;
+ hover (m_currentPoint);
+ }
+
+ if (returnToPreviousToolAfterEndDraw ())
+ {
+ kpToolToolBar *tb = mainWindow ()->toolToolBar ();
+
+ // (don't end up with no tool selected)
+ if (tb->previousTool ())
+ {
+ // endInternal() will be called by kpMainWindow (thanks to this line)
+ // so we won't have the view anymore
+ tb->selectPreviousTool ();
+ }
+ }
+}
+
+// private
+void kpTool::endShapeInternal (const QPoint &thisPoint, const QRect &normalizedRect)
+{
+ endDrawInternal (thisPoint, normalizedRect, true/*end shape*/);
+}
+
+// virtual
+void kpTool::endDraw (const QPoint &, const QRect &)
+{
+}
+
+kpMainWindow *kpTool::mainWindow () const
+{
+ return m_mainWindow;
+}
+
+kpDocument *kpTool::document () const
+{
+ return m_mainWindow ? m_mainWindow->document () : 0;
+}
+
+kpView *kpTool::viewUnderCursor () const
+{
+ kpViewManager *vm = viewManager ();
+ return vm ? vm->viewUnderCursor () : 0;
+}
+
+kpViewManager *kpTool::viewManager () const
+{
+ return m_mainWindow ? m_mainWindow->viewManager () : 0;
+}
+
+kpToolToolBar *kpTool::toolToolBar () const
+{
+ return m_mainWindow ? m_mainWindow->toolToolBar () : 0;
+}
+
+kpColor kpTool::color (int which) const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->color (which);
+ else
+ {
+ kdError () << "kpTool::color () without mainWindow" << endl;
+ return kpColor::invalid;
+ }
+}
+
+kpColor kpTool::foregroundColor () const
+{
+ return color (0);
+}
+
+kpColor kpTool::backgroundColor () const
+{
+ return color (1);
+}
+
+
+double kpTool::colorSimilarity () const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->colorSimilarity ();
+ else
+ {
+ kdError () << "kpTool::colorSimilarity() without mainWindow" << endl;
+ return 0;
+ }
+}
+
+int kpTool::processedColorSimilarity () const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->processedColorSimilarity ();
+ else
+ {
+ kdError () << "kpTool::processedColorSimilarity() without mainWindow" << endl;
+ return kpColor::Exact;
+ }
+}
+
+
+kpColor kpTool::oldForegroundColor () const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->oldForegroundColor ();
+ else
+ {
+ kdError () << "kpTool::oldForegroundColor() without mainWindow" << endl;
+ return kpColor::invalid;
+ }
+}
+
+kpColor kpTool::oldBackgroundColor () const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->oldBackgroundColor ();
+ else
+ {
+ kdError () << "kpTool::oldBackgroundColor() without mainWindow" << endl;
+ return kpColor::invalid;
+ }
+}
+
+double kpTool::oldColorSimilarity () const
+{
+ if (m_mainWindow)
+ return m_mainWindow->colorToolBar ()->oldColorSimilarity ();
+ else
+ {
+ kdError () << "kpTool::oldColorSimilarity() without mainWindow" << endl;
+ return 0;
+ }
+}
+
+
+void kpTool::slotColorsSwappedInternal (const kpColor &newForegroundColor,
+ const kpColor &newBackgroundColor)
+{
+ if (careAboutColorsSwapped ())
+ {
+ slotColorsSwapped (newForegroundColor, newBackgroundColor);
+ m_ignoreColorSignals = 2;
+ }
+ else
+ m_ignoreColorSignals = 0;
+}
+
+void kpTool::slotForegroundColorChangedInternal (const kpColor &color)
+{
+ if (m_ignoreColorSignals > 0)
+ {
+ #if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::slotForegroundColorChangedInternal() ignoreColorSignals=" << m_ignoreColorSignals << endl;
+ #endif
+ m_ignoreColorSignals--;
+ return;
+ }
+
+ slotForegroundColorChanged (color);
+}
+
+void kpTool::slotBackgroundColorChangedInternal (const kpColor &color)
+{
+ if (m_ignoreColorSignals > 0)
+ {
+ #if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::slotBackgroundColorChangedInternal() ignoreColorSignals=" << m_ignoreColorSignals << endl;
+ #endif
+ m_ignoreColorSignals--;
+ return;
+ }
+
+ slotBackgroundColorChanged (color);
+}
+
+void kpTool::slotColorSimilarityChangedInternal (double similarity, int processedSimilarity)
+{
+ slotColorSimilarityChanged (similarity, processedSimilarity);
+}
+
+bool kpTool::currentPointNextToLast () const
+{
+ if (m_lastPoint == QPoint (-1, -1))
+ return true;
+
+ int dx = kAbs (m_currentPoint.x () - m_lastPoint.x ());
+ int dy = kAbs (m_currentPoint.y () - m_lastPoint.y ());
+
+ return (dx <= 1 && dy <= 1);
+}
+
+bool kpTool::currentPointCardinallyNextToLast () const
+{
+ if (m_lastPoint == QPoint (-1, -1))
+ return true;
+
+ int dx = kAbs (m_currentPoint.x () - m_lastPoint.x ());
+ int dy = kAbs (m_currentPoint.y () - m_lastPoint.y ());
+
+ return (dx + dy <= 1);
+}
+
+kpCommandHistory *kpTool::commandHistory () const
+{
+ return m_mainWindow ? m_mainWindow->commandHistory () : 0;
+}
+
+void kpTool::mousePressEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::mousePressEvent pos=" << e->pos ()
+ << " btnStateBefore=" << (int) e->state ()
+ << " btnStateAfter=" << (int) e->stateAfter ()
+ << " button=" << (int) e->button ()
+ << " beganDraw=" << m_beganDraw << endl;
+#endif
+
+ // state of all the buttons - not just the one that triggered the event (button())
+ Qt::ButtonState buttonState = e->stateAfter ();
+
+ if (m_mainWindow && e->button () == Qt::MidButton)
+ {
+ const QString text = QApplication::clipboard ()->text (QClipboard::Selection);
+ #if DEBUG_KP_TOOL && 1
+ kdDebug () << "\tMMB pasteText='" << text << "'" << endl;
+ #endif
+ if (!text.isEmpty ())
+ {
+ if (hasBegunShape ())
+ {
+ #if DEBUG_KP_TOOL && 1
+ kdDebug () << "\t\thasBegunShape - end" << endl;
+ #endif
+ endShapeInternal (m_currentPoint,
+ QRect (m_startPoint, m_currentPoint).normalize ());
+ }
+
+ if (viewUnderCursor ())
+ {
+ m_mainWindow->pasteTextAt (text,
+ viewUnderCursor ()->transformViewToDoc (e->pos ()),
+ true/*adjust topLeft so that cursor isn't
+ on top of resize handle*/);
+ }
+
+ return;
+ }
+ }
+
+ int mb = mouseButton (buttonState);
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "\tmb=" << mb << " m_beganDraw=" << m_beganDraw << endl;
+#endif
+
+ if (mb == -1 && !m_beganDraw) return; // ignore
+
+ if (m_beganDraw)
+ {
+ if (mb == -1 || mb != m_mouseButton)
+ {
+ #if DEBUG_KP_TOOL && 1
+ kdDebug () << "\tCancelling operation as " << mb << " == -1 or != " << m_mouseButton << endl;
+ #endif
+
+ kpView *view = viewUnderStartPoint ();
+ if (!view)
+ {
+ kdError () << "kpTool::mousePressEvent() cancel without a view under the start point!" << endl;
+ }
+
+ // if we get a mousePressEvent when we're drawing, then the other
+ // mouse button must have been pressed
+ m_currentPoint = view ? view->transformViewToDoc (e->pos ()) : QPoint (-1, -1);
+ m_currentViewPoint = view ? e->pos () : QPoint (-1, -1);
+ cancelShapeInternal ();
+ }
+
+ return;
+ }
+
+ kpView *view = viewUnderCursor ();
+ if (!view)
+ {
+ kdError () << "kpTool::mousePressEvent() without a view under the cursor!" << endl;
+ }
+
+#if DEBUG_KP_TOOL && 1
+ if (view)
+ kdDebug () << "\tview=" << view->name () << endl;
+#endif
+
+
+ // let user know what mouse button is being used for entire draw
+ m_mouseButton = mouseButton (buttonState);
+ m_shiftPressed = (buttonState & Qt::ShiftButton);
+ m_controlPressed = (buttonState & Qt::ControlButton);
+ m_altPressed = (buttonState & Qt::AltButton);
+ m_startPoint = m_currentPoint = view ? view->transformViewToDoc (e->pos ()) : QPoint (-1, -1);
+ m_currentViewPoint = view ? e->pos () : QPoint (-1, -1);
+ m_viewUnderStartPoint = view;
+ m_lastPoint = QPoint (-1, -1);
+
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "\tBeginning draw @ " << m_currentPoint << endl;
+#endif
+
+ beginDrawInternal ();
+
+ draw (m_currentPoint, m_lastPoint, QRect (m_currentPoint, m_currentPoint));
+ m_lastPoint = m_currentPoint;
+}
+
+void kpTool::mouseMoveEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::mouseMoveEvent pos=" << e->pos ()
+ << " btnStateAfter=" << (int) e->stateAfter () << endl;
+ kpView *v0 = viewUnderCursor (),
+ *v1 = viewManager ()->viewUnderCursor (true/*use Qt*/),
+ *v2 = viewUnderStartPoint ();
+ kdDebug () << "\tviewUnderCursor=" << (v0 ? v0->name () : "(none)")
+ << " viewUnderCursorQt=" << (v1 ? v1->name () : "(none)")
+ << " viewUnderStartPoint=" << (v2 ? v2->name () : "(none)")
+ << endl;
+ kdDebug () << "\tfocusWidget=" << kapp->focusWidget () << endl;
+#endif
+
+ Qt::ButtonState buttonState = e->stateAfter ();
+ m_shiftPressed = (buttonState & Qt::ShiftButton);
+ m_controlPressed = (buttonState & Qt::ControlButton);
+ m_altPressed = (buttonState & Qt::AltButton);
+
+ if (m_beganDraw)
+ {
+ kpView *view = viewUnderStartPoint ();
+ if (!view)
+ {
+ kdError () << "kpTool::mouseMoveEvent() without a view under the start point!" << endl;
+ return;
+ }
+
+ m_currentPoint = view->transformViewToDoc (e->pos ());
+ m_currentViewPoint = e->pos ();
+
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tDraw!" << endl;
+ #endif
+
+ bool dragScrolled = false;
+ movedAndAboutToDraw (m_currentPoint, m_lastPoint, view->zoomLevelX (), &dragScrolled);
+
+ if (dragScrolled)
+ {
+ m_currentPoint = currentPoint ();
+ m_currentViewPoint = currentPoint (false/*view point*/);
+
+ // Scrollview has scrolled contents and has scheduled an update
+ // for the newly exposed region. If draw() schedules an update
+ // as well (instead of immediately updating), the scrollview's
+ // update will be executed first and it'll only update part of
+ // the screen resulting in ugly tearing of the viewManager's
+ // tempPixmap.
+ viewManager ()->setFastUpdates ();
+ }
+
+ draw (m_currentPoint, m_lastPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+
+ if (dragScrolled)
+ viewManager ()->restoreFastUpdates ();
+
+ m_lastPoint = m_currentPoint;
+ }
+ else
+ {
+ kpView *view = viewUnderCursor ();
+ if (!view) // possible if cancelShape()'ed but still holding down initial mousebtn
+ {
+ m_currentPoint = KP_INVALID_POINT;
+ m_currentViewPoint = KP_INVALID_POINT;
+ return;
+ }
+
+ m_currentPoint = view->transformViewToDoc (e->pos ());
+ m_currentViewPoint = e->pos ();
+ hover (m_currentPoint);
+ }
+}
+
+void kpTool::mouseReleaseEvent (QMouseEvent *e)
+{
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::mouseReleaseEvent pos=" << e->pos ()
+ << " btnStateBefore=" << (int) e->state ()
+ << " btnStateAfter=" << (int) e->stateAfter ()
+ << " button=" << (int) e->button () << endl;
+#endif
+
+ if (m_beganDraw) // didn't cancelShape()
+ {
+ kpView *view = viewUnderStartPoint ();
+ if (!view)
+ {
+ kdError () << "kpTool::mouseReleaseEvent() without a view under the start point!" << endl;
+ return;
+ }
+
+ m_currentPoint = view ? view->transformViewToDoc (e->pos ()) : QPoint (-1, -1);
+ m_currentViewPoint = view ? e->pos () : QPoint (-1, -1);
+ endDrawInternal (m_currentPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+ }
+
+ if ((e->stateAfter () & Qt::MouseButtonMask) == 0)
+ {
+ releasedAllButtons ();
+ }
+}
+
+void kpTool::wheelEvent (QWheelEvent *e)
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::wheelEvent() state=" << e->state ()
+ << " hasBegunDraw=" << hasBegunDraw ()
+ << " delta=" << e->delta ()
+ << endl;
+#endif
+
+ e->ignore ();
+
+ // If CTRL not pressed, bye.
+ if ((e->state () & Qt::ControlButton) == 0)
+ return;
+
+ // If drawing, bye; don't care if a shape in progress though.
+ if (hasBegunDraw ())
+ return;
+
+
+ // Zoom in/out depending on wheel direction.
+
+ // Moved wheel away from user?
+ if (e->delta () > 0)
+ {
+ m_mainWindow->zoomIn (true/*center under cursor*/);
+ e->accept ();
+ }
+ // Moved wheel towards user?
+ else if (e->delta () < 0)
+ {
+ #if 1
+ m_mainWindow->zoomOut (true/*center under cursor - make zoom in/out
+ stay under same doc pos*/);
+ #else
+ m_mainWindow->zoomOut (false/*don't center under cursor - as is
+ confusing behaviour when zooming
+ out*/);
+ #endif
+ e->accept ();
+ }
+}
+
+
+void kpTool::keyPressEvent (QKeyEvent *e)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::keyPressEvent() e->key=" << e->key () << endl;
+#endif
+
+ int dx = 0, dy = 0;
+
+ e->ignore ();
+
+ switch (e->key ())
+ {
+ case 0:
+ case Qt::Key_unknown:
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::keyPressEvent() picked up unknown key!" << endl;
+ #endif
+ // --- fall thru and update all modifiers ---
+ case Qt::Key_Alt:
+ case Qt::Key_Shift:
+ case Qt::Key_Control:
+ keyUpdateModifierState (e);
+
+ e->accept ();
+ break;
+
+ case Qt::Key_Delete:
+ m_mainWindow->slotDelete ();
+ break;
+
+ /*
+ * QCursor::setPos conveniently causes mouseMoveEvents :)
+ */
+
+ case Qt::Key_Home: dx = -1, dy = -1; break;
+ case Qt::Key_Up: dy = -1; break;
+ case Qt::Key_PageUp: dx = +1, dy = -1; break;
+
+ case Qt::Key_Left: dx = -1; break;
+ case Qt::Key_Right: dx = +1; break;
+
+ case Qt::Key_End: dx = -1, dy = +1; break;
+ case Qt::Key_Down: dy = +1; break;
+ case Qt::Key_PageDown: dx = +1, dy = +1; break;
+
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ case Qt::Key_Insert:
+ case Qt::Key_Clear/*Numpad 5 Key*/:
+ {
+ kpView *view = viewUnderCursor (); // TODO: wrong for dragging lines outside of view (for e.g.)
+ if (view)
+ {
+ // TODO: what about the modifiers
+ QMouseEvent me (QEvent::MouseButtonPress,
+ view->mapFromGlobal (QCursor::pos ()),
+ Qt::LeftButton,
+ 0);
+ mousePressEvent (&me);
+ e->accept ();
+ }
+
+ break;
+ }}
+
+ kpView *view = viewUnderCursor ();
+ if (view && (dx || dy))
+ {
+ QPoint oldPoint = view->mapFromGlobal (QCursor::pos ());
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\toldPoint=" << oldPoint
+ << " dx=" << dx << " dy=" << dy << endl;
+ #endif
+
+
+ const int viewIncX = (dx ? QMAX (1, view->zoomLevelX () / 100) * dx : 0);
+ const int viewIncY = (dy ? QMAX (1, view->zoomLevelY () / 100) * dy : 0);
+
+ int newViewX = oldPoint.x () + viewIncX;
+ int newViewY = oldPoint.y () + viewIncY;
+
+
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tnewPoint=" << QPoint (newViewX, newViewY) << endl;
+ #endif
+
+ if (view->transformViewToDoc (QPoint (newViewX, newViewY)) ==
+ view->transformViewToDoc (oldPoint))
+ {
+ newViewX += viewIncX, newViewY += viewIncY;
+
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\tneed adjust for doc - newPoint="
+ << QPoint (newViewX, newViewY) << endl;
+ #endif
+ }
+
+
+ // TODO: visible width/height (e.g. with scrollbars)
+ int x = QMIN (QMAX (newViewX, 0), view->width () - 1);
+ int y = QMIN (QMAX (newViewY, 0), view->height () - 1);
+
+ QCursor::setPos (view->mapToGlobal (QPoint (x, y)));
+ e->accept ();
+ }
+}
+
+void kpTool::keyReleaseEvent (QKeyEvent *e)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::keyReleaseEvent() e->key=" << e->key () << endl;
+#endif
+
+ e->ignore ();
+
+ switch (e->key ())
+ {
+ case 0:
+ case Qt::Key_unknown:
+ #if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::keyReleaseEvent() picked up unknown key!" << endl;
+ #endif
+ // HACK: around Qt bug: if you hold a modifier before you start the
+ // program and then release it over the view,
+ // Qt reports it as the release of an unknown key
+ // --- fall thru and update all modifiers ---
+ case Qt::Key_Alt:
+ case Qt::Key_Shift:
+ case Qt::Key_Control:
+ keyUpdateModifierState (e);
+
+ e->accept ();
+ break;
+
+ case Qt::Key_Escape:
+ if (hasBegunDraw ())
+ {
+ cancelShapeInternal ();
+ e->accept ();
+ }
+
+ break;
+
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ case Qt::Key_Insert:
+ case Qt::Key_Clear/*Numpad 5 Key*/:
+ {
+ kpView *view = viewUnderCursor ();
+ if (view)
+ {
+ QMouseEvent me (QEvent::MouseButtonRelease,
+ view->mapFromGlobal (QCursor::pos ()),
+ Qt::LeftButton,
+ Qt::LeftButton);
+ mouseReleaseEvent (&me);
+ e->accept ();
+ }
+ break;
+ }}
+}
+
+// private
+void kpTool::keyUpdateModifierState (QKeyEvent *e)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::updateModifierState() e->key=" << e->key () << endl;
+ kdDebug () << "\tshift="
+ << (e->stateAfter () & Qt::ShiftButton)
+ << " control="
+ << (e->stateAfter () & Qt::ControlButton)
+ << " alt="
+ << (e->stateAfter () & Qt::AltButton)
+ << endl;
+#endif
+ if (e->key () & (Qt::Key_Alt | Qt::Key_Shift | Qt::Key_Control))
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\t\tmodifier changed - use e's claims" << endl;
+ #endif
+ setShiftPressed (e->stateAfter () & Qt::ShiftButton);
+ setControlPressed (e->stateAfter () & Qt::ControlButton);
+ setAltPressed (e->stateAfter () & Qt::AltButton);
+ }
+ else
+ {
+ #if DEBUG_KP_TOOL && 0
+ kdDebug () << "\t\tmodifiers not changed - figure out the truth" << endl;
+ #endif
+ uint keyState = KApplication::keyboardModifiers ();
+
+ setShiftPressed (keyState & KApplication::ShiftModifier);
+ setControlPressed (keyState & KApplication::ControlModifier);
+
+ // TODO: Can't do much about ALT - unless it's always KApplication::Modifier1?
+ // Ditto for everywhere else where I set SHIFT & CTRL but not alt.
+ setAltPressed (e->stateAfter () & Qt::AltButton);
+ }
+}
+
+
+void kpTool::notifyModifierStateChanged ()
+{
+ if (careAboutModifierState ())
+ {
+ if (m_beganDraw)
+ draw (m_currentPoint, m_lastPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+ else
+ {
+ m_currentPoint = currentPoint ();
+ m_currentViewPoint = currentPoint (false/*view point*/);
+ hover (m_currentPoint);
+ }
+ }
+}
+
+void kpTool::setShiftPressed (bool pressed)
+{
+ if (pressed == m_shiftPressed)
+ return;
+
+ m_shiftPressed = pressed;
+
+ notifyModifierStateChanged ();
+}
+
+void kpTool::setControlPressed (bool pressed)
+{
+ if (pressed == m_controlPressed)
+ return;
+
+ m_controlPressed = pressed;
+
+ notifyModifierStateChanged ();
+}
+
+void kpTool::setAltPressed (bool pressed)
+{
+ if (pressed = m_altPressed)
+ return;
+
+ m_altPressed = pressed;
+
+ notifyModifierStateChanged ();
+}
+
+void kpTool::focusInEvent (QFocusEvent *)
+{
+}
+
+void kpTool::focusOutEvent (QFocusEvent *)
+{
+#if DEBUG_KP_TOOL && 0
+ kdDebug () << "kpTool::focusOutEvent() beganDraw=" << m_beganDraw << endl;
+#endif
+
+ if (m_beganDraw)
+ endDrawInternal (m_currentPoint, QRect (m_startPoint, m_currentPoint).normalize ());
+}
+
+void kpTool::enterEvent (QEvent *)
+{
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::enterEvent() beganDraw=" << m_beganDraw << endl;
+#endif
+}
+
+void kpTool::leaveEvent (QEvent *)
+{
+#if DEBUG_KP_TOOL && 1
+ kdDebug () << "kpTool::leaveEvent() beganDraw=" << m_beganDraw << endl;
+#endif
+
+ // if we haven't started drawing (e.g. dragging a rectangle)...
+ if (!m_beganDraw)
+ {
+ m_currentPoint = KP_INVALID_POINT;
+ m_currentViewPoint = KP_INVALID_POINT;
+ hover (m_currentPoint);
+ }
+}
+
+// static
+int kpTool::mouseButton (const Qt::ButtonState &buttonState)
+{
+ // we have nothing to do with mid-buttons
+ if (buttonState & Qt::MidButton)
+ return -1;
+
+ // both left & right together is quite meaningless...
+ Qt::ButtonState bothButtons = (Qt::ButtonState) (Qt::LeftButton | Qt::RightButton);
+ if ((buttonState & bothButtons) == bothButtons)
+ return -1;
+
+ if (buttonState & Qt::LeftButton)
+ return 0;
+ else if (buttonState & Qt::RightButton)
+ return 1;
+ else
+ return -1;
+}
+
+
+/*
+ * User Notifications
+ */
+
+
+// public static
+QString kpTool::cancelUserMessage (int mouseButton)
+{
+ if (mouseButton == 0)
+ return i18n ("Right click to cancel.");
+ else
+ return i18n ("Left click to cancel.");
+}
+
+// public
+QString kpTool::cancelUserMessage () const
+{
+ return cancelUserMessage (m_mouseButton);
+}
+
+
+// public
+QString kpTool::userMessage () const
+{
+ return m_userMessage;
+}
+
+// public
+void kpTool::setUserMessage (const QString &userMessage)
+{
+ m_userMessage = userMessage;
+
+ if (m_userMessage.isEmpty ())
+ m_userMessage = text ();
+ else
+ m_userMessage.prepend (i18n ("%1: ").arg (text ()));
+
+ emit userMessageChanged (m_userMessage);
+}
+
+
+// public
+QPoint kpTool::userShapeStartPoint () const
+{
+ return m_userShapeStartPoint;
+}
+
+// public
+QPoint kpTool::userShapeEndPoint () const
+{
+ return m_userShapeEndPoint;
+}
+
+// public static
+int kpTool::calculateLength (int start, int end)
+{
+ if (start <= end)
+ {
+ return end - start + 1;
+ }
+ else
+ {
+ return end - start - 1;
+ }
+}
+
+// public
+void kpTool::setUserShapePoints (const QPoint &startPoint,
+ const QPoint &endPoint,
+ bool setSize)
+{
+ m_userShapeStartPoint = startPoint;
+ m_userShapeEndPoint = endPoint;
+ emit userShapePointsChanged (m_userShapeStartPoint, m_userShapeEndPoint);
+
+ if (setSize)
+ {
+ if (startPoint != KP_INVALID_POINT &&
+ endPoint != KP_INVALID_POINT)
+ {
+ setUserShapeSize (calculateLength (startPoint.x (), endPoint.x ()),
+ calculateLength (startPoint.y (), endPoint.y ()));
+ }
+ else
+ {
+ setUserShapeSize ();
+ }
+ }
+}
+
+
+// public
+QSize kpTool::userShapeSize () const
+{
+ return m_userShapeSize;
+}
+
+// public
+int kpTool::userShapeWidth () const
+{
+ return m_userShapeSize.width ();
+}
+
+// public
+int kpTool::userShapeHeight () const
+{
+ return m_userShapeSize.height ();
+}
+
+// public
+void kpTool::setUserShapeSize (const QSize &size)
+{
+ m_userShapeSize = size;
+
+ emit userShapeSizeChanged (m_userShapeSize);
+ emit userShapeSizeChanged (m_userShapeSize.width (),
+ m_userShapeSize.height ());
+}
+
+// public
+void kpTool::setUserShapeSize (int width, int height)
+{
+ setUserShapeSize (QSize (width, height));
+}
+
+
+// public static
+bool kpTool::warnIfBigImageSize (int oldWidth, int oldHeight,
+ int newWidth, int newHeight,
+ const QString &text,
+ const QString &caption,
+ const QString &continueButtonText,
+ QWidget *parent)
+{
+#if DEBUG_KP_TOOL
+ kdDebug () << "kpTool::warnIfBigImageSize()"
+ << " old: w=" << oldWidth << " h=" << oldWidth
+ << " new: w=" << newWidth << " h=" << newHeight
+ << " pixmapSize="
+ << kpPixmapFX::pixmapSize (newWidth,
+ newHeight,
+ QPixmap::defaultDepth ())
+ << " vs BigImageSize=" << KP_BIG_IMAGE_SIZE
+ << endl;
+#endif
+
+ // Only got smaller or unchanged - don't complain
+ if (!(newWidth > oldWidth || newHeight > oldHeight))
+ {
+ return true;
+ }
+
+ // Was already large - user was warned before, don't annoy him/her again
+ if (kpPixmapFX::pixmapSize (oldWidth, oldHeight, QPixmap::defaultDepth ()) >=
+ KP_BIG_IMAGE_SIZE)
+ {
+ return true;
+ }
+
+ if (kpPixmapFX::pixmapSize (newWidth, newHeight, QPixmap::defaultDepth ()) >=
+ KP_BIG_IMAGE_SIZE)
+ {
+ int accept = KMessageBox::warningContinueCancel (parent,
+ text,
+ caption,
+ continueButtonText,
+ QString::fromLatin1 ("BigImageDontAskAgain"));
+
+ return (accept == KMessageBox::Continue);
+ }
+ else
+ {
+ return true;
+ }
+}
+
+
+#include <kptool.moc>