mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-15 14:16:07 -06:00
754 lines
18 KiB
C++
754 lines
18 KiB
C++
#include "Draw.h"
|
|
|
|
NAMESPACE_UPP
|
|
|
|
#define LLOG(x) // LOG(x)
|
|
|
|
#ifdef COMPILER_MSC
|
|
#pragma warning(disable: 4700)
|
|
#endif
|
|
|
|
static void StreamUnpackPoints(Stream& stream, Point *out, int count)
|
|
{
|
|
if(count == 0)
|
|
return;
|
|
#ifdef CPU_LITTLE_ENDIAN
|
|
if(sizeof(Point) == 8) {
|
|
stream.Get(out, 8 * count);
|
|
return;
|
|
}
|
|
#endif
|
|
Point *end = out + count;
|
|
byte *top = reinterpret_cast<byte *>(end) - count * 8;
|
|
stream.Get(top, count * 8);
|
|
for(; out < end; out++, top += 8) {
|
|
out -> x = (short)Peek32le(top + 0);
|
|
out -> y = (short)Peek32le(top + 4);
|
|
}
|
|
}
|
|
|
|
static void StreamPackPoints(Stream& stream, const Point *in, int count)
|
|
{
|
|
#ifdef CPU_LITTLE_ENDIAN
|
|
if(sizeof(Point) == 8) {
|
|
stream.Put(in, 8 * count);
|
|
return;
|
|
}
|
|
#endif
|
|
enum { PART = 1024 };
|
|
byte part[PART * 8];
|
|
while(count > 0)
|
|
{
|
|
int part_count = min<int>(count, PART);
|
|
for(byte *pp = part, *pe = pp + 8 * part_count; pp < pe; pp += 8, in++) {
|
|
Poke32le(pp + 0, in -> x);
|
|
Poke32le(pp + 4, in -> y);
|
|
}
|
|
stream.Put(part, part_count * 4);
|
|
count -= part_count;
|
|
}
|
|
}
|
|
|
|
static void StreamUnpackInts(Stream& stream, int *out, int count)
|
|
{
|
|
#ifdef CPU_LITTLE_ENDIAN
|
|
if(sizeof(int) == 4) {
|
|
stream.Get(out, count * 4);
|
|
return;
|
|
}
|
|
#endif
|
|
while(count--)
|
|
*out++ = stream.Get32le();
|
|
}
|
|
|
|
static void StreamPackInts(Stream& stream, const int *in, int count)
|
|
{
|
|
#ifdef CPU_LITTLE_ENDIAN
|
|
if(sizeof(int) == 4) {
|
|
stream.Put(in, count * 4);
|
|
return;
|
|
}
|
|
#endif
|
|
while(count--)
|
|
stream.Put32le(*in++);
|
|
}
|
|
|
|
// ------------------------------
|
|
|
|
void DrawingDraw::DrawingBegin()
|
|
{
|
|
Cloff& w = cloff.Add();
|
|
w.org = actual_offset;
|
|
w.drawingclip = drawingclip;
|
|
}
|
|
|
|
void DrawingDraw::BeginOp()
|
|
{
|
|
DrawingOp(BEGIN);
|
|
DrawingBegin();
|
|
}
|
|
|
|
void DrawingDraw::OffsetOp(Point p)
|
|
{
|
|
DrawingOp(OFFSET) % p;
|
|
DrawingBegin();
|
|
actual_offset += p;
|
|
}
|
|
|
|
bool DrawingDraw::ClipOp(const Rect& r)
|
|
{
|
|
DrawingOp(CLIP) % const_cast<Rect&>(r);
|
|
DrawingBegin();
|
|
drawingclip &= r + actual_offset;
|
|
return !drawingclip.IsEmpty();
|
|
}
|
|
|
|
bool DrawingDraw::ClipoffOp(const Rect& r)
|
|
{
|
|
DrawingOp(CLIPOFF) % const_cast<Rect&>(r);
|
|
DrawingBegin();
|
|
drawingclip &= r + actual_offset;
|
|
actual_offset += r.TopLeft();
|
|
return !drawingclip.IsEmpty();
|
|
}
|
|
|
|
void DrawingDraw::EndOp()
|
|
{
|
|
DrawingOp(END);
|
|
ASSERT(cloff.GetCount());
|
|
Cloff& w = cloff.Top();
|
|
actual_offset = w.org;
|
|
drawingclip = w.drawingclip;
|
|
cloff.Drop();
|
|
}
|
|
|
|
bool DrawingDraw::ExcludeClipOp(const Rect& r)
|
|
{
|
|
DrawingOp(EXCLUDECLIP) % const_cast<Rect&>(r);
|
|
return !drawingclip.IsEmpty();
|
|
}
|
|
|
|
bool DrawingDraw::IntersectClipOp(const Rect& r)
|
|
{
|
|
DrawingOp(INTERSECTCLIP) % const_cast<Rect&>(r);
|
|
drawingclip &= r;
|
|
return !drawingclip.IsEmpty();
|
|
}
|
|
|
|
Rect DrawingDraw::GetClipOp() const
|
|
{
|
|
return drawingclip - actual_offset;
|
|
}
|
|
|
|
bool DrawingDraw::IsPaintingOp(const Rect& r) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void DrawingDraw::DrawRectOp(int x, int y, int cx, int cy, Color color)
|
|
{
|
|
if(!IsNull(color))
|
|
DrawingOp(DRAWRECT) % x % y % cx % cy % color;
|
|
}
|
|
|
|
void DrawingDraw::DrawImageOp(int x, int y, int cx, int cy, const Image& img, const Rect& src, Color color)
|
|
{
|
|
Rect s = src;
|
|
DrawingOp(DRAWIMAGE) % x % y % cx % cy % const_cast<Image&>(img) % s % color;
|
|
}
|
|
|
|
void DrawingDraw::DrawDataOp(int x, int y, int cx, int cy, const String& data, const char *id)
|
|
{
|
|
String h = id;
|
|
DrawingOp(DRAWDATA) % x % y % cx % cy % const_cast<String&>(data) % h;
|
|
}
|
|
|
|
void DrawingDraw::DrawLineOp(int x1, int y1, int x2, int y2, int width, Color color)
|
|
{
|
|
DrawingOp(DRAWLINE) % x1 % y1 % x2 % y2 % width % color;
|
|
}
|
|
|
|
void DrawingDraw::DrawPolyPolylineOp(const Point *vertices, int vertex_count,
|
|
const int *counts, int count_count,
|
|
int width, Color color, Color doxor)
|
|
{
|
|
ASSERT(count_count > 0 && vertex_count > 0);
|
|
if(vertex_count < 2 || IsNull(color))
|
|
return;
|
|
DrawingOp(DRAWPOLYPOLYLINE);
|
|
int version = 2;
|
|
drawing / version;
|
|
drawing % width % color % doxor;
|
|
drawing % vertex_count % count_count;
|
|
StreamPackPoints(drawing, vertices, vertex_count);
|
|
StreamPackInts(drawing, counts, count_count);
|
|
}
|
|
|
|
void DrawingDraw::DrawPolyPolyPolygonOp(const Point *vertices, int vertex_count,
|
|
const int *subpolygon_counts, int subpolygon_count_count,
|
|
const int *disjunct_polygon_counts, int disjunct_polygon_count_count,
|
|
Color color, int width, Color outline, uint64 pattern, Color doxor)
|
|
{
|
|
if(vertex_count == 0)
|
|
return;
|
|
DrawingOp(DRAWPOLYPOLYPOLYGON);
|
|
int version = 2;
|
|
drawing / version;
|
|
drawing % color % width % outline % pattern % doxor;
|
|
drawing % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
|
|
StreamPackPoints(drawing, vertices, vertex_count);
|
|
StreamPackInts(drawing, subpolygon_counts, subpolygon_count_count);
|
|
StreamPackInts(drawing, disjunct_polygon_counts, disjunct_polygon_count_count);
|
|
}
|
|
|
|
void DrawingDraw::DrawEllipseOp(const Rect& r, Color color, int pen, Color pencolor)
|
|
{
|
|
DrawingOp(DRAWELLIPSE) % const_cast<Rect&>(r) % color / pen % pencolor;
|
|
}
|
|
|
|
void DrawingDraw::DrawArcOp(const Rect& rc, Point start, Point end, int width, Color color)
|
|
{
|
|
DrawingOp(DRAWARC) % const_cast<Rect&>(rc) % start % end % color % width;
|
|
}
|
|
|
|
void DrawingDraw::DrawTextOp(int x, int y, int angle, const wchar *text, Font font, Color ink,
|
|
int n, const int *dx) {
|
|
if(IsNull(ink)) return;
|
|
if(n < 0)
|
|
n = wstrlen((const wchar *)text);
|
|
if(n == 0)
|
|
return;
|
|
Stream& s = DrawingOp(DRAWTEXT);
|
|
byte cs = CHARSET_UNICODE;
|
|
s % x % y % angle % font % ink / n % cs;
|
|
s.PutW((wchar *)text, n);
|
|
bool dxb = dx;
|
|
s % dxb;
|
|
if(dx) {
|
|
int *w = const_cast<int *>(dx);
|
|
while(n--)
|
|
s / *w++;
|
|
}
|
|
}
|
|
|
|
Drawing DrawingDraw::GetResult()
|
|
{
|
|
Drawing out;
|
|
out.size = size;
|
|
LLOG("GetResult size: " << size);
|
|
out.data = drawing.GetResult();
|
|
return out;
|
|
}
|
|
|
|
// ------------------------------
|
|
|
|
int DrawingPos::GetX(int x) const {
|
|
return iscale(x + srcoff.x, target.cx, source.cx) - trgoff.x;
|
|
}
|
|
|
|
int DrawingPos::GetY(int y) const {
|
|
return iscale(y + srcoff.y, target.cy, source.cy) - trgoff.y;
|
|
}
|
|
|
|
int DrawingPos::GetCx(int cx) const {
|
|
return iscale(cx, target.cx, source.cx);
|
|
}
|
|
|
|
int DrawingPos::GetCy(int cy) const {
|
|
return iscale(cy, target.cy, source.cy);
|
|
}
|
|
|
|
int DrawingPos::GetW(int w) const {
|
|
return iscale(w, target.cx + target.cy, source.cx + source.cy);
|
|
}
|
|
|
|
Point DrawingPos::Get(int x, int y) const {
|
|
return Point(GetX(x), GetY(y));
|
|
}
|
|
|
|
Point DrawingPos::Get(Point p) const {
|
|
return Get(p.x, p.y);
|
|
}
|
|
|
|
Size DrawingPos::Get(Size sz) const {
|
|
return Size(GetCx(sz.cx), GetCy(sz.cy));
|
|
}
|
|
|
|
Rect DrawingPos::Get(const Rect& r) const {
|
|
return Rect(GetX(r.left), GetY(r.top), GetX(r.right), GetY(r.bottom));
|
|
}
|
|
|
|
Rect DrawingPos::Get(int x, int y, int cx, int cy) const {
|
|
return Get(RectC(x, y, cx, cy));
|
|
}
|
|
|
|
Rect GetRect16(Stream& s) {
|
|
Rect r;
|
|
Pack16(s, r);
|
|
return r;
|
|
}
|
|
|
|
Point GetPoint16(Stream& s) {
|
|
Point p;
|
|
Pack16(s, p);
|
|
return p;
|
|
}
|
|
|
|
static void wsBegin(Draw& w, Stream&, const DrawingPos& ps) {
|
|
w.Begin();
|
|
DrawingPos& cps = const_cast<DrawingPos&>(ps);
|
|
cps.stack.Add(cps.srcoff);
|
|
}
|
|
|
|
static void wsOffset(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Point off;
|
|
s % off;
|
|
w.Offset(ps(off));
|
|
DrawingPos& cps = const_cast<DrawingPos&>(ps);
|
|
cps.stack.Add(cps.srcoff);
|
|
cps.srcoff += off;
|
|
cps.trgoff = w.GetOffset() - cps.trgini;
|
|
}
|
|
|
|
static void wsClip(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Rect rc;
|
|
s % rc;
|
|
w.Clip(ps(rc));
|
|
DrawingPos& cps = const_cast<DrawingPos&>(ps);
|
|
cps.stack.Add(cps.srcoff);
|
|
}
|
|
|
|
static void wsClipoff(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Rect rc;
|
|
s % rc;
|
|
w.Clipoff(ps(rc));
|
|
DrawingPos& cps = const_cast<DrawingPos&>(ps);
|
|
cps.stack.Add(cps.srcoff);
|
|
cps.srcoff += rc.TopLeft();
|
|
cps.trgoff = w.GetOffset() - cps.trgini;
|
|
}
|
|
|
|
static void wsExcludeClip(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Rect rc;
|
|
s % rc;
|
|
w.ExcludeClip(ps(rc));
|
|
}
|
|
|
|
static void wsIntersectClip(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Rect rc;
|
|
s % rc;
|
|
w.IntersectClip(ps(rc));
|
|
}
|
|
|
|
static void wsEnd(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
w.End();
|
|
DrawingPos& cps = const_cast<DrawingPos&>(ps);
|
|
cps.srcoff = cps.stack.Pop();
|
|
cps.trgoff = w.GetOffset() - cps.trgini;
|
|
}
|
|
|
|
static void wsDrawRect(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
int x, y, cx, cy;
|
|
Color color;
|
|
s % x % y % cx % cy % color;
|
|
LLOG("wsDrawRect " << RectC(x, y, cx, cy) << " ps:" << ps(x, y, cx, cy) << " color:" << color);
|
|
w.DrawRect(ps(x, y, cx, cy), color);
|
|
}
|
|
|
|
static void wsDrawImage(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
int x, y, cx, cy;
|
|
Image img;
|
|
Rect src;
|
|
Color color;
|
|
s % x % y % cx % cy % img % src % color;
|
|
Rect r = ps(x, y, cx, cy);
|
|
w.DrawImageOp(r.left, r.top, r.Width(), r.Height(), img, src, color);
|
|
}
|
|
|
|
static void wsDrawData(Draw& w, Stream& s, const DrawingPos& ps)
|
|
{
|
|
String data, id;
|
|
int x, y, cx, cy;
|
|
s % x % y % cx % cy % const_cast<String&>(data) % id;
|
|
Rect r = ps(x, y, cx, cy);
|
|
w.DrawData(r, data, id);
|
|
}
|
|
|
|
static void wsDrawDrawing(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Drawing dw;
|
|
Rect rc;
|
|
s % dw % rc;
|
|
w.DrawDrawing(ps(rc), dw);
|
|
}
|
|
|
|
static void wsDrawLine(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
int x1, y1, x2, y2, width;
|
|
Color color;
|
|
s % x1 % y1 % x2 % y2 % width % color;
|
|
w.DrawLine(ps(x1, y1), ps(x2, y2), width > 0 ? ps.GetW(width) : width, color);
|
|
}
|
|
|
|
#ifndef PLATFORM_WINCE
|
|
|
|
static void wsDrawPolyPolyline(Draw& w, Stream& stream, const DrawingPos& dp)
|
|
{
|
|
int width, vertex_count, count_count;
|
|
Color color, doxor;
|
|
int version;
|
|
stream / version;
|
|
stream % width % color % doxor;
|
|
stream % vertex_count % count_count;
|
|
Buffer<Point> vertices(vertex_count);
|
|
Buffer<int> counts(count_count);
|
|
StreamUnpackPoints(stream, vertices, vertex_count);
|
|
StreamUnpackInts(stream, counts, count_count);
|
|
if(!dp.Identity()) {
|
|
for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
|
|
dp.Transform(*p);
|
|
if(width > 0)
|
|
dp.TransformW(width);
|
|
}
|
|
w.DrawPolyPolyline(vertices, vertex_count, counts, count_count, width, color, doxor);
|
|
}
|
|
|
|
static void wsDrawPolyPolyPolygon(Draw& w, Stream& stream, const DrawingPos& dp)
|
|
{
|
|
Color color, outline, doxor;
|
|
uint64 pattern;
|
|
int width, vertex_count, subpolygon_count_count, disjunct_polygon_count_count;
|
|
int version = 2;
|
|
stream / version;
|
|
stream % color % width % outline % pattern % doxor;
|
|
stream % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
|
|
Buffer<Point> vertices(vertex_count);
|
|
Buffer<int> subpolygon_counts(subpolygon_count_count);
|
|
Buffer<int> disjunct_polygon_counts(disjunct_polygon_count_count);
|
|
StreamUnpackPoints(stream, vertices, vertex_count);
|
|
StreamUnpackInts(stream, subpolygon_counts, subpolygon_count_count);
|
|
StreamUnpackInts(stream, disjunct_polygon_counts, disjunct_polygon_count_count);
|
|
if(!dp.Identity()) {
|
|
for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
|
|
dp.Transform(*p);
|
|
dp.TransformW(width);
|
|
}
|
|
w.DrawPolyPolyPolygon(vertices, vertex_count,
|
|
subpolygon_counts, subpolygon_count_count,
|
|
disjunct_polygon_counts, disjunct_polygon_count_count,
|
|
color, width, outline, pattern, doxor);
|
|
}
|
|
|
|
static void wsDrawArc(Draw& w, Stream& s, const DrawingPos& ps)
|
|
{
|
|
Rect r;
|
|
Point start, end;
|
|
Color color;
|
|
int width;
|
|
s % r % start % end % color % width;
|
|
w.DrawArc(r, start, end, width, color);
|
|
}
|
|
|
|
#endif
|
|
|
|
static void wsDrawEllipse(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
Rect r;
|
|
s % r;
|
|
Color color, pencolor;
|
|
int pen;
|
|
s % color / pen % pencolor;
|
|
w.DrawEllipse(ps(r), color, pen > 0 ? ps.GetW(pen) : pen, pencolor);
|
|
}
|
|
|
|
static void wsDrawText(Draw& w, Stream& s, const DrawingPos& ps) {
|
|
int x, y, n, angle;
|
|
Font font;
|
|
Color ink;
|
|
byte cs;
|
|
s % x % y % angle % font % ink / n % cs;
|
|
if(font.GetHeight() == 0) {
|
|
FontInfo fi = font.Info();
|
|
font.Height(fi.GetHeight() - fi.GetInternal());
|
|
}
|
|
bool unicode = cs == CHARSET_UNICODE;
|
|
WString text;
|
|
if(unicode) {
|
|
Buffer<wchar> txt(n);
|
|
s.GetW(txt, n);
|
|
text = WString(txt, n);
|
|
}
|
|
else {
|
|
Buffer<char> txt(n);
|
|
s.Get(txt, n);
|
|
text = ToUnicode(txt, n, cs);
|
|
}
|
|
LLOG("wsDrawText \"" << WString(text, n)
|
|
<< "\" at: (" << x << ", " << y << ", " << angle << ")");
|
|
bool dxb;
|
|
s % dxb;
|
|
Buffer<int> dx(n);
|
|
int *wd = dx;
|
|
int nn = n;
|
|
angle %= 3600;
|
|
if(ps.Identity()) {
|
|
if(dxb) {
|
|
while(nn--)
|
|
s / *wd++;
|
|
w.DrawText(x, y, angle, text, font, ink, dx);
|
|
}
|
|
else
|
|
w.DrawText(x, y, angle, text, font, ink);
|
|
}
|
|
else {
|
|
FontInfo fi = font.Info();
|
|
const wchar *wp = ~text;
|
|
int odd = (angle / 900) & 1;
|
|
if(angle % 900 == 0) {
|
|
int error = 0;
|
|
int a, b;
|
|
if(odd) {
|
|
a = ps.target.cy;
|
|
b = ps.source.cy;
|
|
int ht = ps.GetCx(fi.GetFontHeight());
|
|
font.Width(ps.GetCy(fi.GetAveWidth())).Height(ht ? ht : 1);
|
|
FontInfo nf = font.Info();
|
|
x = angle == 2700 ? ps.GetX(x - fi.GetAscent()) + nf.GetAscent()
|
|
: ps.GetX(x + fi.GetAscent()) - nf.GetAscent();
|
|
y = ps.GetY(y);
|
|
}
|
|
else {
|
|
a = ps.target.cx;
|
|
b = ps.source.cx;
|
|
int ht = ps.GetCy(fi.GetFontHeight());
|
|
font.Width(ps.GetCx(fi.GetAveWidth())).Height(ht ? ht : 1);
|
|
FontInfo nf = font.Info();
|
|
x = ps.GetX(x);
|
|
y = angle == 1800 ? ps.GetY(y - fi.GetAscent()) + nf.GetAscent()
|
|
: ps.GetY(y + fi.GetAscent()) - nf.GetAscent();
|
|
}
|
|
while(nn--) {
|
|
int c;
|
|
if(dxb)
|
|
s / c;
|
|
else
|
|
c = fi[*wp++];
|
|
*wd++ = (c * a + error) / b;
|
|
error = (c * a + error) % b;
|
|
}
|
|
w.DrawText(x, y, angle, text, font, ink, dx);
|
|
}
|
|
else {
|
|
double ang = (double) (angle % 900) * M_2PI / 3600;
|
|
double sx = (double) ps.target.cx / ps.source.cx;
|
|
double sy = (double) ps.target.cy / ps.source.cy;
|
|
double ang2 = atan((odd ? sx / sy : sy / sx) * tan(ang));
|
|
double q = (odd ? sx : sy) * sin(ang) / sin(ang2);
|
|
double error = 0;
|
|
while(nn--) {
|
|
int cx;
|
|
if(dxb)
|
|
s / cx;
|
|
else
|
|
cx = fi[*wp++];
|
|
double ncx = q * cx + error;
|
|
*wd++ = cx = (int) ncx;
|
|
error = ncx - cx;
|
|
}
|
|
int ht = (int)(fi.GetFontHeight() * (sx * sin(ang) * sin(ang2) + sy * cos(ang) * cos(ang2)));
|
|
font.Width(int(q * fi.GetAveWidth())).Height(ht ? ht : 1);
|
|
w.DrawText(ps.GetX(x), ps.GetY(y), int(ang2 * 3600 / M_2PI) + (angle / 900) * 900,
|
|
text, font, ink, dx);
|
|
}
|
|
}
|
|
}
|
|
|
|
static VectorMap<int, Draw::Drawer>& sDrawerMap()
|
|
{
|
|
return Single< VectorMap<int, Draw::Drawer> > ();
|
|
}
|
|
|
|
void Draw::Register(int code, Drawer drawer)
|
|
{
|
|
static StaticCriticalSection lock;
|
|
CriticalSection::Lock __(lock);
|
|
VectorMap<int, Draw::Drawer>& map = sDrawerMap();
|
|
int i = map.Find(code);
|
|
if(i >= 0) {
|
|
ASSERT(map[i] == drawer);
|
|
return;
|
|
}
|
|
map.Add(code, drawer);
|
|
}
|
|
|
|
void Draw::DrawDrawingOp(const Rect& target, const Drawing& w) {
|
|
{
|
|
ONCELOCK {
|
|
Register(BEGIN, wsBegin);
|
|
Register(OFFSET, wsOffset);
|
|
Register(CLIP, wsClip);
|
|
Register(CLIPOFF, wsClipoff);
|
|
Register(EXCLUDECLIP, wsExcludeClip);
|
|
Register(INTERSECTCLIP, wsIntersectClip);
|
|
Register(END, wsEnd);
|
|
Register(DRAWRECT, wsDrawRect);
|
|
Register(DRAWIMAGE, wsDrawImage);
|
|
Register(DRAWDRAWING, wsDrawDrawing);
|
|
Register(DRAWLINE, wsDrawLine);
|
|
Register(DRAWELLIPSE, wsDrawEllipse);
|
|
Register(DRAWTEXT, wsDrawText);
|
|
#ifndef PLATFORM_WINCE
|
|
Register(DRAWARC, wsDrawArc);
|
|
Register(DRAWPOLYPOLYLINE, wsDrawPolyPolyline);
|
|
Register(DRAWPOLYPOLYPOLYGON, wsDrawPolyPolyPolygon);
|
|
#endif
|
|
Register(DRAWDATA, wsDrawData);
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
int cl = GetCloffLevel();
|
|
#endif
|
|
DrawingPos pos;
|
|
pos.srcoff = pos.trgoff = Point(0, 0);
|
|
pos.target = target.Size();
|
|
pos.source = w.size;
|
|
LLOG("DrawDrawingOp size: " << w.size);
|
|
if(pos.target.cx == 0 || pos.target.cy == 0 || pos.source.cx == 0 || pos.source.cy == 0)
|
|
return;
|
|
Clipoff(target);
|
|
pos.trgini = GetOffset();
|
|
VectorMap<int, Draw::Drawer>& map = sDrawerMap();
|
|
StringStream s(w.data);
|
|
// LOGBEGIN();
|
|
while(!s.IsEof()) {
|
|
int code;
|
|
s / code;
|
|
int i = map.Find(code);
|
|
if(i < 0)
|
|
break;
|
|
(*map[i])(*this, s, pos);
|
|
}
|
|
// LOGEND();
|
|
End();
|
|
#ifdef _DEBUG
|
|
ASSERT(GetCloffLevel() == cl);
|
|
#endif
|
|
}
|
|
|
|
void DrawingDraw::DrawDrawingOp(const Rect& target, const Drawing& w)
|
|
{
|
|
DrawingOp(DRAWDRAWING) % const_cast<Drawing&>(w) % const_cast<Rect&>(target);
|
|
return;
|
|
}
|
|
|
|
void Draw::DrawDrawing(int x, int y, int cx, int cy, const Drawing& w) {
|
|
DrawDrawing(RectC(x, y, cx, cy), w);
|
|
}
|
|
|
|
void DrawingDraw::Create(int cx, int cy) {
|
|
Create(Size(cx, cy));
|
|
}
|
|
|
|
void DrawingDraw::Create(Size sz) {
|
|
drawing.Create();
|
|
size = sz;
|
|
#ifdef PLATFORM_WIN32
|
|
cloff.Clear();
|
|
#endif
|
|
#ifdef PLATFORM_X11
|
|
cloff.Clear();
|
|
clip.Clear();
|
|
Vector<Rect> cliplist;
|
|
cliplist.Add(RectC(0, 0, sz.cx, sz.cy));
|
|
Init(cliplist);
|
|
#endif
|
|
drawingclip = Rect(0, 0, sz.cx, sz.cy);
|
|
pixels = false;
|
|
LLOG("DrawingDraw::Create, sz = " << sz << " -> clip = " << GetClip());
|
|
}
|
|
|
|
void DrawingDraw::DInit()
|
|
{
|
|
#ifdef PLATFORM_WIN32
|
|
Attach(ScreenHDC());
|
|
#endif
|
|
#ifdef PLATFORM_X11
|
|
gc = XCreateGC(Xdisplay, RootWindow(Xdisplay, Xscreenno), 0, 0);
|
|
dw = RootWindow(Xdisplay, Xscreenno);
|
|
#endif
|
|
pixels = false;
|
|
backdraw = true;
|
|
LLOG("DrawingDraw::DInit: pixels = " << Pixels());
|
|
}
|
|
|
|
DrawingDraw::DrawingDraw()
|
|
{
|
|
DInit();
|
|
}
|
|
|
|
DrawingDraw::DrawingDraw(Size sz) {
|
|
DInit();
|
|
Create(sz);
|
|
}
|
|
|
|
DrawingDraw::DrawingDraw(int cx, int cy) {
|
|
DInit();
|
|
Create(cx, cy);
|
|
}
|
|
|
|
DrawingDraw::~DrawingDraw() {
|
|
#ifdef PLATFORM_X11
|
|
XFreeGC(Xdisplay, gc);
|
|
#endif
|
|
}
|
|
|
|
Size Drawing::RatioSize(int cx, int cy) const {
|
|
return GetRatioSize(GetSize(), cx, cy);
|
|
}
|
|
|
|
void Drawing::Append(Drawing& dw)
|
|
{
|
|
if(IsNull(size))
|
|
size = dw.size;
|
|
data << dw.data;
|
|
}
|
|
|
|
void Drawing::Serialize(Stream& s)
|
|
{
|
|
s % size;
|
|
s % data;
|
|
}
|
|
|
|
#ifdef PLATFORM_WIN32
|
|
#ifndef PLATFORM_WINCE
|
|
Drawing Drawing::FromWMF(const WinMetaFile& wmf) {
|
|
if(!wmf) return Drawing();
|
|
Size sz = wmf.GetSize();
|
|
DrawingDraw dd(sz);
|
|
wmf.Paint(dd, 0, 0, sz.cx, sz.cy);
|
|
return dd;
|
|
}
|
|
|
|
Drawing Drawing::LoadWMF(const char *file) {
|
|
return FromWMF(WinMetaFile(file));
|
|
}
|
|
|
|
Drawing Drawing::ReadClipboardWMF() {
|
|
WinMetaFile wmf;
|
|
wmf.ReadClipboard();
|
|
return FromWMF(wmf);
|
|
}
|
|
|
|
WinMetaFile Drawing::AsWMF() const {
|
|
Size sz = GetSize();
|
|
WinMetaFileDraw wd(sz.cx, sz.cy);
|
|
wd.DrawDrawing(0, 0, sz.cx, sz.cy, *this);
|
|
return wd.Close();
|
|
}
|
|
|
|
void Drawing::WriteClipboardWMF() const {
|
|
WinMetaFile wmf = AsWMF();
|
|
wmf.WriteClipboard();
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
END_UPP_NAMESPACE
|