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.
965 lines
25 KiB
965 lines
25 KiB
/*
|
|
Copyright (C) 2000, S.R.Haque <shaheedhaque@hotmail.com>.
|
|
This file is part of the KDE project
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
|
|
DESCRIPTION
|
|
|
|
This is based on code originally written by Stefan Taferner
|
|
(taferner@kde.org) and also borrows from libwmf (by Martin Vermeer and
|
|
Caolan McNamara).
|
|
*/
|
|
|
|
#include <kdebug.h>
|
|
#include <math.h>
|
|
#include <tqfile.h>
|
|
#include <tqpointarray.h>
|
|
#include <kwmf.h>
|
|
#include <tqrect.h>
|
|
|
|
#define PI (3.14159265358979323846)
|
|
|
|
const int KWmf::s_area = 30504;
|
|
const int KWmf::s_maxHandles = 64;
|
|
|
|
KWmf::KWmf(
|
|
unsigned dpi)
|
|
{
|
|
m_dpi = dpi;
|
|
m_objectHandles = new WinObjHandle*[s_maxHandles];
|
|
}
|
|
|
|
KWmf::~KWmf()
|
|
{
|
|
delete[] m_objectHandles;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
void KWmf::brushSet(
|
|
unsigned colour,
|
|
unsigned style)
|
|
{
|
|
m_dc.m_brushColour = colour;
|
|
m_dc.m_brushStyle = style;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
unsigned KWmf::getColour(
|
|
S32 colour)
|
|
{
|
|
unsigned red, green, blue;
|
|
|
|
red = colour & 255;
|
|
green = (colour >> 8) & 255;
|
|
blue = (colour >> 16) & 255;
|
|
return (red << 16) + (green << 8) + blue;
|
|
}
|
|
|
|
void KWmf::genericArc(
|
|
TQString type,
|
|
TQDataStream &operands)
|
|
{
|
|
TQPoint topLeft;
|
|
TQPoint bottomRight;
|
|
TQPoint start;
|
|
TQPoint end;
|
|
|
|
topLeft = normalisePoint(operands);
|
|
bottomRight = normalisePoint(operands);
|
|
start = normalisePoint(operands);
|
|
end = normalisePoint(operands);
|
|
|
|
// WMF defines arcs with the major and minor axes of an ellipse, and two points.
|
|
// From each point draw a line to the center of the ellipse: the intercepts define
|
|
// the ends of the arc.
|
|
|
|
TQRect ellipse(topLeft, bottomRight);
|
|
TQPoint centre = ellipse.center();
|
|
double startAngle = atan2((double)(centre.y() - start.y()), (double)(centre.x() - start.x()));
|
|
double stopAngle = atan2((double)(centre.y() - end.y()), (double)(centre.x() - end.x()));
|
|
|
|
startAngle = 180 * startAngle / PI;
|
|
stopAngle = 180 * stopAngle / PI;
|
|
|
|
gotEllipse(m_dc, type, centre, ellipse.size() / 2,
|
|
static_cast<unsigned int>(startAngle),
|
|
static_cast<unsigned int>(stopAngle));
|
|
}
|
|
|
|
int KWmf::handleIndex(void) const
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < s_maxHandles; i++)
|
|
{
|
|
if (!m_objectHandles[i])
|
|
return i;
|
|
}
|
|
kdError(s_area) << "handle table full !" << endl;
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
KWmf::WinObjPenHandle *KWmf::handleCreatePen(void)
|
|
{
|
|
WinObjPenHandle *handle = new WinObjPenHandle;
|
|
int idx = handleIndex();
|
|
|
|
if (idx >= 0)
|
|
m_objectHandles[idx] = handle;
|
|
return handle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
KWmf::WinObjBrushHandle *KWmf::handleCreateBrush(void)
|
|
{
|
|
WinObjBrushHandle *handle = new WinObjBrushHandle;
|
|
int idx = handleIndex();
|
|
|
|
if (idx >= 0)
|
|
m_objectHandles[idx] = handle;
|
|
return handle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void KWmf::handleDelete(int idx)
|
|
{
|
|
if (idx >= 0 && idx < s_maxHandles && m_objectHandles[idx])
|
|
{
|
|
delete m_objectHandles[idx];
|
|
m_objectHandles[idx] = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
void KWmf::invokeHandler(
|
|
S16 opcode,
|
|
U32 words,
|
|
TQDataStream &operands)
|
|
{
|
|
typedef void (KWmf::*method)(U32 words, TQDataStream &operands);
|
|
|
|
typedef struct
|
|
{
|
|
const char *name;
|
|
unsigned short opcode;
|
|
method handler;
|
|
} opcodeEntry;
|
|
|
|
static const opcodeEntry funcTab[] =
|
|
{
|
|
{ "ANIMATEPALETTE", 0x0436, 0 },
|
|
{ "ARC", 0x0817, &KWmf::opArc },
|
|
{ "BITBLT", 0x0922, 0 },
|
|
{ "CHORD", 0x0830, 0 },
|
|
{ "CREATEBRUSHINDIRECT", 0x02FC, &KWmf::opBrushCreateIndirect },
|
|
{ "CREATEFONTINDIRECT", 0x02FB, 0 },
|
|
{ "CREATEPALETTE", 0x00F7, 0 },
|
|
{ "CREATEPATTERNBRUSH", 0x01F9, 0 },
|
|
{ "CREATEPENINDIRECT", 0x02FA, &KWmf::opPenCreateIndirect },
|
|
{ "CREATEREGION", 0x06FF, 0 },
|
|
{ "DELETEOBJECT", 0x01F0, &KWmf::opObjectDelete },
|
|
{ "DIBBITBLT", 0x0940, 0 },
|
|
{ "DIBCREATEPATTERNBRUSH",0x0142, 0 },
|
|
{ "DIBSTRETCHBLT", 0x0b41, 0 },
|
|
{ "ELLIPSE", 0x0418, &KWmf::opEllipse },
|
|
{ "ESCAPE", 0x0626, &KWmf::opNoop },
|
|
{ "EXCLUDECLIPRECT", 0x0415, 0 },
|
|
{ "EXTFLOODFILL", 0x0548, 0 },
|
|
{ "EXTTEXTOUT", 0x0a32, 0 },
|
|
{ "FILLREGION", 0x0228, 0 },
|
|
{ "FLOODFILL", 0x0419, 0 },
|
|
{ "FRAMEREGION", 0x0429, 0 },
|
|
{ "INTERSECTCLIPRECT", 0x0416, 0 },
|
|
{ "INVERTREGION", 0x012A, 0 },
|
|
{ "LINETO", 0x0213, &KWmf::opLineTo },
|
|
{ "MOVETO", 0x0214, &KWmf::opMoveTo },
|
|
{ "OFFSETCLIPRGN", 0x0220, 0 },
|
|
{ "OFFSETVIEWPORTORG", 0x0211, 0 },
|
|
{ "OFFSETWINDOWORG", 0x020F, 0 },
|
|
{ "PAINTREGION", 0x012B, 0 },
|
|
{ "PATBLT", 0x061D, 0 },
|
|
{ "PIE", 0x081A, &KWmf::opPie },
|
|
{ "POLYGON", 0x0324, &KWmf::opPolygon },
|
|
{ "POLYLINE", 0x0325, &KWmf::opPolyline },
|
|
{ "POLYPOLYGON", 0x0538, 0 },
|
|
{ "REALIZEPALETTE", 0x0035, 0 },
|
|
{ "RECTANGLE", 0x041B, &KWmf::opRectangle },
|
|
{ "RESIZEPALETTE", 0x0139, 0 },
|
|
{ "RESTOREDC", 0x0127, &KWmf::opRestoreDc },
|
|
{ "ROUNDRECT", 0x061C, 0 },
|
|
{ "SAVEDC", 0x001E, &KWmf::opSaveDc },
|
|
{ "SCALEVIEWPORTEXT", 0x0412, 0 },
|
|
{ "SCALEWINDOWEXT", 0x0410, 0 },
|
|
{ "SELECTCLIPREGION", 0x012C, 0 },
|
|
{ "SELECTOBJECT", 0x012D, &KWmf::opObjectSelect },
|
|
{ "SELECTPALETTE", 0x0234, 0 },
|
|
{ "SETBKCOLOR", 0x0201, 0 },
|
|
{ "SETBKMODE", 0x0102, 0 },
|
|
{ "SETDIBTODEV", 0x0d33, 0 },
|
|
{ "SETMAPMODE", 0x0103, 0 },
|
|
{ "SETMAPPERFLAGS", 0x0231, 0 },
|
|
{ "SETPALENTRIES", 0x0037, 0 },
|
|
{ "SETPIXEL", 0x041F, 0 },
|
|
{ "SETPOLYFILLMODE", 0x0106, &KWmf::opPolygonSetFillMode },
|
|
{ "SETRELABS", 0x0105, 0 },
|
|
{ "SETROP2", 0x0104, 0 },
|
|
{ "SETSTRETCHBLTMODE", 0x0107, 0 },
|
|
{ "SETTEXTALIGN", 0x012E, 0 },
|
|
{ "SETTEXTCHAREXTRA", 0x0108, 0 },
|
|
{ "SETTEXTCOLOR", 0x0209, 0 },
|
|
{ "SETTEXTJUSTIFICATION", 0x020A, 0 },
|
|
{ "SETVIEWPORTEXT", 0x020E, 0 },
|
|
{ "SETVIEWPORTORG", 0x020D, 0 },
|
|
{ "SETWINDOWEXT", 0x020C, &KWmf::opWindowSetExt },
|
|
{ "SETWINDOWORG", 0x020B, &KWmf::opWindowSetOrg },
|
|
{ "STRETCHBLT", 0x0B23, 0 },
|
|
{ "STRETCHDIB", 0x0f43, 0 },
|
|
{ "TEXTOUT", 0x0521, 0 },
|
|
{ NULL, 0, 0 }
|
|
};
|
|
unsigned i;
|
|
method result;
|
|
|
|
// Scan lookup table for operation.
|
|
|
|
for (i = 0; funcTab[i].name; i++)
|
|
{
|
|
if (funcTab[i].opcode == opcode)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Invoke handler.
|
|
|
|
result = funcTab[i].handler;
|
|
if (!result)
|
|
{
|
|
if (funcTab[i].name)
|
|
kdError(s_area) << "invokeHandler: unsupported opcode: " <<
|
|
funcTab[i].name <<
|
|
" operands: " << words << endl;
|
|
else
|
|
kdError(s_area) << "invokeHandler: unsupported opcode: 0x" <<
|
|
TQString::number(opcode, 16) <<
|
|
" operands: " << words << endl;
|
|
|
|
// Skip data we cannot use.
|
|
|
|
for (i = 0; i < words; i++)
|
|
{
|
|
S16 discard;
|
|
|
|
operands >> discard;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
kdDebug(s_area) << "invokeHandler: opcode: " << funcTab[i].name <<
|
|
" operands: " << words << endl;
|
|
|
|
// We don't invoke the handler directly on the incoming operands, but
|
|
// via a temporary datastream. This adds overhead, but eliminates the
|
|
// need for the individual handlers to read *exactly* the right amount
|
|
// of data (thus speeding development, and possibly adding some
|
|
// future-proofing).
|
|
|
|
if (words)
|
|
{
|
|
TQByteArray *record = new TQByteArray(words * 2);
|
|
TQDataStream *body;
|
|
|
|
operands.readRawBytes(record->data(), words * 2);
|
|
body = new TQDataStream(*record, IO_ReadOnly);
|
|
body->setByteOrder(TQDataStream::LittleEndian);
|
|
(this->*result)(words, *body);
|
|
delete body;
|
|
delete record;
|
|
}
|
|
else
|
|
{
|
|
TQDataStream *body = new TQDataStream();
|
|
|
|
(this->*result)(words, *body);
|
|
delete body;
|
|
}
|
|
}
|
|
}
|
|
|
|
TQPoint KWmf::normalisePoint(
|
|
TQDataStream &operands)
|
|
{
|
|
S16 x;
|
|
S16 y;
|
|
|
|
operands >> x >> y;
|
|
return TQPoint((x - m_windowOrgX) * m_windowFlipX / m_dpi, (y - m_windowOrgY) * m_windowFlipY / m_dpi);
|
|
}
|
|
|
|
TQSize KWmf::normaliseSize(
|
|
TQDataStream &operands)
|
|
{
|
|
S16 width;
|
|
S16 height;
|
|
|
|
operands >> width >> height;
|
|
return TQSize(width / m_dpi, height / m_dpi);
|
|
}
|
|
|
|
bool KWmf::parse(
|
|
const TQString &file)
|
|
{
|
|
TQFile in(file);
|
|
if (!in.open(IO_ReadOnly))
|
|
{
|
|
kdError(s_area) << "Unable to open input file!" << endl;
|
|
in.close();
|
|
return false;
|
|
}
|
|
TQDataStream stream(&in);
|
|
bool result = parse(stream, in.size());
|
|
in.close();
|
|
return result;
|
|
}
|
|
|
|
bool KWmf::parse(
|
|
TQDataStream &stream,
|
|
unsigned size)
|
|
{
|
|
int startedAt;
|
|
bool isPlaceable;
|
|
bool isEnhanced;
|
|
|
|
startedAt = stream.device()->at();
|
|
stream.setByteOrder(TQDataStream::LittleEndian); // Great, I love TQt !
|
|
|
|
for (int i = 0; i < s_maxHandles; i++)
|
|
m_objectHandles[i] = NULL;
|
|
|
|
struct RECT
|
|
{
|
|
S16 left;
|
|
S16 top;
|
|
S16 right;
|
|
S16 bottom;
|
|
};
|
|
|
|
struct RECTL
|
|
{
|
|
S32 left;
|
|
S32 top;
|
|
S32 right;
|
|
S32 bottom;
|
|
};
|
|
|
|
struct SIZE
|
|
{
|
|
S16 width;
|
|
S16 height;
|
|
};
|
|
|
|
struct SIZEL
|
|
{
|
|
S32 width;
|
|
S32 height;
|
|
};
|
|
|
|
struct WmfEnhMetaHeader
|
|
{
|
|
S32 iType; // Record type EMR_HEADER
|
|
S32 nSize; // Record size in bytes. This may be greater
|
|
// than the sizeof(ENHMETAHEADER).
|
|
RECTL rclBounds; // Inclusive-inclusive bounds in device units
|
|
RECTL rclFrame; // Inclusive-inclusive Picture Frame of metafile
|
|
// in .01 mm units
|
|
S32 dSignature; // Signature. Must be ENHMETA_SIGNATURE.
|
|
S32 nVersion; // Version number
|
|
S32 nBytes; // Size of the metafile in bytes
|
|
S32 nRecords; // Number of records in the metafile
|
|
S16 nHandles; // Number of handles in the handle table
|
|
// Handle index zero is reserved.
|
|
S16 sReserved; // Reserved. Must be zero.
|
|
S32 nDescription; // Number of chars in the unicode description string
|
|
// This is 0 if there is no description string
|
|
S32 offDescription; // Offset to the metafile description record.
|
|
// This is 0 if there is no description string
|
|
S32 nPalEntries; // Number of entries in the metafile palette.
|
|
SIZEL szlDevice; // Size of the reference device in pels
|
|
SIZEL szlMillimeters; // Size of the reference device in millimeters
|
|
};
|
|
#define ENHMETA_SIGNATURE 0x464D4520
|
|
|
|
struct WmfMetaHeader
|
|
{
|
|
S16 mtType;
|
|
S16 mtHeaderSize;
|
|
S16 mtVersion;
|
|
S32 mtSize;
|
|
S16 mtNoObjects;
|
|
S32 mtMaxRecord;
|
|
S16 mtNoParameters;
|
|
};
|
|
|
|
struct WmfPlaceableHeader
|
|
{
|
|
S32 key;
|
|
S16 hmf;
|
|
RECT bbox;
|
|
S16 inch;
|
|
S32 reserved;
|
|
S16 checksum;
|
|
};
|
|
#define APMHEADER_KEY 0x9AC6CDD7L
|
|
|
|
WmfPlaceableHeader pheader;
|
|
WmfEnhMetaHeader eheader;
|
|
WmfMetaHeader header;
|
|
S16 checksum;
|
|
int fileAt;
|
|
|
|
//----- Read placeable metafile header
|
|
|
|
stream >> pheader.key;
|
|
isPlaceable = (pheader.key == (S32)APMHEADER_KEY);
|
|
if (isPlaceable)
|
|
{
|
|
stream >> pheader.hmf;
|
|
stream >> pheader.bbox.left;
|
|
stream >> pheader.bbox.top;
|
|
stream >> pheader.bbox.right;
|
|
stream >> pheader.bbox.bottom;
|
|
stream >> pheader.inch;
|
|
stream >> pheader.reserved;
|
|
stream >> pheader.checksum;
|
|
checksum = 0;
|
|
S16 *ptr = (S16 *)&pheader;
|
|
|
|
// XOR in each of the S16s.
|
|
|
|
for (unsigned i = 0; i < sizeof(WmfPlaceableHeader)/sizeof(S16); i++)
|
|
{
|
|
checksum ^= ptr[i];
|
|
}
|
|
if (pheader.checksum != checksum)
|
|
isPlaceable = false;
|
|
m_dpi = (unsigned)((double)pheader.inch / m_dpi);
|
|
m_windowOrgX = pheader.bbox.left;
|
|
m_windowOrgY = pheader.bbox.top;
|
|
if (pheader.bbox.right > pheader.bbox.left)
|
|
m_windowFlipX = 1;
|
|
else
|
|
m_windowFlipX = -1;
|
|
if (pheader.bbox.bottom > pheader.bbox.top)
|
|
m_windowFlipY = 1;
|
|
else
|
|
m_windowFlipY = -1;
|
|
}
|
|
else
|
|
{
|
|
stream.device()->at(startedAt);
|
|
m_dpi = (unsigned)((double)576 / m_dpi);
|
|
m_windowOrgX = 0;
|
|
m_windowOrgY = 0;
|
|
m_windowFlipX = 1;
|
|
m_windowFlipY = 1;
|
|
}
|
|
|
|
//----- Read as enhanced metafile header
|
|
|
|
fileAt = stream.device()->at();
|
|
stream >> eheader.iType;
|
|
stream >> eheader.nSize;
|
|
stream >> eheader.rclBounds.left;
|
|
stream >> eheader.rclBounds.top;
|
|
stream >> eheader.rclBounds.right;
|
|
stream >> eheader.rclBounds.bottom;
|
|
stream >> eheader.rclFrame.left;
|
|
stream >> eheader.rclFrame.top;
|
|
stream >> eheader.rclFrame.right;
|
|
stream >> eheader.rclFrame.bottom;
|
|
stream >> eheader.dSignature;
|
|
isEnhanced = (eheader.dSignature == ENHMETA_SIGNATURE);
|
|
if (isEnhanced) // is it really enhanced ?
|
|
{
|
|
stream >> eheader.nVersion;
|
|
stream >> eheader.nBytes;
|
|
stream >> eheader.nRecords;
|
|
stream >> eheader.nHandles;
|
|
stream >> eheader.sReserved;
|
|
stream >> eheader.nDescription;
|
|
stream >> eheader.offDescription;
|
|
stream >> eheader.nPalEntries;
|
|
stream >> eheader.szlDevice.width;
|
|
stream >> eheader.szlDevice.height;
|
|
stream >> eheader.szlMillimeters.width;
|
|
stream >> eheader.szlMillimeters.height;
|
|
|
|
kdError(s_area) << "WMF Extended Header NOT YET IMPLEMENTED, SORRY." << endl;
|
|
/*
|
|
if (mSingleStep)
|
|
{
|
|
debug(" iType=%d", eheader.iType);
|
|
debug(" nSize=%d", eheader.nSize);
|
|
debug(" rclBounds=(%ld;%ld;%ld;%ld)",
|
|
eheader.rclBounds.left, eheader.rclBounds.top,
|
|
eheader.rclBounds.right, eheader.rclBounds.bottom);
|
|
debug(" rclFrame=(%ld;%ld;%ld;%ld)",
|
|
eheader.rclFrame.left, eheader.rclFrame.top,
|
|
eheader.rclFrame.right, eheader.rclFrame.bottom);
|
|
debug(" dSignature=%d", eheader.dSignature);
|
|
debug(" nVersion=%d", eheader.nVersion);
|
|
debug(" nBytes=%d", eheader.nBytes);
|
|
}
|
|
debug("NOT YET IMPLEMENTED, SORRY.");
|
|
*/
|
|
return false;
|
|
}
|
|
else // no, not enhanced
|
|
{
|
|
// debug("WMF Header");
|
|
//----- Read as standard metafile header
|
|
stream.device()->at(fileAt);
|
|
stream >> header.mtType;
|
|
stream >> header.mtHeaderSize;
|
|
stream >> header.mtVersion;
|
|
stream >> header.mtSize;
|
|
stream >> header.mtNoObjects;
|
|
stream >> header.mtMaxRecord;
|
|
stream >> header.mtNoParameters;
|
|
/*
|
|
if (mSingleStep)
|
|
{
|
|
debug(" mtType=%u", header.mtType);
|
|
debug(" mtHeaderSize=%u", header.mtHeaderSize);
|
|
debug(" mtVersion=%u", header.mtVersion);
|
|
debug(" mtSize=%ld", header.mtSize);
|
|
}
|
|
*/
|
|
}
|
|
|
|
walk((size - (stream.device()->at() - startedAt)) / 2, stream);
|
|
return true;
|
|
}
|
|
|
|
void KWmf::opArc(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
genericArc("arc", operands);
|
|
}
|
|
|
|
void KWmf::opBrushCreateIndirect(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
static TQt::BrushStyle hatchedStyleTab[] =
|
|
{
|
|
TQt::HorPattern,
|
|
TQt::FDiagPattern,
|
|
TQt::BDiagPattern,
|
|
TQt::CrossPattern,
|
|
TQt::DiagCrossPattern
|
|
};
|
|
static TQt::BrushStyle styleTab[] =
|
|
{
|
|
TQt::SolidPattern,
|
|
TQt::NoBrush,
|
|
TQt::FDiagPattern, // hatched
|
|
TQt::Dense4Pattern, // should be custom bitmap pattern
|
|
TQt::HorPattern, // should be BS_INDEXED (?)
|
|
TQt::VerPattern, // should be device-independent bitmap
|
|
TQt::Dense6Pattern, // should be device-independent packed-bitmap
|
|
TQt::Dense2Pattern, // should be BS_PATTERN8x8
|
|
TQt::Dense3Pattern // should be device-independent BS_DIBPATTERN8x8
|
|
};
|
|
TQt::BrushStyle style;
|
|
WinObjBrushHandle *handle = handleCreateBrush();
|
|
S16 arg;
|
|
S32 colour;
|
|
S16 discard;
|
|
|
|
operands >> arg >> colour;
|
|
handle->m_colour = getColour(colour);
|
|
if (arg == 2)
|
|
{
|
|
operands >> arg;
|
|
if (arg >= 0 && arg < 6)
|
|
{
|
|
style = hatchedStyleTab[arg];
|
|
}
|
|
else
|
|
{
|
|
kdError(s_area) << "createBrushIndirect: invalid hatched brush " << arg << endl;
|
|
style = TQt::SolidPattern;
|
|
}
|
|
}
|
|
else
|
|
if (arg >= 0 && arg < 9)
|
|
{
|
|
style = styleTab[arg];
|
|
operands >> discard;
|
|
}
|
|
else
|
|
{
|
|
kdError(s_area) << "createBrushIndirect: invalid brush " << arg << endl;
|
|
style = TQt::SolidPattern;
|
|
operands >> discard;
|
|
}
|
|
handle->m_style = style;
|
|
}
|
|
|
|
void KWmf::opEllipse(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
TQPoint topLeft;
|
|
TQPoint bottomRight;
|
|
|
|
topLeft = normalisePoint(operands);
|
|
bottomRight = normalisePoint(operands);
|
|
|
|
TQRect ellipse(topLeft, bottomRight);
|
|
|
|
gotEllipse(m_dc, "full", ellipse.center(), ellipse.size() / 2, 0, 0);
|
|
}
|
|
|
|
void KWmf::opLineTo(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
TQPoint lineTo;
|
|
|
|
lineTo = normalisePoint(operands);
|
|
TQPointArray points(2);
|
|
points.setPoint(0, m_lineFrom);
|
|
points.setPoint(1, lineTo);
|
|
gotPolyline(m_dc, points);
|
|
|
|
// Remember this point for next time.
|
|
|
|
m_lineFrom = lineTo;
|
|
}
|
|
|
|
void KWmf::opMoveTo(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
m_lineFrom = normalisePoint(operands);
|
|
}
|
|
|
|
void KWmf::opNoop(
|
|
U32 words,
|
|
TQDataStream &operands)
|
|
{
|
|
skip(words, operands);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void KWmf::opObjectDelete(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 idx;
|
|
|
|
operands >> idx;
|
|
handleDelete(idx);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void KWmf::opObjectSelect(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 idx;
|
|
|
|
operands >> idx;
|
|
if (idx >= 0 && idx < s_maxHandles && m_objectHandles[idx])
|
|
m_objectHandles[idx]->apply(*this);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
void KWmf::opPenCreateIndirect(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
static Qt::PenStyle styleTab[] =
|
|
{
|
|
Qt::SolidLine,
|
|
Qt::DashLine,
|
|
Qt::DotLine,
|
|
Qt::DashDotLine,
|
|
Qt::DashDotDotLine,
|
|
Qt::NoPen,
|
|
Qt::SolidLine, // PS_INSIDEFRAME
|
|
Qt::SolidLine, // PS_USERSTYLE
|
|
Qt::SolidLine // PS_ALTERNATE
|
|
};
|
|
WinObjPenHandle *handle = handleCreatePen();
|
|
S16 arg;
|
|
S32 colour;
|
|
|
|
operands >> arg;
|
|
if (arg >= 0 && arg < 8)
|
|
{
|
|
handle->m_style = styleTab[arg];
|
|
}
|
|
else
|
|
{
|
|
kdError(s_area) << "createPenIndirect: invalid pen " << arg << endl;
|
|
handle->m_style = TQt::SolidLine;
|
|
}
|
|
operands >> arg;
|
|
handle->m_width = arg;
|
|
operands >> arg >> colour;
|
|
handle->m_colour = getColour(colour);
|
|
}
|
|
|
|
void KWmf::opPie(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
genericArc("pie", operands);
|
|
}
|
|
|
|
void KWmf::opPolygonSetFillMode(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 tmp;
|
|
|
|
operands >> tmp;
|
|
m_dc.m_winding = tmp != 0;
|
|
}
|
|
|
|
void KWmf::opPolygon(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 tmp;
|
|
|
|
operands >> tmp;
|
|
TQPointArray points(tmp);
|
|
|
|
for (int i = 0; i < tmp; i++)
|
|
{
|
|
points.setPoint(i, normalisePoint(operands));
|
|
}
|
|
gotPolygon(m_dc, points);
|
|
}
|
|
|
|
void KWmf::opPolyline(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 tmp;
|
|
|
|
operands >> tmp;
|
|
TQPointArray points(tmp);
|
|
|
|
for (int i = 0; i < tmp; i++)
|
|
{
|
|
points.setPoint(i, normalisePoint(operands));
|
|
}
|
|
gotPolyline(m_dc, points);
|
|
}
|
|
|
|
void KWmf::opRectangle(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
TQPoint topLeft;
|
|
TQSize size;
|
|
|
|
topLeft = normalisePoint(operands);
|
|
size = normaliseSize(operands);
|
|
TQRect rect(topLeft, size);
|
|
TQPointArray points(4);
|
|
|
|
points.setPoint(0, topLeft);
|
|
points.setPoint(1, rect.topRight());
|
|
points.setPoint(2, rect.bottomRight());
|
|
points.setPoint(3, rect.bottomLeft());
|
|
gotRectangle(m_dc, points);
|
|
}
|
|
|
|
void KWmf::opRestoreDc(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 pop;
|
|
S16 i;
|
|
|
|
operands >> pop;
|
|
for (i = 0; i < pop; i++)
|
|
{
|
|
m_dc = m_savedDcs.pop();
|
|
}
|
|
}
|
|
|
|
void KWmf::opSaveDc(
|
|
U32 /*words*/,
|
|
TQDataStream &/*operands*/)
|
|
{
|
|
m_savedDcs.push(m_dc);
|
|
|
|
// TBD: reinitialise m_dc.
|
|
}
|
|
|
|
void KWmf::opWindowSetOrg(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 top;
|
|
S16 left;
|
|
|
|
operands >> top >> left;
|
|
m_windowOrgX = left;
|
|
m_windowOrgY = top;
|
|
}
|
|
|
|
void KWmf::opWindowSetExt(
|
|
U32 /*words*/,
|
|
TQDataStream &operands)
|
|
{
|
|
S16 height;
|
|
S16 width;
|
|
|
|
operands >> height >> width;
|
|
if (width > 0)
|
|
m_windowFlipX = 1;
|
|
else
|
|
m_windowFlipX = -1;
|
|
if (height > 0)
|
|
m_windowFlipY = 1;
|
|
else
|
|
m_windowFlipY = -1;
|
|
}
|
|
|
|
void KWmf::penSet(
|
|
unsigned colour,
|
|
unsigned style,
|
|
unsigned width)
|
|
{
|
|
m_dc.m_penColour = colour;
|
|
m_dc.m_penStyle = style;
|
|
m_dc.m_penWidth = width;
|
|
}
|
|
|
|
void KWmf::skip(
|
|
U32 words,
|
|
TQDataStream &operands)
|
|
{
|
|
if ((int)words < 0)
|
|
{
|
|
kdError(s_area) << "skip: " << (int)words << endl;
|
|
return;
|
|
}
|
|
if (words)
|
|
{
|
|
U32 i;
|
|
S16 discard;
|
|
|
|
kdDebug(s_area) << "skip: " << words << endl;
|
|
for (i = 0; i < words; i++)
|
|
{
|
|
operands >> discard;
|
|
}
|
|
}
|
|
}
|
|
|
|
void KWmf::walk(
|
|
U32 words,
|
|
TQDataStream &operands)
|
|
{
|
|
// Read bits:
|
|
//
|
|
// struct WmfMetaRecord
|
|
// {
|
|
// S32 rdSize; // Record size (in words) of the function
|
|
// S16 rdFunction; // Record function number
|
|
// S16 rdParm[1]; // WORD array of parameters
|
|
// };
|
|
//
|
|
// struct WmfEnhMetaRecord
|
|
// {
|
|
// S32 iType; // Record type EMR_xxx
|
|
// S32 nSize; // Record size in bytes
|
|
// S32 dParm[1]; // DWORD array of parameters
|
|
// };
|
|
|
|
S32 wordCount;
|
|
S16 opcode;
|
|
U32 length = 0;
|
|
|
|
while (length < words)
|
|
{
|
|
operands >> wordCount;
|
|
operands >> opcode;
|
|
|
|
// If we get some duff data, protect ourselves.
|
|
if (length + wordCount > words)
|
|
{
|
|
wordCount = words - length;
|
|
}
|
|
length += wordCount;
|
|
if (opcode == 0)
|
|
{
|
|
// This appears to be an EOF marker.
|
|
break;
|
|
}
|
|
|
|
// Package the arguments...
|
|
|
|
invokeHandler(opcode, wordCount - 3, operands);
|
|
}
|
|
|
|
// Eat unexpected data that the caller may expect us to consume.
|
|
skip(words - length, operands);
|
|
}
|
|
|
|
KWmf::DrawContext::DrawContext()
|
|
{
|
|
// TBD: initalise with proper values.
|
|
m_brushColour = 0x808080;
|
|
m_brushStyle = 1;
|
|
m_penColour = 0x808080;
|
|
m_penStyle = 1;
|
|
m_penWidth = 1;
|
|
}
|
|
|
|
void KWmf::WinObjBrushHandle::apply(
|
|
KWmf &p)
|
|
{
|
|
p.brushSet(m_colour, m_style);
|
|
}
|
|
|
|
void KWmf::WinObjPenHandle::apply(
|
|
KWmf &p)
|
|
{
|
|
p.penSet(m_colour, m_style, m_width);
|
|
}
|