TDE graphics utilities
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.
 
 
 
 

1446 lines
37 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_SELECTION 0
#include <kpselection.h>
#include <tqfont.h>
#include <tqimage.h>
#include <tqpainter.h>
#include <tqwmatrix.h>
#include <kdebug.h>
#include <tdelocale.h>
#include <kpcolorsimilaritydialog.h>
#include <kpdefs.h>
#include <kppixmapfx.h>
#include <kptool.h>
kpSelection::kpSelection (const kpSelectionTransparency &transparency)
: TQObject (),
m_type (kpSelection::Rectangle),
m_pixmap (0)
{
setTransparency (transparency);
}
kpSelection::kpSelection (Type type, const TQRect &rect, const TQPixmap &pixmap,
const kpSelectionTransparency &transparency)
: TQObject (),
m_type (type),
m_rect (rect)
{
calculatePoints ();
m_pixmap = pixmap.isNull () ? 0 : new TQPixmap (pixmap);
setTransparency (transparency);
}
kpSelection::kpSelection (Type type, const TQRect &rect, const kpSelectionTransparency &transparency)
: TQObject (),
m_type (type),
m_rect (rect),
m_pixmap (0)
{
calculatePoints ();
setTransparency (transparency);
}
kpSelection::kpSelection (const TQRect &rect,
const TQValueVector <TQString> &textLines_,
const kpTextStyle &textStyle_)
: TQObject (),
m_type (Text),
m_rect (rect),
m_pixmap (0),
m_textStyle (textStyle_)
{
calculatePoints ();
setTextLines (textLines_);
}
kpSelection::kpSelection (const TQPointArray &points, const TQPixmap &pixmap,
const kpSelectionTransparency &transparency)
: TQObject (),
m_type (Points),
m_rect (points.boundingRect ()),
m_points (points)
{
m_pixmap = pixmap.isNull () ? 0 : new TQPixmap (pixmap);
m_points.detach ();
setTransparency (transparency);
}
kpSelection::kpSelection (const TQPointArray &points, const kpSelectionTransparency &transparency)
: TQObject (),
m_type (Points),
m_rect (points.boundingRect ()),
m_points (points),
m_pixmap (0)
{
m_points.detach ();
setTransparency (transparency);
}
kpSelection::kpSelection (const kpSelection &rhs)
: TQObject (),
m_type (rhs.m_type),
m_rect (rhs.m_rect),
m_points (rhs.m_points),
m_pixmap (rhs.m_pixmap ? new TQPixmap (*rhs.m_pixmap) : 0),
m_textLines (rhs.m_textLines),
m_textStyle (rhs.m_textStyle),
m_transparency (rhs.m_transparency),
m_transparencyMask (rhs.m_transparencyMask)
{
m_points.detach ();
}
kpSelection &kpSelection::operator= (const kpSelection &rhs)
{
if (this == &rhs)
return *this;
m_type = rhs.m_type;
m_rect = rhs.m_rect;
m_points = rhs.m_points;
m_points.detach ();
delete m_pixmap;
m_pixmap = rhs.m_pixmap ? new TQPixmap (*rhs.m_pixmap) : 0;
m_textLines = rhs.m_textLines;
m_textStyle = rhs.m_textStyle;
m_transparency = rhs.m_transparency;
m_transparencyMask = rhs.m_transparencyMask;
return *this;
}
// friend
TQDataStream &operator<< (TQDataStream &stream, const kpSelection &selection)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::operator<<(sel: rect=" << selection.boundingRect ()
<< " pixmap rect=" << (selection.pixmap () ? selection.pixmap ()->rect () : TQRect ())
<< endl;
#endif
stream << int (selection.m_type);
stream << selection.m_rect;
stream << selection.m_points;
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\twrote type=" << int (selection.m_type) << " rect=" << selection.m_rect
<< " and points" << endl;
#endif
// TODO: need for text?
// For now we just use TQTextDrag for Text Selections so this point is mute.
if (selection.m_pixmap)
{
const TQImage image = kpPixmapFX::convertToImage (*selection.m_pixmap);
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\twrote image rect=" << image.rect () << endl;
#endif
stream << image;
}
else
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\twrote no image because no pixmap" << endl;
#endif
stream << TQImage ();
}
//stream << selection.m_textLines;
//stream << selection.m_textStyle;
return stream;
}
// friend
TQDataStream &operator>> (TQDataStream &stream, kpSelection &selection)
{
selection.readFromStream (stream);
return stream;
}
// public
// TODO: KolourPaint has not been tested against invalid or malicious
// clipboard data [Bug #28].
void kpSelection::readFromStream (TQDataStream &stream,
const kpPixmapFX::WarnAboutLossInfo &wali)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::readFromStream()" << endl;
#endif
int typeAsInt;
stream >> typeAsInt;
m_type = kpSelection::Type (typeAsInt);
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\ttype=" << typeAsInt << endl;
#endif
stream >> m_rect;
stream >> m_points;
m_points.detach ();
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\trect=" << m_rect << endl;
//kdDebug () << "\tpoints=" << m_points << endl;
#endif
TQImage image;
stream >> image;
delete m_pixmap;
if (!image.isNull ())
m_pixmap = new TQPixmap (kpPixmapFX::convertToPixmap (image, false/*no dither*/, wali));
else
m_pixmap = 0;
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\timage: w=" << image.width () << " h=" << image.height ()
<< " depth=" << image.depth () << endl;
if (m_pixmap)
{
kdDebug () << "\tpixmap: w=" << m_pixmap->width () << " h=" << m_pixmap->height ()
<< endl;
}
else
{
kdDebug () << "\tpixmap: none" << endl;
}
#endif
//stream >> m_textLines;
//stream >> m_textStyle;
}
kpSelection::~kpSelection ()
{
delete m_pixmap; m_pixmap = 0;
}
// private
void kpSelection::calculatePoints ()
{
if (m_type == kpSelection::Points)
return;
if (m_type == kpSelection::Ellipse)
{
m_points.makeEllipse (m_rect.x (), m_rect.y (),
m_rect.width (), m_rect.height ());
return;
}
if (m_type == kpSelection::Rectangle || m_type == kpSelection::Text)
{
// OPT: not space optimal - redoes corners
m_points.resize (m_rect.width () * 2 + m_rect.height () * 2);
int pointsUpto = 0;
// top
for (int x = 0; x < m_rect.width (); x++)
m_points [pointsUpto++] = TQPoint (m_rect.x () + x, m_rect.top ());
// right
for (int y = 0; y < m_rect.height (); y++)
m_points [pointsUpto++] = TQPoint (m_rect.right (), m_rect.y () + y);
// bottom
for (int x = m_rect.width () - 1; x >= 0; x--)
m_points [pointsUpto++] = TQPoint (m_rect.x () + x, m_rect.bottom ());
// left
for (int y = m_rect.height () - 1; y >= 0; y--)
m_points [pointsUpto++] = TQPoint (m_rect.left (), m_rect.y () + y);
return;
}
kdError () << "kpSelection::calculatePoints() with unknown type" << endl;
return;
}
// public
kpSelection::Type kpSelection::type () const
{
return m_type;
}
// public
bool kpSelection::isRectangular () const
{
return (m_type == Rectangle || m_type == Text);
}
// public
bool kpSelection::isText () const
{
return (m_type == Text);
}
// public
TQString kpSelection::name () const
{
if (m_type == Text)
return i18n ("Text");
return i18n ("Selection");
}
// public
int kpSelection::size () const
{
return kpPixmapFX::pointArraySize (m_points) +
kpPixmapFX::pixmapSize (m_pixmap) +
kpPixmapFX::stringSize (text ()) +
kpPixmapFX::pixmapSize (m_transparencyMask);
}
// public
TQBitmap kpSelection::maskForOwnType (bool nullForRectangular) const
{
if (!m_rect.isValid ())
{
kdError () << "kpSelection::maskForOwnType() boundingRect invalid" << endl;
return TQBitmap ();
}
if (isRectangular ())
{
if (nullForRectangular)
return TQBitmap ();
TQBitmap maskBitmap (m_rect.width (), m_rect.height ());
maskBitmap.fill (TQt::color1/*opaque*/);
return maskBitmap;
}
TQBitmap maskBitmap (m_rect.width (), m_rect.height ());
maskBitmap.fill (TQt::color0/*transparent*/);
TQPainter painter;
painter.begin (&maskBitmap);
painter.setPen (TQt::color1)/*opaque*/;
painter.setBrush (TQt::color1/*opaque*/);
if (m_type == kpSelection::Ellipse)
painter.drawEllipse (0, 0, m_rect.width (), m_rect.height ());
else if (m_type == kpSelection::Points)
{
TQPointArray points = m_points;
points.detach ();
points.translate (-m_rect.x (), -m_rect.y ());
painter.drawPolygon (points, false/*even-odd algo*/);
}
painter.end ();
return maskBitmap;
}
// public
TQPoint kpSelection::topLeft () const
{
return m_rect.topLeft ();
}
// public
TQPoint kpSelection::point () const
{
return m_rect.topLeft ();
}
// public
int kpSelection::x () const
{
return m_rect.x ();
}
// public
int kpSelection::y () const
{
return m_rect.y ();
}
// public
void kpSelection::moveBy (int dx, int dy)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::moveBy(" << dx << "," << dy << ")" << endl;
#endif
if (dx == 0 && dy == 0)
return;
TQRect oldRect = boundingRect ();
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\toldRect=" << oldRect << endl;
#endif
m_rect.moveBy (dx, dy);
m_points.translate (dx, dy);
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\tnewRect=" << m_rect << endl;
#endif
emit changed (oldRect);
emit changed (boundingRect ());
}
// public
void kpSelection::moveTo (int dx, int dy)
{
moveTo (TQPoint (dx, dy));
}
// public
void kpSelection::moveTo (const TQPoint &topLeftPoint)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::moveTo(" << topLeftPoint << ")" << endl;
#endif
TQRect oldBoundingRect = boundingRect ();
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\toldBoundingRect=" << oldBoundingRect << endl;
#endif
if (topLeftPoint == oldBoundingRect.topLeft ())
return;
TQPoint delta (topLeftPoint - oldBoundingRect.topLeft ());
moveBy (delta.x (), delta.y ());
}
// public
TQPointArray kpSelection::points () const
{
return m_points;
}
// public
TQPointArray kpSelection::pointArray () const
{
return m_points;
}
// public
TQRect kpSelection::boundingRect () const
{
return m_rect;
}
// public
int kpSelection::width () const
{
return boundingRect ().width ();
}
// public
int kpSelection::height () const
{
return boundingRect ().height ();
}
// public
bool kpSelection::contains (const TQPoint &point) const
{
TQRect rect = boundingRect ();
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::contains(" << point
<< ") rect==" << rect
<< " #points=" << m_points.size ()
<< endl;
#endif
if (!rect.contains (point))
return false;
// OPT: TQRegion is probably incredibly slow - cache
// We can't use the m_pixmap (if avail) and get the transparency of
// the pixel at that point as it may be transparent but still within the
// border
switch (m_type)
{
case kpSelection::Rectangle:
case kpSelection::Text:
return true;
case kpSelection::Ellipse:
return TQRegion (m_rect, TQRegion::Ellipse).contains (point);
case kpSelection::Points:
// TODO: make this always include the border
// (draw up a rect sel in this mode to see what I mean)
return TQRegion (m_points, false/*even-odd algo*/).contains (point);
default:
return false;
}
}
// public
bool kpSelection::contains (int x, int y)
{
return contains (TQPoint (x, y));
}
// public
TQPixmap *kpSelection::pixmap () const
{
return m_pixmap;
}
// public
void kpSelection::setPixmap (const TQPixmap &pixmap)
{
delete m_pixmap;
// TODO: If isText(), setting pixmap() to 0 is unexpected (implies
// it's a border, not a text box) but saves memory when using
// that kpSelection::setPixmap (TQPixmap ()) hack.
m_pixmap = pixmap.isNull () ? 0 : new TQPixmap (pixmap);
TQRect changedRect = boundingRect ();
if (m_pixmap)
{
const bool changedSize = (m_pixmap->width () != m_rect.width () ||
m_pixmap->height () != m_rect.height ());
const bool changedFromText = (m_type == Text);
if (changedSize || changedFromText)
{
if (changedSize)
{
kdError () << "kpSelection::setPixmap() changes the size of the selection!"
<< " old:"
<< " w=" << m_rect.width ()
<< " h=" << m_rect.height ()
<< " new:"
<< " w=" << m_pixmap->width ()
<< " h=" << m_pixmap->height ()
<< endl;
}
if (changedFromText)
{
kdError () << "kpSelection::setPixmap() changed from text" << endl;
}
m_type = kpSelection::Rectangle;
m_rect = TQRect (m_rect.x (), m_rect.y (),
m_pixmap->width (), m_pixmap->height ());
calculatePoints ();
m_textLines = TQValueVector <TQString> ();
changedRect = changedRect.unite (boundingRect ());
}
}
calculateTransparencyMask ();
emit changed (changedRect);
}
// public
bool kpSelection::usesBackgroundPixmapToPaint () const
{
// Opaque text with transparent background needs to antialias with
// doc pixmap below it.
return (isText () &&
m_textStyle.foregroundColor ().isOpaque () &&
m_textStyle.effectiveBackgroundColor ().isTransparent ());
}
static int mostContrastingValue (int val)
{
if (val <= 127)
return 255;
else
return 0;
}
static TQRgb mostContrastingRGB (TQRgb val)
{
return tqRgba (mostContrastingValue (tqRed (val)),
mostContrastingValue (tqGreen (val)),
mostContrastingValue (tqBlue (val)),
mostContrastingValue (tqAlpha (val)));
}
// private
static void drawTextLines (TQPainter *painter, TQPainter *maskPainter,
const TQRect &rect,
const TQValueVector <TQString> &textLines)
{
if (!painter->clipRegion ().isEmpty () || !maskPainter->clipRegion ().isEmpty ())
{
// TODO: fix esp. before making method public
kdError () << "kpselection.cpp:drawTextLines() can't deal with existing painter clip regions" << endl;
return;
}
#define PAINTER_CALL(cmd) \
{ \
if (painter->isActive ()) \
painter->cmd; \
\
if (maskPainter->isActive ()) \
maskPainter->cmd; \
}
// Can't do this because the line heights become
// >TQFontMetrics::height() if you type Chinese characters (!) and then
// the cursor gets out of sync.
// PAINTER_CALL (drawText (rect, 0/*flags*/, text ()));
#if 0
const TQFontMetrics fontMetrics (painter->fontMetrics ());
kdDebug () << "height=" << fontMetrics.height ()
<< " leading=" << fontMetrics.leading ()
<< " ascent=" << fontMetrics.ascent ()
<< " descent=" << fontMetrics.descent ()
<< " lineSpacing=" << fontMetrics.lineSpacing ()
<< endl;
#endif
PAINTER_CALL (setClipRect (rect, TQPainter::CoordPainter/*transform*/));
int baseLine = rect.y () + painter->fontMetrics ().ascent ();
for (TQValueVector <TQString>::const_iterator it = textLines.begin ();
it != textLines.end ();
it++)
{
PAINTER_CALL (drawText (rect.x (), baseLine, *it));
baseLine += painter->fontMetrics ().lineSpacing ();
}
#undef PAINTER_CALL
}
// private
void kpSelection::paintOpaqueText (TQPixmap *destPixmap, const TQRect &docRect) const
{
if (!isText () || !m_textStyle.foregroundColor ().isOpaque ())
return;
const TQRect modifyingRect = docRect.intersect (boundingRect ());
if (modifyingRect.isEmpty ())
return;
TQBitmap destPixmapMask;
TQPainter destPixmapPainter, destPixmapMaskPainter;
if (destPixmap->mask ())
{
if (m_textStyle.effectiveBackgroundColor ().isTransparent ())
{
TQRect modifyingRectRelPixmap = modifyingRect;
modifyingRectRelPixmap.moveBy (-docRect.x (), -docRect.y ());
// Set the RGB of transparent pixels to foreground colour to avoid
// anti-aliasing the foreground coloured text with undefined RGBs.
kpPixmapFX::setPixmapAt (destPixmap,
modifyingRectRelPixmap,
kpPixmapFX::pixmapWithDefinedTransparentPixels (
kpPixmapFX::getPixmapAt (*destPixmap, modifyingRectRelPixmap),
m_textStyle.foregroundColor ().toTQColor ()));
}
destPixmapMask = *destPixmap->mask ();
destPixmapMaskPainter.begin (&destPixmapMask);
destPixmapMaskPainter.translate (-docRect.x (), -docRect.y ());
destPixmapMaskPainter.setPen (TQt::color1/*opaque*/);
destPixmapMaskPainter.setFont (m_textStyle.font ());
}
destPixmapPainter.begin (destPixmap);
destPixmapPainter.translate (-docRect.x (), -docRect.y ());
destPixmapPainter.setPen (m_textStyle.foregroundColor ().toTQColor ());
destPixmapPainter.setFont (m_textStyle.font ());
if (m_textStyle.effectiveBackgroundColor ().isOpaque ())
{
destPixmapPainter.fillRect (
boundingRect (),
m_textStyle.effectiveBackgroundColor ().toTQColor ());
if (destPixmapMaskPainter.isActive ())
{
destPixmapMaskPainter.fillRect (
boundingRect (),
TQt::color1/*opaque*/);
}
}
::drawTextLines (&destPixmapPainter, &destPixmapMaskPainter,
textAreaRect (),
textLines ());
if (destPixmapPainter.isActive ())
destPixmapPainter.end ();
if (destPixmapMaskPainter.isActive ())
destPixmapMaskPainter.end ();
if (!destPixmapMask.isNull ())
destPixmap->setMask (destPixmapMask);
}
// private
TQPixmap kpSelection::transparentForegroundTextPixmap () const
{
if (!isText () || !m_textStyle.foregroundColor ().isTransparent ())
return TQPixmap ();
TQPixmap pixmap (m_rect.width (), m_rect.height ());
TQBitmap pixmapMask (m_rect.width (), m_rect.height ());
// Iron out stupid case first
if (m_textStyle.effectiveBackgroundColor ().isTransparent ())
{
pixmapMask.fill (TQt::color0/*transparent*/);
pixmap.setMask (pixmapMask);
return pixmap;
}
// -- Foreground transparent, background opaque --
TQFont font = m_textStyle.font ();
// TODO: why doesn't "font.setStyleStrategy (TQFont::NoAntialias);"
// let us avoid the hack below?
TQPainter pixmapPainter, pixmapMaskPainter;
pixmap.fill (m_textStyle.effectiveBackgroundColor ().toTQColor ());
pixmapPainter.begin (&pixmap);
// HACK: Transparent foreground colour + antialiased fonts don't
// work - they don't seem to be able to draw in
// TQt::color0/*transparent*/ (but TQt::color1 seems Ok).
// So we draw in a contrasting color to the background so that
// we can identify the transparent pixels for manually creating
// the mask.
pixmapPainter.setPen (
TQColor (mostContrastingRGB (m_textStyle.effectiveBackgroundColor ().toTQRgb () & TQRGB_MASK)));
pixmapPainter.setFont (font);
pixmapMask.fill (TQt::color1/*opaque*/);
pixmapMaskPainter.begin (&pixmapMask);
pixmapMaskPainter.setPen (TQt::color0/*transparent*/);
pixmapMaskPainter.setFont (font);
TQRect rect (textAreaRect ());
rect.moveBy (-m_rect.x (), -m_rect.y ());
::drawTextLines (&pixmapPainter, &pixmapMaskPainter,
rect,
textLines ());
if (pixmapPainter.isActive ())
pixmapPainter.end ();
if (pixmapMaskPainter.isActive ())
pixmapMaskPainter.end ();
#if DEBUG_KP_SELECTION
kdDebug () << "\tinvoking foreground transparency hack" << endl;
#endif
TQImage image = kpPixmapFX::convertToImage (pixmap);
TQRgb backgroundRGB = image.pixel (0, 0); // on textBorderSize()
pixmapMaskPainter.begin (&pixmapMask);
for (int y = 0; y < image.height (); y++)
{
for (int x = 0; x < image.width (); x++)
{
if (image.pixel (x, y) == backgroundRGB)
pixmapMaskPainter.setPen (TQt::color1/*opaque*/);
else
pixmapMaskPainter.setPen (TQt::color0/*transparent*/);
pixmapMaskPainter.drawPoint (x, y);
}
}
pixmapMaskPainter.end ();
if (!pixmapMask.isNull ())
pixmap.setMask (pixmapMask);
return pixmap;
}
// public
void kpSelection::paint (TQPixmap *destPixmap, const TQRect &docRect) const
{
if (!isText ())
{
if (pixmap () && !pixmap ()->isNull ())
{
kpPixmapFX::paintPixmapAt (destPixmap,
topLeft () - docRect.topLeft (),
transparentPixmap ());
}
}
else
{
#if DEBUG_KP_SELECTION
kdDebug () << "kpSelection::paint() textStyle: fcol="
<< (int *) m_textStyle.foregroundColor ().toTQRgb ()
<< " bcol="
<< (int *) m_textStyle.effectiveBackgroundColor ().toTQRgb ()
<< endl;
#endif
if (m_textStyle.foregroundColor ().isOpaque ())
{
// (may have to antialias with background so don't use m_pixmap)
paintOpaqueText (destPixmap, docRect);
}
else
{
if (!m_pixmap)
{
kdError () << "kpSelection::paint() without m_pixmap?" << endl;
return;
}
// (transparent foreground slow to render, no antialiasing
// so use m_pixmap cache)
kpPixmapFX::paintPixmapAt (destPixmap,
topLeft () - docRect.topLeft (),
*m_pixmap);
}
}
}
// private
void kpSelection::calculateTextPixmap ()
{
if (!isText ())
{
kdError () << "kpSelection::calculateTextPixmap() not text sel"
<< endl;
return;
}
delete m_pixmap;
if (m_textStyle.foregroundColor().isOpaque ())
{
m_pixmap = new TQPixmap (m_rect.width (), m_rect.height ());
if (usesBackgroundPixmapToPaint ())
kpPixmapFX::fill (m_pixmap, kpColor::transparent);
paintOpaqueText (m_pixmap, m_rect);
}
else
{
m_pixmap = new TQPixmap (transparentForegroundTextPixmap ());
}
}
// public static
TQString kpSelection::textForTextLines (const TQValueVector <TQString> &textLines_)
{
if (textLines_.isEmpty ())
return TQString();
TQString bigString = textLines_ [0];
for (TQValueVector <TQString>::const_iterator it = textLines_.begin () + 1;
it != textLines_.end ();
it++)
{
bigString += TQString::fromLatin1 ("\n");
bigString += (*it);
}
return bigString;
}
// public
TQString kpSelection::text () const
{
if (!isText ())
{
return TQString();
}
return textForTextLines (m_textLines);
}
// public
TQValueVector <TQString> kpSelection::textLines () const
{
if (!isText ())
{
kdError () << "kpSelection::textLines() not a text selection" << endl;
return TQValueVector <TQString> ();
}
return m_textLines;
}
// public
void kpSelection::setTextLines (const TQValueVector <TQString> &textLines_)
{
if (!isText ())
{
kdError () << "kpSelection::setTextLines() not a text selection" << endl;
return;
}
m_textLines = textLines_;
if (m_textLines.isEmpty ())
{
kdError () << "kpSelection::setTextLines() passed no lines" << endl;
m_textLines.push_back (TQString());
}
calculateTextPixmap ();
emit changed (boundingRect ());
}
// public static
int kpSelection::textBorderSize ()
{
return 1;
}
// public
TQRect kpSelection::textAreaRect () const
{
if (!isText ())
{
kdError () << "kpSelection::textAreaRect() not a text selection" << endl;
return TQRect ();
}
return TQRect (m_rect.x () + textBorderSize (),
m_rect.y () + textBorderSize (),
m_rect.width () - textBorderSize () * 2,
m_rect.height () - textBorderSize () * 2);
}
// public
bool kpSelection::pointIsInTextBorderArea (const TQPoint &globalPoint) const
{
if (!isText ())
{
kdError () << "kpSelection::pointIsInTextBorderArea() not a text selection" << endl;
return false;
}
return (m_rect.contains (globalPoint) && !pointIsInTextArea (globalPoint));
}
// public
bool kpSelection::pointIsInTextArea (const TQPoint &globalPoint) const
{
if (!isText ())
{
kdError () << "kpSelection::pointIsInTextArea() not a text selection" << endl;
return false;
}
return textAreaRect ().contains (globalPoint);
}
// public
void kpSelection::textResize (int width, int height)
{
if (!isText ())
{
kdError () << "kpSelection::textResize() not a text selection" << endl;
return;
}
TQRect oldRect = m_rect;
m_rect = TQRect (oldRect.x (), oldRect.y (), width, height);
calculatePoints ();
calculateTextPixmap ();
emit changed (m_rect.unite (oldRect));
}
// public static
int kpSelection::minimumWidthForTextStyle (const kpTextStyle &)
{
return (kpSelection::textBorderSize () * 2 + 5);
}
// public static
int kpSelection::minimumHeightForTextStyle (const kpTextStyle &)
{
return (kpSelection::textBorderSize () * 2 + 5);
}
// public static
TQSize kpSelection::minimumSizeForTextStyle (const kpTextStyle &textStyle)
{
return TQSize (minimumWidthForTextStyle (textStyle),
minimumHeightForTextStyle (textStyle));
}
// public static
int kpSelection::preferredMinimumWidthForTextStyle (const kpTextStyle &textStyle)
{
const int about15CharsWidth =
textStyle.fontMetrics ().width (
TQString::fromLatin1 ("1234567890abcde"));
const int preferredMinWidth =
TQMAX (150,
textBorderSize () * 2 + about15CharsWidth);
return TQMAX (minimumWidthForTextStyle (textStyle),
TQMIN (250, preferredMinWidth));
}
// public static
int kpSelection::preferredMinimumHeightForTextStyle (const kpTextStyle &textStyle)
{
const int preferredMinHeight =
textBorderSize () * 2 + textStyle.fontMetrics ().height ();
return TQMAX (minimumHeightForTextStyle (textStyle),
TQMIN (150, preferredMinHeight));
}
// public static
TQSize kpSelection::preferredMinimumSizeForTextStyle (const kpTextStyle &textStyle)
{
return TQSize (preferredMinimumWidthForTextStyle (textStyle),
preferredMinimumHeightForTextStyle (textStyle));
}
// public
int kpSelection::minimumWidth () const
{
if (isText ())
return minimumWidthForTextStyle (textStyle ());
else
return 1;
}
// public
int kpSelection::minimumHeight () const
{
if (isText ())
return minimumHeightForTextStyle (textStyle ());
else
return 1;
}
// public
TQSize kpSelection::minimumSize () const
{
return TQSize (minimumWidth (), minimumHeight ());
}
// public
int kpSelection::textRowForPoint (const TQPoint &globalPoint) const
{
if (!isText ())
{
kdError () << "kpSelection::textRowForPoint() not a text selection" << endl;
return -1;
}
if (!pointIsInTextArea (globalPoint))
return -1;
const TQFontMetrics fontMetrics (m_textStyle.fontMetrics ());
int row = (globalPoint.y () - textAreaRect ().y ()) /
fontMetrics.lineSpacing ();
if (row >= (int) m_textLines.size ())
row = m_textLines.size () - 1;
return row;
}
// public
int kpSelection::textColForPoint (const TQPoint &globalPoint) const
{
if (!isText ())
{
kdError () << "kpSelection::textColForPoint() not a text selection" << endl;
return -1;
}
int row = textRowForPoint (globalPoint);
if (row < 0 || row >= (int) m_textLines.size ())
return -1;
const int localX = globalPoint.x () - textAreaRect ().x ();
const TQFontMetrics fontMetrics (m_textStyle.fontMetrics ());
// (should be 0 but call just in case)
int charLocalLeft = fontMetrics.width (m_textLines [row], 0);
// OPT: binary search or guess location then move
for (int col = 0; col < (int) m_textLines [row].length (); col++)
{
// OPT: fontMetrics::charWidth() might be faster
const int nextCharLocalLeft = fontMetrics.width (m_textLines [row], col + 1);
if (localX <= (charLocalLeft + nextCharLocalLeft) / 2)
return col;
charLocalLeft = nextCharLocalLeft;
}
return m_textLines [row].length ()/*past end of line*/;
}
// public
TQPoint kpSelection::pointForTextRowCol (int row, int col)
{
if (!isText ())
{
kdError () << "kpSelection::pointForTextRowCol() not a text selection" << endl;
return KP_INVALID_POINT;
}
if (row < 0 || row >= (int) m_textLines.size () ||
col < 0 || col > (int) m_textLines [row].length ())
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::pointForTextRowCol("
<< row << ","
<< col << ") out of range"
<< " textLines='"
<< text ()
<< "'"
<< endl;
#endif
return KP_INVALID_POINT;
}
const TQFontMetrics fontMetrics (m_textStyle.fontMetrics ());
const int x = fontMetrics.width (m_textLines [row], col);
const int y = row * fontMetrics.height () +
(row >= 1 ? row * fontMetrics.leading () : 0);
return textAreaRect ().topLeft () + TQPoint (x, y);
}
// public
kpTextStyle kpSelection::textStyle () const
{
if (!isText ())
{
kdError () << "kpSelection::textStyle() not a text selection" << endl;
}
return m_textStyle;
}
// public
void kpSelection::setTextStyle (const kpTextStyle &textStyle_)
{
if (!isText ())
{
kdError () << "kpSelection::setTextStyle() not a text selection" << endl;
return;
}
m_textStyle = textStyle_;
calculateTextPixmap ();
emit changed (boundingRect ());
}
// public
TQPixmap kpSelection::opaquePixmap () const
{
TQPixmap *p = pixmap ();
if (p)
{
return *p;
}
else
{
return TQPixmap ();
}
}
// private
void kpSelection::calculateTransparencyMask ()
{
#if DEBUG_KP_SELECTION
kdDebug () << "kpSelection::calculateTransparencyMask()" << endl;
#endif
if (isText ())
{
#if DEBUG_KP_SELECTION
kdDebug () << "\ttext - no need for transparency mask" << endl;
#endif
m_transparencyMask.resize (0, 0);
return;
}
if (!m_pixmap)
{
#if DEBUG_KP_SELECTION
kdDebug () << "\tno pixmap - no need for transparency mask" << endl;
#endif
m_transparencyMask.resize (0, 0);
return;
}
if (m_transparency.isOpaque ())
{
#if DEBUG_KP_SELECTION
kdDebug () << "\topaque - no need for transparency mask" << endl;
#endif
m_transparencyMask.resize (0, 0);
return;
}
m_transparencyMask.resize (m_pixmap->width (), m_pixmap->height ());
TQImage image = kpPixmapFX::convertToImage (*m_pixmap);
TQPainter transparencyMaskPainter (&m_transparencyMask);
bool hasTransparent = false;
for (int y = 0; y < m_pixmap->height (); y++)
{
for (int x = 0; x < m_pixmap->width (); x++)
{
if (kpPixmapFX::getColorAtPixel (image, x, y).isSimilarTo (m_transparency.transparentColor (),
m_transparency.processedColorSimilarity ()))
{
transparencyMaskPainter.setPen (TQt::color1/*make it transparent*/);
hasTransparent = true;
}
else
{
transparencyMaskPainter.setPen (TQt::color0/*keep pixel as is*/);
}
transparencyMaskPainter.drawPoint (x, y);
}
}
transparencyMaskPainter.end ();
if (!hasTransparent)
{
#if DEBUG_KP_SELECTION
kdDebug () << "\tcolour useless - completely opaque" << endl;
#endif
m_transparencyMask.resize (0, 0);
return;
}
}
// public
TQPixmap kpSelection::transparentPixmap () const
{
TQPixmap pixmap = opaquePixmap ();
if (!m_transparencyMask.isNull ())
{
kpPixmapFX::paintMaskTransparentWithBrush (&pixmap, TQPoint (0, 0),
m_transparencyMask);
}
return pixmap;
}
// public
kpSelectionTransparency kpSelection::transparency () const
{
return m_transparency;
}
// public
bool kpSelection::setTransparency (const kpSelectionTransparency &transparency,
bool checkTransparentPixmapChanged)
{
if (m_transparency == transparency)
return false;
m_transparency = transparency;
bool haveChanged = true;
TQBitmap oldTransparencyMask = m_transparencyMask;
calculateTransparencyMask ();
if (oldTransparencyMask.width () == m_transparencyMask.width () &&
oldTransparencyMask.height () == m_transparencyMask.height ())
{
if (m_transparencyMask.isNull ())
{
#if DEBUG_KP_SELECTION
kdDebug () << "\tboth old and new pixmaps are null - nothing changed" << endl;
#endif
haveChanged = false;
}
else if (checkTransparentPixmapChanged)
{
TQImage oldTransparencyMaskImage = kpPixmapFX::convertToImage (oldTransparencyMask);
TQImage newTransparencyMaskImage = kpPixmapFX::convertToImage (m_transparencyMask);
bool changed = false;
for (int y = 0; y < oldTransparencyMaskImage.height () && !changed; y++)
{
for (int x = 0; x < oldTransparencyMaskImage.width () && !changed; x++)
{
if (kpPixmapFX::getColorAtPixel (oldTransparencyMaskImage, x, y) !=
kpPixmapFX::getColorAtPixel (newTransparencyMaskImage, x, y))
{
#if DEBUG_KP_SELECTION
kdDebug () << "\tdiffer at " << TQPoint (x, y)
<< " old=" << (int *) kpPixmapFX::getColorAtPixel (oldTransparencyMaskImage, x, y).toTQRgb ()
<< " new=" << (int *) kpPixmapFX::getColorAtPixel (newTransparencyMaskImage, x, y).toTQRgb ()
<< endl;
#endif
changed = true;
break;
}
}
}
if (!changed)
haveChanged = false;
}
}
if (haveChanged)
emit changed (boundingRect ());
return haveChanged;
}
// private
void kpSelection::flipPoints (bool horiz, bool vert)
{
TQRect oldRect = boundingRect ();
m_points.translate (-oldRect.x (), -oldRect.y ());
const TQWMatrix matrix = kpPixmapFX::flipMatrix (oldRect.width (), oldRect.height (),
horiz, vert);
m_points = matrix.map (m_points);
m_points.translate (oldRect.x (), oldRect.y ());
}
// public
void kpSelection::flip (bool horiz, bool vert)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "kpSelection::flip(horiz=" << horiz
<< ",vert=" << vert << ")" << endl;
#endif
flipPoints (horiz, vert);
if (m_pixmap)
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\thave pixmap - flipping that" << endl;
#endif
kpPixmapFX::flip (m_pixmap, horiz, vert);
}
if (!m_transparencyMask.isNull ())
{
#if DEBUG_KP_SELECTION && 1
kdDebug () << "\thave transparency mask - flipping that" << endl;
#endif
kpPixmapFX::flip (TQT_TQPIXMAP(&m_transparencyMask), horiz, vert);
}
emit changed (boundingRect ());
}
#include <kpselection.moc>