Aren
/
haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sync 

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16003 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stefano Ceccherini 2006-01-17 21:39:41 +00:00
parent 9e8d2dd28b
commit 9cc00d82fb
2 changed files with 0 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

528
src/servers/app/PicturePlayer.cpp
View File

@ -1,528 +0,0 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, Haiku, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: PicturePlayer.cpp
// Author: Marc Flerackers (mflerackers@androme.be)
// DarkWyrm <bpmagic@columbus.rr.com>
// Description: Server class to interpret and play BPicture data. Based on
// Marc Flerackers' TPicture class
//------------------------------------------------------------------------------
#include <stdio.h>
#include <Region.h>
#include "ServerBitmap.h"
#include "DrawingEngine.h"
#include "PictureProtocol.h"
#include "PicturePlayer.h"
BRect
CalculatePolygonBounds(BPoint *pts, int32 pointcount)
{
if (!pts)
return BRect(0,0,0,0);
BRect r(0,0,0,0);
// shamelessly stolen from Marc's BPolygon code and tweaked to fit. :P
r = BRect(pts[0], pts[0]);
for (int32 i = 1; i < 4; i++) {
if (pts[i].x < r.left)
r.left = pts[i].x;
if (pts[i].y < r.top)
r.top = pts[i].y;
if (pts[i].x > r.right)
r.right = pts[i].x;
if (pts[i].y > r.bottom)
r.bottom = pts[i].y;
}
return r;
}
// #pragma mark -
PicturePlayer::PicturePlayer(DrawingEngine *d,void *data, int32 size)
: fData(data, size)
{
fdriver=d;
stipplepat=0xFFFFFFFFFFFFFFFFLL;
clipreg=NULL;
}
PicturePlayer::~PicturePlayer()
{
delete clipreg;
}
int16 PicturePlayer::GetOp()
{
int16 data;
fData.Read(&data, sizeof(int16));
return data;
}
bool PicturePlayer::GetBool()
{
bool data;
fData.Read(&data, sizeof(bool));
return data;
}
int16 PicturePlayer::GetInt16()
{
int16 data;
fData.Read(&data, sizeof(int16));
return data;
}
int32 PicturePlayer::GetInt32()
{
int32 data;
fData.Read(&data, sizeof(int32));
return data;
}
float PicturePlayer::GetFloat()
{
float data;
fData.Read(&data, sizeof(float));
return data;
}
BPoint PicturePlayer::GetCoord()
{
BPoint data;
fData.Read(&data, sizeof(BPoint));
return data;
}
BRect PicturePlayer::GetRect()
{
BRect data;
fData.Read(&data, sizeof(BRect));
return data;
}
rgb_color PicturePlayer::GetColor()
{
rgb_color data;
fData.Read(&data, sizeof(rgb_color));
return data;
}
void PicturePlayer::GetData(void *data, int32 size)
{
fData.Read(data, size);
}
status_t PicturePlayer::Play(int32 tableEntries,void *userData, DrawState *d)
{
if(!userData || !d)
return B_ERROR;
int16 op;
int32 size=fData.Seek(0,SEEK_END);
fData.Seek(0,SEEK_SET);
off_t pos;
fldata=*d;
ServerFont dummyFont;
while (fData.Position() < size)
{
op = GetOp();
size = GetInt32();
pos = fData.Position();
switch (op)
{
case B_PIC_MOVE_PEN_BY:
{
BPoint where = GetCoord();
fldata.SetPenLocation(fldata.PenLocation() + where);
break;
}
case B_PIC_STROKE_LINE:
{
BPoint start = GetCoord();
BPoint end = GetCoord();
fdriver->StrokeLine(start,end,&fldata);
break;
}
case B_PIC_STROKE_RECT:
{
BRect rect = GetRect();
fdriver->StrokeRect(rect,&fldata);
break;
}
case B_PIC_FILL_RECT:
{
BRect rect = GetRect();
fdriver->FillRect(rect,&fldata);
break;
}
case B_PIC_STROKE_ROUND_RECT:
case B_PIC_FILL_ROUND_RECT:
{
BRect rect = GetRect();
BPoint radii = GetCoord();
fdriver->DrawRoundRect(rect, radii.x, radii.y,
&fldata, op == B_PIC_FILL_ROUND_RECT);
break;
}
case B_PIC_STROKE_BEZIER:
case B_PIC_FILL_BEZIER:
{
BPoint control[4];
GetData(control, sizeof(control));
fdriver->DrawBezier(control, &fldata,
op == B_PIC_FILL_BEZIER);
break;
}
case B_PIC_STROKE_POLYGON:
case B_PIC_FILL_POLYGON:
{
int32 numPoints = GetInt32();
BPoint *points = new BPoint[numPoints];
GetData(points, numPoints * sizeof(BPoint));
bool closed = true;
if (op == B_PIC_STROKE_POLYGON)
closed = GetBool();
fdriver->DrawPolygon(points, numPoints,
CalculatePolygonBounds(points, numPoints),
&fldata, op == B_PIC_FILL_POLYGON,
closed);
delete points;
break;
}
case B_PIC_STROKE_SHAPE:
case B_PIC_FILL_SHAPE:
break;
case B_PIC_DRAW_STRING:
{
int32 len = GetInt32();
char *string = new char[len + 1];
GetData(string, len);
string[len] = '\0';
float deltax = GetFloat();
float deltay = GetFloat();
// TODO: The deltas given are escapements. They seem to be called deltax and deltay
// despite the fact that they are space and non-space escapements. Find out which is which when possible.
// My best guess is that deltax corresponds to escapement_delta.nonspace.
escapement_delta delta;
delta.nonspace = deltax;
delta.space = deltay;
fdriver->DrawString(string, len, fldata.PenLocation(), &fldata, &delta);
delete string;
break;
}
case B_PIC_DRAW_PIXELS:
{
// Equivalent of DrawBitmap().
// Normally, we wouldn't explicitly play around with ServerBitmap's buffer memory, but
// we don't want the overhead of going through the pool allocator for a quick bitmap.
BRect src = GetRect();
BRect dest = GetRect();
int32 width = GetInt32();
int32 height = GetInt32();
int32 bytesPerRow = GetInt32();
int32 pixelFormat = GetInt32();
int32 flags = GetInt32();
ServerBitmap sbmp(BRect(0,0,width-1,height-1), (color_space)pixelFormat, flags, bytesPerRow);
sbmp._AllocateBuffer();
GetData(sbmp.Bits(), size - (fData.Position() - pos));
fdriver->DrawBitmap(&sbmp, src, dest, &fldata);
sbmp._FreeBuffer();
break;
}
case B_PIC_DRAW_PICTURE:
{
// TODO: Implement
printf("DEBUG: PicturePlayer::Play(): B_PIC_DRAW_PICTURE unimplemented!\n");
break;
}
case B_PIC_STROKE_ARC:
case B_PIC_FILL_ARC:
{
BPoint center = GetCoord();
BPoint radii = GetCoord();
float startTheta = GetFloat();
float arcTheta = GetFloat();
fdriver->DrawArc(BRect(center.x - radii.x,
center.y - radii.y,
center.x + radii.x,
center.y+radii.y),
startTheta, arcTheta, &fldata,
op == B_PIC_FILL_ARC);
break;
}
case B_PIC_STROKE_ELLIPSE:
case B_PIC_FILL_ELLIPSE:
{
BRect rect = GetRect();
BPoint center;
BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f);
center = rect.LeftTop() + radii;
fdriver->DrawEllipse(rect, &fldata, op == B_PIC_FILL_ELLIPSE);
break;
}
case B_PIC_ENTER_STATE_CHANGE:
{
// This simply signals that only state stuff will follow until
// B_PIC_EXIT_STATE_CHANGE is encountered. This doesn't affect us AFAIK,
// so we'll do absolutely nothing.
break;
}
case B_PIC_CLIP_TO_PICTURE:
{
//TODO: Implement
break;
}
case B_PIC_PUSH_STATE:
{
//TODO: Implement
break;
}
case B_PIC_POP_STATE:
{
//TODO: Implement
break;
}
case B_PIC_SET_CLIPPING_RECTS:
{
// TODO: Find out how the data will be stored and implement
break;
}
case B_PIC_CLEAR_CLIPPING_RECTS:
{
SetClippingRegion(NULL, 0);
break;
}
case B_PIC_SET_ORIGIN:
{
BPoint pt = GetCoord();
forigin=pt;
break;
}
case B_PIC_SET_PEN_LOCATION:
{
BPoint pt = GetCoord();
fldata.SetPenLocation(pt);
break;
}
case B_PIC_SET_DRAWING_MODE:
{
int16 mode = GetInt16();
fldata.SetDrawingMode((drawing_mode)mode);
break;
}
case B_PIC_SET_LINE_MODE:
{
cap_mode lineCapMode;
join_mode lineJoinMode;
GetData(&lineCapMode, sizeof(cap_mode));
GetData(&lineJoinMode, sizeof(join_mode));
fldata.SetLineCapMode(lineCapMode);
fldata.SetLineJoinMode(lineJoinMode);
fldata.SetMiterLimit(GetFloat());
break;
}
case B_PIC_SET_PEN_SIZE:
{
float size = GetFloat();
fldata.SetPenSize(size);
break;
}
case B_PIC_SET_SCALE:
{
float scale = GetFloat();
fldata.SetScale(scale);
break;
}
case B_PIC_SET_FORE_COLOR:
{
rgb_color color = GetColor();
fldata.SetHighColor(color);
break;
}
case B_PIC_SET_BACK_COLOR:
{
rgb_color color = GetColor();
fldata.SetLowColor(color);
break;
}
case B_PIC_SET_STIPLE_PATTERN:
{
pattern p;
GetData(&p, sizeof(p));
stipplepat=*((uint64*)p.data);
break;
}
case B_PIC_ENTER_FONT_STATE:
{
// We don't really care about this call, so do nothing
break;
}
case B_PIC_SET_BLENDING_MODE:
{
int16 alphaSrcMode = GetInt16();
int16 alphaFncMode = GetInt16();
fldata.SetBlendingMode((source_alpha)alphaSrcMode,
(alpha_function)alphaFncMode);
break;
}
case B_PIC_SET_FONT_FAMILY:
{
//TODO: Implement
/* int32 len = GetInt32();
char *string = new char[len + 1];
GetData(string, len);
string[len] = '\0';
((fnc_Pc)callBackTable[37])(userData, string);
delete string;
*/ break;
}
case B_PIC_SET_FONT_STYLE:
{
//TODO: Implement
/* int32 len = GetInt32();
char *string = new char[len + 1];
GetData(string, len);
string[len] = '\0';
((fnc_Pc)callBackTable[38])(userData, string);
delete string;
*/ break;
}
case B_PIC_SET_FONT_SPACING:
{
dummyFont.SetSpacing(GetInt32());
fldata.SetFont(dummyFont, B_FONT_SPACING);
break;
}
case B_PIC_SET_FONT_ENCODING:
{
dummyFont.SetEncoding(GetInt32());
fldata.SetFont(dummyFont, B_FONT_ENCODING);
break;
}
case B_PIC_SET_FONT_FLAGS:
{
dummyFont.SetFlags(GetInt32());
fldata.SetFont(dummyFont, B_FONT_FLAGS);
break;
}
case B_PIC_SET_FONT_SIZE:
{
dummyFont.SetSize(GetFloat());
fldata.SetFont(dummyFont, B_FONT_SIZE);
break;
}
case B_PIC_SET_FONT_ROTATE:
{
dummyFont.SetRotation(GetFloat());
fldata.SetFont(dummyFont, B_FONT_ROTATION);
break;
}
case B_PIC_SET_FONT_SHEAR:
{
dummyFont.SetShear(GetFloat());
fldata.SetFont(dummyFont, B_FONT_SHEAR);
break;
}
case B_PIC_SET_FONT_FACE:
{
dummyFont.SetFace(GetInt32());
fldata.SetFont(dummyFont, B_FONT_FACE);
break;
}
default:
break;
}
// If we didn't read enough bytes, skip them. This is not a error
// since the instructions can change over time.
if (fData.Position() - pos < size)
fData.Seek(size - (fData.Position() - pos), SEEK_CUR);
}
return B_OK;
}
void PicturePlayer::SetClippingRegion(BRect *rects, int32 numrects)
{
// Sets the player's clipping region to the union of the rectangles passed to it.
// Passing NULL or 0 rectangles to the function empties the clipping region. The clipping
// region is also emptied if there is no union of all rectangles passed to the function.
if(!rects || numrects == 0)
{
delete clipreg;
clipreg=NULL;
return;
}
if(!clipreg)
clipreg=new BRegion();
else
clipreg->MakeEmpty();
*clipreg=rects[0];
BRegion temp;
for(int32 i=1; i<numrects; i++)
{
temp=rects[i];
clipreg->IntersectWith(&temp);
}
if(clipreg->CountRects()==0)
{
delete clipreg;
clipreg=NULL;
}
}

98
src/servers/app/PicturePlayer.h
View File

@ -1,98 +0,0 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, Haiku, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: PicturePlayer.cpp
// Author: Marc Flerackers (mflerackers@androme.be)
// DarkWyrm <bpmagic@columbus.rr.com>
// Description: Server class to interpret and play BPicture data. Based on
// Marc Flerackers' TPicture class
//------------------------------------------------------------------------------
#ifndef _PICTUREPLAYER_H
#define _PICTUREPLAYER_H
#include <GraphicsDefs.h>
#include <Point.h>
#include <Rect.h>
#include <DataIO.h>
#include "DrawState.h"
#include "PatternHandler.h" // for pattern_union
class DrawingEngine;
class PicturePlayer
{
public:
PicturePlayer(DrawingEngine *driver,void *data, int32 size);
virtual ~PicturePlayer();
int16 GetOp();
bool GetBool();
int16 GetInt8();
int16 GetInt16();
int32 GetInt32();
int64 GetInt64();
float GetFloat();
BPoint GetCoord();
BRect GetRect();
rgb_color GetColor();
//void GetString(char *);
void *GetData(int32);
void GetData(void *data, int32 size);
void AddInt8(int8);
void AddInt16(int16);
void AddInt32(int32);
void AddInt64(int64);
void AddFloat(float);
void AddCoord(BPoint);
void AddRect(BRect);
void AddColor(rgb_color);
void AddString(char *);
void AddData(void *data, int32 size);
void BeginOp(int32);
void EndOp();
void EnterStateChange();
void ExitStateChange();
void EnterFontChange();
void ExitFontChange();
void SetClippingRegion(BRect *rects, int32 numrects);
status_t Play(int32 tableEntries,void *userData, DrawState *d);
status_t Rewind();
private:
BMemoryIO fData;
int32 fSize;
DrawingEngine *fdriver;
DrawState fldata;
BPoint forigin;
Pattern stipplepat;
BRegion *clipreg;
};
#endif