Convert to LayerData independent drawing API

Implement clipping routines for Lines and Rectangles
Fix workspace initialization problem
it's saturday night and I am writing code... bummer


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@5599 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/servers/app/server/AccelerantDriver.h

@@ -49,8 +49,42 @@ public:
 	virtual void DrawBitmap(ServerBitmap *bmp, BRect src, BRect dest, LayerData *d);
 	virtual void DrawString(const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta=NULL);
 
-	virtual void FillRect(BRect r, LayerData *d, const Pattern &pat);
+
+	virtual void FillArc(const BRect r, float angle, float span, RGBColor& color);
+	virtual void FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillBezier(BPoint *pts, RGBColor& color);
+	virtual void FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillEllipse(BRect r, RGBColor& color);
+	virtual void FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillRect(const BRect r, RGBColor& color);
+	virtual void FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
 //	virtual void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
+	virtual void FillTriangle(BPoint *pts, RGBColor& color);
+	virtual void FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color);
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, RGBColor& color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeEllipse(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokePoint(BPoint& pt, RGBColor& color);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed=true);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed=true);
+	virtual void StrokeRect(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+//	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
+
+	virtual void StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors);
+
 
 	virtual void HideCursor(void);
 	virtual void MoveCursorTo(float x, float y);
@@ -59,8 +93,6 @@ public:
 	virtual void ObscureCursor(void);
 	virtual void SetCursor(ServerCursor *csr);
 
-//	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
-	virtual void StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
 	virtual void SetMode(int32 mode);
 	virtual bool DumpToFile(const char *path);
 	float StringWidth(const char *string, int32 length, LayerData *d);
@@ -79,12 +111,17 @@ public:
 protected:
 	void BlitBitmap(ServerBitmap *sourcebmp, BRect sourcerect, BRect destrect, drawing_mode mode=B_OP_COPY);
 	void ExtractToBitmap(ServerBitmap *destbmp, BRect destrect, BRect sourcerect);
-	void SetPixelPattern(int x, int y, uint8 *pattern, uint8 patternindex);
+	//void SetPixelPattern(int x, int y, uint8 *pattern, uint8 patternindex);
-	void HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat);
+	//void HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat);
-	void HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat);
+	//void HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat);
+	void HLinePatternThick(int32 x1, int32 x2, int32 y);
+	void VLinePatternThick(int32 x, int32 y1, int32 y2);
+	void FillSolidRect(int32 left, int32 top, int32 right, int32 bottom);
+	void FillPatternRect(int32 left, int32 top, int32 right, int32 bottom);
 	rgb_color GetBlitColor(rgb_color src, rgb_color dest, LayerData *d, bool use_high=true);
-	void SetPixel(int x, int y, RGBColor col);
+	//void SetPixel(int x, int y, RGBColor col);
-	void SetThickPixel(int x, int y, int thick, PatternHandler *pat);
+	//void SetThickPixel(int x, int y, int thick, PatternHandler *pat);
+	void SetThickPatternPixel(int x, int y);
 	int OpenGraphicsDevice(int deviceNumber);
 	int GetModeFromResolution(int width, int height, int space);
 	int GetWidthFromMode(int mode);

src/servers/app/server/BitmapDriver.h

@@ -79,8 +79,40 @@ public:
 //	virtual void DrawPicture(SPicture *pic, BPoint pt);
 	virtual void DrawString(const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *delta=NULL);
 
-	virtual void FillRect(BRect r, LayerData *d, const Pattern &pat);
+virtual void FillArc(const BRect r, float angle, float span, RGBColor& color);
+	virtual void FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillBezier(BPoint *pts, RGBColor& color);
+	virtual void FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillEllipse(BRect r, RGBColor& color);
+	virtual void FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillRect(const BRect r, RGBColor& color);
+	virtual void FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
 //	virtual void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
+	virtual void FillTriangle(BPoint *pts, RGBColor& color);
+	virtual void FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color);
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, RGBColor& color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeEllipse(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokePoint(BPoint& pt, RGBColor& color);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed=true);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed=true);
+	virtual void StrokeRect(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+//	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
+
+	virtual void StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors);
 
 	virtual void HideCursor(void);
 	virtual void MoveCursorTo(float x, float y);
@@ -89,8 +121,6 @@ public:
 	virtual void ObscureCursor(void);
 	virtual void SetCursor(ServerCursor *cursor);
 
-//	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
-//	virtual void StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
 	virtual void SetMode(int32 mode);
 	float StringWidth(const char *string, int32 length, LayerData *d);
 	float StringHeight(const char *string, int32 length, LayerData *d);
@@ -100,19 +130,12 @@ protected:
 	void BlitGray2RGB32(FT_Bitmap *src, BPoint pt, LayerData *d);
 	void BlitBitmap(ServerBitmap *sourcebmp, BRect sourcerect, BRect destrect, drawing_mode mode=B_OP_COPY);
 	void ExtractToBitmap(ServerBitmap *destbmp, BRect destrect, BRect sourcerect);
-	void SetPixelPattern(int x, int y, uint8 *pattern, uint8 patternindex);
-	void Line(BPoint start, BPoint end, LayerData *d, const Pattern &pat);
-	void HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat);
-	void HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat);
 	rgb_color GetBlitColor(rgb_color src, rgb_color dest, LayerData *d, bool use_high=true);
-	void SetPixel(int x, int y, RGBColor col);
+	void HLinePatternThick(int32 x1, int32 x2, int32 y);
-	void SetPixel32(int x, int y, rgb_color col);
+	void VLinePatternThick(int32 x, int32 y1, int32 y2);
-	void SetPixel16(int x, int y, uint16 col);
+	void FillSolidRect(int32 left, int32 top, int32 right, int32 bottom);
-	void SetPixel8(int x, int y, uint8 col);
+	void FillPatternRect(int32 left, int32 top, int32 right, int32 bottom);
-	void SetThickPixel(int x, int y, int thick, RGBColor col);
+	void SetThickPatternPixel(int x, int y);
-	void SetThickPixel32(int x, int y, int thick, rgb_color col);
-	void SetThickPixel16(int x, int y, int thick, uint16 col);
-	void SetThickPixel8(int x, int y, int thick, uint8 col);
 	ServerBitmap *_target;
 };
 

src/servers/app/server/Clipper.cpp

@@ -26,6 +26,7 @@
 //  
 //------------------------------------------------------------------------------
 #include "Clipper.h"
+#include "LayerData.h"
 
 Clipper::Clipper(DisplayDriver* driver)
 {
@@ -46,50 +47,109 @@ void Clipper::DrawString(BRegion* clip_reg, const char *string, int32 length, BP
 	fDriver->DrawString(string,length,pt,d,edelta);
 }
 
-void Clipper::FillArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
+
+
+
+
+
+
+
+void Clipper::FillArc(const BRect r, float angle, float span, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->FillArc(r,angle,span,d,pat);
+	fDriver->FillArc(r,angle,span,color);
 }
 
-void Clipper::FillBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat)
+void Clipper::FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->FillBezier(pts,d,pat);
+	fDriver->FillArc(r,angle,span,pattern,high_color,low_color);
 }
 
-void Clipper::FillEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillBezier(BPoint *pts, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->FillEllipse(r,d,pat);
+	fDriver->FillBezier(pts,color);
 }
 
-void Clipper::FillPolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat)
+void Clipper::FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->FillPolygon(ptlist,numpts,rect,d,pat);
+	fDriver->FillBezier(pts,pattern,high_color,low_color);
 }
 
-void Clipper::FillRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillEllipse(BRect r, RGBColor& color, BRegion* clip_reg)
 {
-	BRegion reg;
+	fDriver->FillEllipse(r,color);
+}
 
-	reg.Set(r);
+void Clipper::FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	fDriver->FillEllipse(r,pattern,high_color,low_color);
+}
+
+void Clipper::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color, BRegion* clip_reg)
+{
+	fDriver->FillPolygon(ptlist,numpts,color);
+}
+
+void Clipper::FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	fDriver->FillPolygon(ptlist,numpts,pattern,high_color,low_color);
+}
+
+void Clipper::FillRect(const BRect r, RGBColor& color, BRegion* clip_reg)
+{
 	if ( clip_reg )
+	{
+		BRegion reg;
+		reg.Set(r);
 		reg.IntersectWith(clip_reg);
-	fDriver->FillRegion(&reg,d,pat);
+		fDriver->FillRegion(reg,color);
+	}
+	else
+		fDriver->FillRect(r,color);
 }
 
-void Clipper::FillRegion(BRegion* clip_reg, BRegion *r, LayerData *d, const Pattern &pat)
+void Clipper::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	BRegion reg;
-
-	reg = *r;
 	if ( clip_reg )
+	{
+		BRegion reg;
+		reg.Set(r);
 		reg.IntersectWith(clip_reg);
-	fDriver->FillRegion(&reg,d,pat);
+		fDriver->FillRegion(reg,pattern,high_color,low_color);
+	}
+	else
+		fDriver->FillRect(r,pattern,high_color,low_color);
 }
 
-void Clipper::FillRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
+void Clipper::FillRegion(BRegion& r, RGBColor& color, BRegion* clip_reg)
+{
+	if ( clip_reg )
+	{
+		BRegion reg;
+		reg = r;
+		reg.IntersectWith(clip_reg);
+		fDriver->FillRegion(reg,color);
+	}
+	else
+		fDriver->FillRegion(r,color);
+}
+
+void Clipper::FillRegion(BRegion& r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	if ( clip_reg )
+	{
+		BRegion reg;
+		reg = r;
+		reg.IntersectWith(clip_reg);
+		fDriver->FillRegion(reg,pattern,high_color,low_color);
+	}
+	else
+		fDriver->FillRegion(r,pattern,high_color,low_color);
+}
+
+void Clipper::FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color, BRegion* clip_reg)
 {
 	if ( !clip_reg )
-		fDriver->FillRoundRect(r,xrad,yrad,d,pat);
+		fDriver->FillRoundRect(r,xrad,yrad,color);
 	else
 	{
 		BRegion reg(r);
@@ -103,64 +163,214 @@ void Clipper::FillRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad,
 		reg.Exclude(corner_rect);
 		corner_rect.OffsetTo(r.right-xrad,r.bottom-yrad);
 		reg.Exclude(corner_rect);
-		FillRegion(clip_reg,&reg,d,pat);
+		FillRegion(reg,color,clip_reg);
 		arc_rect.OffsetTo(r.left,r.top);
-		FillArc(clip_reg,arc_rect,90,90,d,pat);
+		FillArc(arc_rect,90,90,color,clip_reg);
 		arc_rect.OffsetTo(r.left,r.bottom-2*yrad);
-		FillArc(clip_reg,arc_rect,180,90,d,pat);
+		FillArc(arc_rect,180,90,color,clip_reg);
 		arc_rect.OffsetTo(r.right-2*xrad,r.bottom-2*yrad);
-		FillArc(clip_reg,arc_rect,270,90,d,pat);
+		FillArc(arc_rect,270,90,color,clip_reg);
 		arc_rect.OffsetTo(r.right-2*xrad,r.top);
-		FillArc(clip_reg,arc_rect,0,90,d,pat);
+		FillArc(arc_rect,0,90,color,clip_reg);
 	}
 }
 
-void Clipper::FillTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->FillTriangle(pts,r,d,pat);
+	if ( !clip_reg )
+		fDriver->FillRoundRect(r,xrad,yrad,pattern,high_color,low_color);
+	else
+	{
+		BRegion reg(r);
+		BRect corner_rect(0,0,xrad,yrad);
+		BRect arc_rect(0,0,2*xrad,2*yrad);
+		corner_rect.OffsetTo(r.left,r.top);
+		reg.Exclude(corner_rect);
+		corner_rect.OffsetTo(r.right-xrad,r.top);
+		reg.Exclude(corner_rect);
+		corner_rect.OffsetTo(r.left,r.bottom-yrad);
+		reg.Exclude(corner_rect);
+		corner_rect.OffsetTo(r.right-xrad,r.bottom-yrad);
+		reg.Exclude(corner_rect);
+		FillRegion(reg,pattern,high_color,low_color,clip_reg);
+		arc_rect.OffsetTo(r.left,r.top);
+		FillArc(arc_rect,90,90,pattern,high_color,low_color,clip_reg);
+		arc_rect.OffsetTo(r.left,r.bottom-2*yrad);
+		FillArc(arc_rect,180,90,pattern,high_color,low_color,clip_reg);
+		arc_rect.OffsetTo(r.right-2*xrad,r.bottom-2*yrad);
+		FillArc(arc_rect,270,90,pattern,high_color,low_color,clip_reg);
+		arc_rect.OffsetTo(r.right-2*xrad,r.top);
+		FillArc(arc_rect,0,90,pattern,high_color,low_color,clip_reg);
+	}
 }
 
-void Clipper::StrokeArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
+void Clipper::FillTriangle(BPoint *pts, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->StrokeArc(r,angle,span,d,pat);
+	fDriver->FillTriangle(pts,color);
 }
 
-void Clipper::StrokeBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat)
+void Clipper::FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->StrokeBezier(pts,d,pat);
+	fDriver->FillTriangle(pts,pattern,high_color,low_color);
 }
 
-void Clipper::StrokeEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->StrokeEllipse(r,d,pat);
+	fDriver->StrokeArc(r,angle,span,pensize,color);
 }
 
-void Clipper::StrokeLine(BRegion* clip_reg, BPoint start, BPoint end, LayerData *d, const Pattern &pat)
+void Clipper::StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->StrokeLine(start,end,d,pat);
+	fDriver->StrokeArc(r,angle,span,pensize,pattern,high_color,low_color);
 }
 
-void Clipper::StrokePolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed)
+void Clipper::StrokeBezier(BPoint *pts, float pensize, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->StrokePolygon(ptlist,numpts,rect,d,pat,is_closed);
+	fDriver->StrokeBezier(pts,pensize,color);
 }
 
-void Clipper::StrokeRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->StrokeRect(r,d,pat);
+	fDriver->StrokeBezier(pts,pensize,pattern,high_color,low_color);
 }
 
-void Clipper::StrokeRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
+void Clipper::StrokeEllipse(BRect r, float pensize, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->StrokeRoundRect(r,xrad,yrad,d,pat);
+	fDriver->StrokeEllipse(r,pensize,color);
 }
 
-void Clipper::StrokeTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
 {
-	fDriver->StrokeTriangle(pts,r,d,pat);
+	fDriver->StrokeEllipse(r,pensize,pattern,high_color,low_color);
 }
 
-void Clipper::StrokeLineArray(BRegion* clip_reg, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d)
+void Clipper::StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color, BRegion* clip_reg)
 {
-	fDriver->StrokeLineArray(pts,numlines,colors,d);
+	if ( clip_reg )
+	{
+		int i;
+		BRect currentRect;
+		LineCalc line(start,end);
+		BRect lineBounds(line.MinX(),line.MinY(),line.MaxX(),line.MaxY());
+		for (i=0; i<clip_reg->CountRects(); i++)
+		{
+			currentRect = clip_reg->RectAt(i);
+			if ( currentRect.Intersects(lineBounds) ) 
+			{
+				if ( currentRect.Contains(start) && currentRect.Contains(end) )
+				{
+					fDriver->StrokeLine(start,end,pensize,color);
+					return;
+				}
+				if ( line.ClipToRect(currentRect) )
+				{
+					fDriver->StrokeLine(line.GetStart(),line.GetEnd(),pensize,color);
+					line.SetPoints(start,end);
+				}
+			}
+		}
+	}
+	else
+		fDriver->StrokeLine(start,end,pensize,color);
+}
+
+void Clipper::StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	if ( clip_reg )
+	{
+		int i;
+		BRect currentRect;
+		LineCalc line(start,end);
+		BRect lineBounds(line.MinX(),line.MinY(),line.MaxX(),line.MaxY());
+		for (i=0; i<clip_reg->CountRects(); i++)
+		{
+			currentRect = clip_reg->RectAt(i);
+			if ( currentRect.Intersects(lineBounds) ) 
+			{
+				if ( currentRect.Contains(start) && currentRect.Contains(end) )
+				{
+					fDriver->StrokeLine(start,end,pensize,pattern,high_color,low_color);
+					return;
+				}
+				if ( line.ClipToRect(currentRect) )
+				{
+					fDriver->StrokeLine(line.GetStart(),line.GetEnd(),pensize,pattern,high_color,low_color);
+					line.SetPoints(start,end);
+				}
+			}
+		}
+	}
+	else
+		fDriver->StrokeLine(start,end,pensize,pattern,high_color,low_color);
+}
+
+void Clipper::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed, BRegion* clip_reg)
+{
+	fDriver->StrokePolygon(ptlist,numpts,pensize,color,is_closed);
+}
+
+void Clipper::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed, BRegion* clip_reg)
+{
+	fDriver->StrokePolygon(ptlist,numpts,pensize,pattern,high_color,low_color,is_closed);
+}
+
+void Clipper::StrokeRect(BRect r, float pensize, RGBColor& color, BRegion* clip_reg)
+{
+	if ( clip_reg )
+	{
+		StrokeLine(r.LeftTop(), r.RightTop(), pensize, color, clip_reg);
+		StrokeLine(r.LeftTop(), r.LeftBottom(), pensize, color, clip_reg);
+		StrokeLine(r.RightTop(), r.RightBottom(), pensize, color, clip_reg);
+		StrokeLine(r.LeftBottom(), r.RightBottom(), pensize, color, clip_reg);
+	}
+	else
+		fDriver->StrokeRect(r,pensize,color);
+}
+
+void Clipper::StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	if ( clip_reg )
+	{
+		StrokeLine(r.LeftTop(), r.RightTop(), pensize, pattern, high_color, low_color, clip_reg);
+		StrokeLine(r.LeftTop(), r.LeftBottom(), pensize, pattern, high_color, low_color, clip_reg);
+		StrokeLine(r.RightTop(), r.RightBottom(), pensize, pattern, high_color, low_color, clip_reg);
+		StrokeLine(r.LeftBottom(), r.RightBottom(), pensize, pattern, high_color, low_color, clip_reg);
+	}
+	else
+		fDriver->StrokeRect(r,pensize,pattern,high_color,low_color);
+}
+
+void Clipper::StrokeRegion(BRegion& r, float pensize, RGBColor& color, BRegion* clip_reg)
+{
+	fDriver->StrokeRegion(r,pensize,color);
+}
+
+void Clipper::StrokeRegion(BRegion& r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	fDriver->StrokeRegion(r,pensize,pattern,high_color,low_color);
+}
+
+void Clipper::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color, BRegion* clip_reg)
+{
+	fDriver->StrokeRoundRect(r,xrad,yrad,pensize,color);
+}
+
+void Clipper::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	fDriver->StrokeRoundRect(r,xrad,yrad,pensize,pattern,high_color,low_color);
+}
+
+void Clipper::StrokeTriangle(BPoint *pts, float pensize, RGBColor& color, BRegion* clip_reg)
+{
+	fDriver->StrokeTriangle(pts,pensize,color);
+}
+
+void Clipper::StrokeTriangle(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg)
+{
+	fDriver->StrokeTriangle(pts,pensize,pattern,high_color,low_color);
+}
+
+void Clipper::StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors, BRegion* clip_reg)
+{
+	fDriver->StrokeLineArray(pts,numlines,pensize,colors);
 }

src/servers/app/server/Clipper.h

@@ -41,26 +41,44 @@ public:
 	void DrawBitmap(BRegion* clip_reg, ServerBitmap *bmp, BRect src, BRect dest, LayerData *d);
 	void DrawString(BRegion* clip_reg, const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta=NULL);
 
-	void FillArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	void FillBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat);
-	void FillEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void FillPolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat);
-	void FillRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void FillRegion(BRegion* clip_reg, BRegion* r, LayerData *d, const Pattern &pat);
-	void FillRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
-//	void FillShape(BRegion* clip_reg, SShape *sh, LayerData *d, const Pattern &pat);
-	void FillTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
 
-	void StrokeArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
+	void FillArc(const BRect r, float angle, float span, RGBColor& color, BRegion* clip_reg=NULL);
-	void StrokeBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat);
+	void FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
-	void StrokeEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
+	void FillBezier(BPoint *pts, RGBColor& color, BRegion* clip_reg=NULL);
-	void StrokeLine(BRegion* clip_reg, BPoint start, BPoint end, LayerData *d, const Pattern &pat);
+	void FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
-	void StrokePolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
+	void FillEllipse(BRect r, RGBColor& color, BRegion* clip_reg=NULL);
-	void StrokeRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
+	void FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
-	void StrokeRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
+	void FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color, BRegion* clip_reg=NULL);
-//	void StrokeShape(BRegion* clip_reg, SShape *sh, LayerData *d, const Pattern &pat);
+	void FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
-	void StrokeTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
+	void FillRect(const BRect r, RGBColor& color, BRegion* clip_reg=NULL);
-	void StrokeLineArray(BRegion* clip_reg, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
+	void FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void FillRegion(BRegion& r, RGBColor& color, BRegion* clip_reg=NULL);
+	void FillRegion(BRegion& r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color, BRegion* clip_reg=NULL);
+	void FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void FillTriangle(BPoint *pts, RGBColor& color, BRegion* clip_reg=NULL);
+	void FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+
+	void StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeBezier(BPoint *pts, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeEllipse(BRect r, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed=true, BRegion* clip_reg=NULL);
+	void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed=true, BRegion* clip_reg=NULL);
+	void StrokeRect(BRect r, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeRegion(BRegion& r, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeRegion(BRegion& r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+	void StrokeTriangle(BPoint *pts, float pensize, RGBColor& color, BRegion* clip_reg=NULL);
+	void StrokeTriangle(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL);
+
+	void StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors, BRegion* clip_reg=NULL);
 private:
 	DisplayDriver* fDriver;
 };

src/servers/app/server/DefaultDecorator.cpp

@@ -412,30 +412,30 @@ STRACE(("_DrawTab(%f,%f,%f,%f)\n", r.left, r.top, r.right, r.bottom));
 		return;
 	
 	_layerdata.highcolor=(GetFocus())?_colors->window_tab:_colors->inactive_window_tab;
-	_driver->FillRect(_tabrect,&_layerdata,pat_solidhigh);
+	_driver->FillRect(_tabrect,_layerdata.highcolor);
 	
 	_layerdata.highcolor=framecolors[2];
-	_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.LeftBottom(),&_layerdata,pat_solidhigh);
+	_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.LeftBottom(),_layerdata.pensize,_layerdata.highcolor);
-	_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.RightTop(),&_layerdata,pat_solidhigh);
+	_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.RightTop(),_layerdata.pensize,_layerdata.highcolor);
 	_layerdata.highcolor=framecolors[4];
-	_driver->StrokeLine(_tabrect.RightTop(),_tabrect.RightBottom(),&_layerdata,pat_solidhigh);
+	_driver->StrokeLine(_tabrect.RightTop(),_tabrect.RightBottom(),_layerdata.pensize,_layerdata.highcolor);
 	_layerdata.highcolor=framecolors[1];	
 	_driver->StrokeLine( BPoint( _tabrect.left + 2, _tabrect.bottom ),
 						 BPoint( _tabrect.right - 2, _tabrect.bottom ),
-						 &_layerdata,pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	
 	_layerdata.highcolor = RGBColor( 255, 255, 0 );
 	_driver->StrokeLine( BPoint( _tabrect.left + 1, _tabrect.top + 1),
 						 BPoint( _tabrect.left + 1, _tabrect.bottom),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	_driver->StrokeLine( BPoint( _tabrect.left + 1, _tabrect.top + 1),
 						 BPoint( _tabrect.right - 1, _tabrect.top + 1),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 
 	_layerdata.highcolor = RGBColor( 175, 123, 0 );						 
 	_driver->StrokeLine( BPoint( _tabrect.right - 1, _tabrect.top + 2),
 						 BPoint( _tabrect.right - 1, _tabrect.bottom),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 
 
 	_DrawTitle(_tabrect);
@@ -461,21 +461,21 @@ void DefaultDecorator::DrawBlendedRect(BRect r, bool down)
 	_layerdata.highcolor = RGBColor( 175, 123, 0 );						 
 	_driver->StrokeLine( r.LeftTop(),
 						 BPoint( r.left, r.bottom - 1 ),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	_driver->StrokeLine( r.LeftTop(),
 						 BPoint( r.right - 1, r.top ),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	_driver->StrokeLine( BPoint( r.right - 1, r.top + 2),
 						 BPoint( r.right - 1, r.bottom - 1),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	_driver->StrokeLine( BPoint( r.left + 2, r.bottom -1),
 						 BPoint( r.right - 2, r.bottom - 1),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 
 	_layerdata.highcolor = RGBColor( 255, 255, 0 );
 	_driver->StrokeRect( BRect( r.left + 1, r.top + 1,
 								r.right, r.bottom),
-						 &_layerdata, pat_solidhigh);
+						 _layerdata.pensize,_layerdata.highcolor);
 	
 	r.InsetBy( 2, 2 );
 	
@@ -511,7 +511,7 @@ void DefaultDecorator::DrawBlendedRect(BRect r, bool down)
 			uint8(startcol.blue-(i*bstep)));
 		_layerdata.highcolor=tmpcol;
 		_driver->StrokeLine(BPoint(r.left,r.top+i),
-			BPoint(r.left+i,r.top),&_layerdata,pat_solidhigh);
+			BPoint(r.left+i,r.top),_layerdata.pensize,_layerdata.highcolor);
 
 		SetRGBColor(&tmpcol, uint8(halfcol.red-(i*rstep)),
 			uint8(halfcol.green-(i*gstep)),
@@ -519,7 +519,7 @@ void DefaultDecorator::DrawBlendedRect(BRect r, bool down)
 
 		_layerdata.highcolor=tmpcol;
 		_driver->StrokeLine(BPoint(r.left+steps,r.top+i),
-			BPoint(r.left+i,r.top+steps),&_layerdata,pat_solidhigh);
+			BPoint(r.left+i,r.top+steps),_layerdata.pensize,_layerdata.highcolor);
 	}
 }
 
@@ -532,7 +532,7 @@ STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
 	
 	#ifdef USE_VIEW_FILL_HACK
 		_layerdata.highcolor = RGBColor( 255, 255, 255 );	
-		_driver->FillRect(_frame,&_layerdata,pat_solidhigh);
+		_driver->FillRect(_frame,_layerdata.highcolor);
 	#endif
 
 	if(!borderwidth){
@@ -798,7 +798,7 @@ STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
 		}
 	}
 
-	_driver->StrokeLineArray(points,numlines,colors,&_layerdata);
+	_driver->StrokeLineArray(points,numlines,_layerdata.pensize,colors);
 	
 	delete rightindices;
 	delete leftindices;
@@ -816,17 +816,17 @@ STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
 			r.bottom-=4;
 			_layerdata.highcolor=framecolors[2];
 
-			_driver->StrokeLine(r.LeftTop(),r.RightTop(),&_layerdata,pat_solidhigh);
+			_driver->StrokeLine(r.LeftTop(),r.RightTop(),_layerdata.pensize,_layerdata.highcolor);
-			_driver->StrokeLine(r.LeftTop(),r.LeftBottom(),&_layerdata,pat_solidhigh);
+			_driver->StrokeLine(r.LeftTop(),r.LeftBottom(),_layerdata.pensize,_layerdata.highcolor);
 
 			r.OffsetBy(1,1);
 			_layerdata.highcolor=framecolors[0];
-			_driver->StrokeLine(r.LeftTop(),r.RightTop(),&_layerdata,pat_solidhigh);
+			_driver->StrokeLine(r.LeftTop(),r.RightTop(),_layerdata.pensize,_layerdata.highcolor);
-			_driver->StrokeLine(r.LeftTop(),r.LeftBottom(),&_layerdata,pat_solidhigh);
+			_driver->StrokeLine(r.LeftTop(),r.LeftBottom(),_layerdata.pensize,_layerdata.highcolor);
 			
 			r.OffsetBy(1,1);
 			_layerdata.highcolor=framecolors[1];
-			_driver->FillRect(r,&_layerdata,pat_solidhigh);
+			_driver->FillRect(r,_layerdata.highcolor);
 			
 /*			r.left+=2;
 			r.top+=2;
@@ -862,25 +862,25 @@ STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
 					uint8(startcol.blue-(i*bstep)));
 				
 				_driver->StrokeLine(BPoint(r.left,r.top+i),
-					BPoint(r.left+i,r.top),&_layerdata,pat_solidhigh);
+					BPoint(r.left+i,r.top),_layerdata.pensize,_layerdata.highcolor);
 		
 				_layerdata.highcolor.SetColor(uint8(halfcol.red-(i*rstep)),
 					uint8(halfcol.green-(i*gstep)),
 					uint8(halfcol.blue-(i*bstep)));
 				_driver->StrokeLine(BPoint(r.left+steps,r.top+i),
-					BPoint(r.left+i,r.top+steps),&_layerdata,pat_solidhigh);			
+					BPoint(r.left+i,r.top+steps),_layerdata.pensize,_layerdata.highcolor);			
 			}
 			_driver->Unlock();
 //			_layerdata.highcolor=framecolors[4];
-//			_driver->StrokeRect(r,&_layerdata,pat_solidhigh);
+//			_driver->StrokeRect(r,_layerdata.pensize,_layerdata.highcolor);
 		}
 		else
 		{
 			_layerdata.highcolor=framecolors[2];
 			_driver->StrokeLine(BPoint(r.right-4,r.top),BPoint(r.right-2,r.top),
-				&_layerdata,pat_solidhigh);
+				_layerdata.pensize,_layerdata.highcolor);
 			_driver->StrokeLine(BPoint(r.left,r.bottom-4),BPoint(r.left,r.bottom-2),
-				&_layerdata,pat_solidhigh);
+				_layerdata.pensize,_layerdata.highcolor);
 		}
 	}
 

src/servers/app/server/Desktop.cpp

@@ -102,10 +102,7 @@ STRACE(("Desktop: InitWorkspace\n"));
 
 	if(tdriver->Initialize())
 	{
-		// TODO: figure out how to load the workspace data and do it here.
+		s=new Screen(tdriver);
-		// For now, we'll just use 3 workspaces.
-		
-		s=new Screen(tdriver,3);
 		desktop_private::screenlist->AddItem(s);
 	}
 	else
@@ -127,10 +124,7 @@ STRACE(("\t NULL display driver. OK. We crash now. :P\n"));
 
 	if(tdriver->Initialize())
 	{
-		// TODO: figure out how to load the workspace data and do it here.
+		s=new Screen(tdriver);
-		// For now, we'll just use 3 workspaces.
-		
-		s=new Screen(tdriver,3);
 		desktop_private::screenlist->AddItem(s);
 	}
 	else
@@ -149,6 +143,13 @@ STRACE(("\t NULL display driver. OK. We crash now. :P\n"));
 	{
 		s->Activate();
 		desktop_private::activescreen=s;
+
+		// TODO: figure out how to load the workspace data and do it here.
+		// For now, we'll just use 3 workspaces.
+		// Initializing the workspaces has been seperated from the constructor
+		// since currently RootLayer can only be constructed when there is an
+		// active screen.
+		s->SetWorkspaceCount(3);
 #ifdef TEST_MODE
 		s->SetSpace(0,B_32_BIT_640x480,true);
 #endif

src/servers/app/server/DesktopClasses.cpp

@@ -176,7 +176,7 @@ STRACE_WS(("Workspace::SetSpace(%ld) unimplemented\n",res));
 	\param gfxmodule Pointer to the uninitialized display driver to use
 	\param workspaces The number of workspaces on this screen
 */
-Screen::Screen(DisplayDriver *gfxmodule, uint8 workspaces)
+Screen::Screen(DisplayDriver *gfxmodule)
 {
 STRACE_SCREEN(("Screen::Screen(%s,%u)\n",gfxmodule?"driver":"NULL",workspaces));
 	_workspacelist=NULL;
@@ -210,22 +210,9 @@ STRACE_SCREEN(("Screen::Screen(%s,%u)\n",gfxmodule?"driver":"NULL",workspaces));
 		
 		// right now, we won't do anything with the gcinfo structure. ** LAZY PROGRAMMER ALERT ** :P
 
-		_workspacelist = new BList(workspaces);
+		_workspacelist = new BList();
-		_workspacecount = workspaces;
+		_workspacecount = 0;
-		for (int i=0; i<workspaces; i++)
-		{
-			_workspacelist->AddItem(new Workspace(_gcinfo,_fbinfo,this));
-		}
 		_resolution=_driver->GetMode();
-		
-		if(workspaces>0)
-		{
-			_currentworkspace=0;
-			_activeworkspace=(Workspace*)_workspacelist->ItemAt(0);
-			_workspacecount=workspaces;
-			_activeworkspace->GetRoot()->Show();
-//			_activeworkspace->GetRoot()->RequestDraw();
-		}
 	}
 }
 
@@ -311,7 +298,16 @@ void Screen::SetWorkspaceCount(int32 count)
 	if ( _workspacecount == count )
 		return;
 	for (i=_workspacecount; i<count; i++)
+	{
 		AddWorkspace();
+		if ( !i )
+		{
+			_currentworkspace=0;
+			_activeworkspace=(Workspace*)_workspacelist->ItemAt(0);
+			_activeworkspace->GetRoot()->Show();
+//			_activeworkspace->GetRoot()->RequestDraw();
+		}
+	}
 	for (i=_workspacecount; i>count; i--)
 		DeleteWorkspace(i-1);
 	_workspacecount = count;

src/servers/app/server/DesktopClasses.h

@@ -91,7 +91,7 @@ protected:
 class Screen
 {
 public:
-	Screen(DisplayDriver *gfxmodule, uint8 workspaces);
+	Screen(DisplayDriver *gfxmodule);
 	~Screen(void);
 	void AddWorkspace(int32 index=-1);
 	void AddWorkspace(Workspace *workspace,int32 index=-1);

src/servers/app/server/Layer.cpp

@@ -485,13 +485,10 @@ void Layer::RequestClientUpdate(const BRect &rect){
 		// only the visible area is cleared, because DisplayDriver does the clipping to it.
 		// draw background, *only IF* our view color is different to B_TRANSPARENT_COLOR!
 	if ( !(_layerdata->viewcolor == RGBColor(B_TRANSPARENT_COLOR)) ) {
-			// a quick hack for drawing in other color than the low one.
+		RGBColor tempColor(B_TRANSPARENT_COLOR);
-		RGBColor		tempColor	= _layerdata->lowcolor;
+		//_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR );
-		_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR );
 
-		fDriver->StrokeRect(rect, _layerdata, pat_solidlow);
+		fDriver->StrokeRect(rect, _layerdata->pensize, tempColor);
-			// .. hack continued
-		_layerdata->lowcolor		= tempColor;
 	}
 
 	BMessage		msg;
@@ -513,13 +510,10 @@ void Layer::RequestDraw(const BRect &r)
 {
 
 	if (_visible.CountRects() > 0){
-			// a quick hack for drawing in other color than the low one.
+		RGBColor tempColor(B_TRANSPARENT_COLOR);
-		RGBColor		tempColor	= _layerdata->lowcolor;
+		//_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR );
-		_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR );
 
-		fDriver->StrokeRect(r, _layerdata, pat_solidlow);
+		fDriver->StrokeRect(r, _layerdata->pensize, tempColor);
-			// .. hack continued
-		_layerdata->lowcolor		= tempColor;
 
 			// draw itself.
 		Draw(r);

src/servers/app/server/PicturePlayer.h

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

src/servers/app/server/RootLayer.cpp

@@ -39,7 +39,6 @@
 //! TokenHandler object used to provide IDs for RootLayers(WorkSpaces)
 TokenHandler rlayer_token_handler;
 
-//#define DISPLAYDRIVER_TEST_HACK
 //#define DEBUG_ROOTLAYER
 
 /*!
@@ -63,78 +62,6 @@ RootLayer::~RootLayer()
 {
 }
 
-/*!
-	\brief Draws this entire layer on screen
-*/
-void RootLayer::Draw(const BRect &r)
-{
-/* THIS method is here because of DisplayDriver testing!
- *	It SHOULD BE REMOVED as soon as testing is done!!!!
- */
-
-#ifdef DISPLAYDRIVER_TEST_HACK
-	int8 pattern[8];
-	int8 pattern2[8];
-	memset(pattern,255,8);
-	memset(pattern2,128+64+32+16,8);
-	BRect r1(100,100,1500,1100);
-	BPoint pts[4];
-	pts[0].x = 200;
-	pts[0].y = 200;
-	pts[1].x = 400;
-	pts[1].y = 1000;
-	pts[2].x = 600;
-	pts[2].y = 400;
-	pts[3].x = 1200;
-	pts[3].y = 800;
-	BPoint triangle[3];
-	BRect triangleRect(100,100,400,300);
-	triangle[0].x = 100;
-	triangle[0].y = 100;
-	triangle[1].x = 100;
-	triangle[1].y = 300;
-	triangle[2].x = 400;
-	triangle[2].y = 300;
-	BPoint polygon[6];
-	BRect polygonRect(100,100,300,400);
-	polygon[0].x = 100;
-	polygon[0].y = 100;
-	polygon[1].x = 100;
-	polygon[1].y = 400;
-	polygon[2].x = 200;
-	polygon[2].y = 300;
-	polygon[3].x = 300;
-	polygon[3].y = 400;
-	polygon[4].x = 300;
-	polygon[4].y = 100;
-	polygon[5].x = 200;
-	polygon[5].y = 200;
-
-	_layerdata->highcolor.SetColor(255,0,0,255);
-	_layerdata->lowcolor.SetColor(255,255,255,255);
-	_driver->FillRect(r1,_layerdata,pattern);
-
-	_layerdata->highcolor.SetColor(255,255,0,255);
-	_driver->StrokeLine(BPoint(100,100),BPoint(1500,1100),_layerdata,pattern);
-
-	_layerdata->highcolor.SetColor(0,0,255,255);
-	_driver->StrokeBezier(pts,_layerdata,pattern);
-	_driver->StrokeArc(BRect(200,300,400,600),30,270,_layerdata,pattern);
-	_driver->StrokeEllipse(BRect(200,700,400,900),_layerdata,pattern);
-	_driver->StrokeRect(BRect(650,1000,750,1090),_layerdata,pattern);
-	_driver->StrokeRoundRect(BRect(200,1000,600,1090),30,40,_layerdata,pattern);
-//	_driver->StrokePolygon(polygon,6,polygonRect,_layerdata,pattern);
-//	_driver->StrokeTriangle(triangle,triangleRect,_layerdata,pattern);
-	_layerdata->highcolor.SetColor(255,0,255,255);
-	_driver->FillArc(BRect(1250,300,1450,600),30,270,_layerdata,pattern);
-//	_driver->FillBezier(pts,_layerdata,pattern);
-	_driver->FillEllipse(BRect(800,300,1200,600),_layerdata,pattern);
-	_driver->FillRoundRect(BRect(800,1000,1200,1090),30,40,_layerdata,pattern2);
-	_driver->FillPolygon(polygon,6,polygonRect,_layerdata,pattern);
-//	_driver->FillTriangle(triangle,triangleRect,_layerdata,pattern);
-#endif
-}
-
 /*!
 	\brief Sets the background color of the Screen
 	\param col The new background color

src/servers/app/server/RootLayer.h

@@ -47,7 +47,6 @@ public:
 										DisplayDriver *gfxdriver);
 	virtual							~RootLayer();
 
-	virtual	void					Draw(const BRect &r);
 	virtual	void					MoveBy(float x, float y);
 	virtual	void					ResizeBy(float x, float y);
 

src/servers/app/server/ServerWindow.cpp

@@ -1528,9 +1528,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					angle = read_from_buffer<float>(&msgbuffer);
 					span = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeArc(rect,angle,span,layerdata,pattern);
+						//_app->_driver->StrokeArc(rect,angle,span,layerdata,pattern);
 					sizeRemaining -= AS_STROKE_ARC_MSG_SIZE;
 				}
 				else
@@ -1555,8 +1555,8 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 						pts[i].y = read_from_buffer<float>(&msgbuffer);
 					}
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeBezier(pts,layerdata,pattern);
+						//_app->_driver->StrokeBezier(pts,layerdata,pattern);
 					delete[] pts;
 					sizeRemaining -= AS_STROKE_BEZIER_MSG_SIZE;
 				}
@@ -1579,9 +1579,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeEllipse(rect,layerdata,pattern);
+						//_app->_driver->StrokeEllipse(rect,layerdata,pattern);
 					sizeRemaining -= AS_STROKE_ELLIPSE_MSG_SIZE;
 				}
 				else
@@ -1603,10 +1603,10 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					x2 = read_from_buffer<float>(&msgbuffer);
 					y2 = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BPoint p1(x1,y1);
+					//BPoint p1(x1,y1);
-					BPoint p2(x2,y2);
+					//BPoint p2(x2,y2);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeLine(p1,p2,layerdata,pattern);
+						//_app->_driver->StrokeLine(p1,p2,layerdata,pattern);
 					sizeRemaining -= AS_STROKE_LINE_MSG_SIZE;
 				}
 				else
@@ -1638,9 +1638,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeRect(rect,layerdata,pattern);
+						//_app->_driver->StrokeRect(rect,layerdata,pattern);
 					sizeRemaining -= AS_STROKE_RECT_MSG_SIZE;
 				}
 				else
@@ -1664,9 +1664,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					xrad = read_from_buffer<float>(&msgbuffer);
 					yrad = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeRoundRect(rect,xrad,yrad,layerdata,pattern);
+						//_app->_driver->StrokeRoundRect(rect,xrad,yrad,layerdata,pattern);
 					sizeRemaining -= AS_STROKE_ROUNDRECT_MSG_SIZE;
 				}
 				else
@@ -1701,9 +1701,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->StrokeTriangle(pts,rect,layerdata,pattern);
+						//_app->_driver->StrokeTriangle(pts,rect,layerdata,pattern);
 					delete[] pts;
 					sizeRemaining -= AS_STROKE_TRIANGLE_MSG_SIZE;
 				}
@@ -1728,9 +1728,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					angle = read_from_buffer<float>(&msgbuffer);
 					span = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->FillArc(rect,angle,span,layerdata,pattern);
+						//_app->_driver->FillArc(rect,angle,span,layerdata,pattern);
 					sizeRemaining -= AS_FILL_ARC_MSG_SIZE;
 				}
 				else
@@ -1755,8 +1755,8 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 						pts[i].y = read_from_buffer<float>(&msgbuffer);
 					}
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->FillBezier(pts,layerdata,pattern);
+						//_app->_driver->FillBezier(pts,layerdata,pattern);
 					delete[] pts;
 					sizeRemaining -= AS_FILL_BEZIER_MSG_SIZE;
 				}
@@ -1779,9 +1779,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->FillEllipse(rect,layerdata,pattern);
+						//_app->_driver->FillEllipse(rect,layerdata,pattern);
 					sizeRemaining -= AS_FILL_ELLIPSE_MSG_SIZE;
 				}
 				else
@@ -1807,6 +1807,7 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
+					/*
 					BRect rect(left,top,right,bottom);
 					if ( layerdata && numRects )
 						if ( numRects == 1 )
@@ -1817,6 +1818,7 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 							for (i=0; i<numRects; i++)
 								_app->_driver->FillRect(LayerClipRegion.RectAt(i),layerdata,pattern);
 						}
+						*/
 					sizeRemaining -= AS_FILL_RECT_MSG_SIZE;
 				}
 				else
@@ -1845,9 +1847,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					xrad = read_from_buffer<float>(&msgbuffer);
 					yrad = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->FillRoundRect(rect,xrad,yrad,layerdata,pattern);
+						//_app->_driver->FillRoundRect(rect,xrad,yrad,layerdata,pattern);
 					sizeRemaining -= AS_FILL_ROUNDRECT_MSG_SIZE;
 				}
 				else
@@ -1882,9 +1884,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer)
 					right = read_from_buffer<float>(&msgbuffer);
 					bottom = read_from_buffer<float>(&msgbuffer);
 					pattern = read_pattern_from_buffer(&msgbuffer);
-					BRect rect(left,top,right,bottom);
+					//BRect rect(left,top,right,bottom);
-					if ( layerdata )
+					//if ( layerdata )
-						_app->_driver->FillTriangle(pts,rect,layerdata,pattern);
+						//_app->_driver->FillTriangle(pts,rect,layerdata,pattern);
 					delete[] pts;
 					sizeRemaining -= AS_FILL_TRIANGLE_MSG_SIZE;
 				}

src/servers/app/server/ViewDriver.cpp

@@ -809,27 +809,76 @@ bool ViewDriver::DumpToFile(const char *path)
 	return true;
 }
 
-void ViewDriver::FillArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat)
+
+
+
+void ViewDriver::FillArc(const BRect r, float angle, float span, RGBColor& color)
 {
-	if(!d)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+
-	drawview->FillArc(r,angle,span,*((pattern*)pat.GetInt8()));
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+
+	drawview->FillArc(r,angle,span,B_SOLID_HIGH);
 	drawview->Sync();
 	screenwin->view->Invalidate(r);
 	framebuffer->Unlock();
 	screenwin->Unlock();
+	Unlock();
 }
 
-void ViewDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat)
+void ViewDriver::FillArc(const BRect r, float angle, float span, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+
+	drawview->FillArc(r,angle,span,*((pattern*)pat.GetInt8()) );
+	drawview->Sync();
+	screenwin->view->Invalidate(r);
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::FillBezier(BPoint *pts, RGBColor& color)
 {
 	if(!pts)
 		return;
+	Lock();
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->FillBezier(pts,B_SOLID_HIGH);
+	drawview->Sync();
+	
+	// Invalidate the whole view until I get around to adding in the invalid rect calc code
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+
+	Unlock();
+}
+
+void ViewDriver::FillBezier(BPoint *pts, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	if(!pts)
+		return;
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
 	drawview->FillBezier(pts,*((pattern*)pat.GetInt8()));
 	drawview->Sync();
 	
@@ -837,81 +886,498 @@ void ViewDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat)
 	screenwin->view->Invalidate();
 	framebuffer->Unlock();
 	screenwin->Unlock();
+
+	Unlock();
 }
 
-void ViewDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat)
+void ViewDriver::FillEllipse(BRect r, RGBColor& color)
 {
-	if(!d)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->FillEllipse(r,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::FillEllipse(BRect r, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
 	drawview->FillEllipse(r,*((pattern*)pat.GetInt8()));
 	drawview->Sync();
-	screenwin->view->Invalidate(r);
+	screenwin->view->Invalidate();
 	framebuffer->Unlock();
 	screenwin->Unlock();
+	Unlock();
 }
 
-void ViewDriver::FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat)
+void ViewDriver::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color)
 {
-	if(!d)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+	drawview->SetDrawingMode(B_OP_COPY);
-	drawview->FillPolygon(ptlist,numpts,rect,*((pattern*)pat.GetInt8()));
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->FillPolygon(ptlist,numpts,B_SOLID_HIGH);
 	drawview->Sync();
-	screenwin->view->Invalidate(rect);
+	screenwin->view->Invalidate();
 	framebuffer->Unlock();
 	screenwin->Unlock();
+	Unlock();
 }
 
-void ViewDriver::FillRect(BRect r, LayerData *d, const Pattern &pat)
+void ViewDriver::FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
 {
-	if(!d)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->FillPolygon(ptlist,numpts,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::FillRect(const BRect r, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->FillRect(r,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+/*!
+	\brief Called for all BView::FillRect calls
+	\param r BRect to be filled. Guaranteed to be in the frame buffer's coordinate space
+	\param pat The pattern to be used when filling the rectangle
+	\param high_color The high color of the pattern to fill
+	\param low_color  The low color of the pattern to fill
+*/
+void ViewDriver::FillRect(const BRect r, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
 	drawview->FillRect(r,*((pattern*)pat.GetInt8()));
 	drawview->Sync();
-	screenwin->view->Invalidate(r);
+	screenwin->view->Invalidate();
 	framebuffer->Unlock();
 	screenwin->Unlock();
+	Unlock();
 }
 
-void ViewDriver::FillRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
+void ViewDriver::FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color)
 {
-	if(!d)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	SetLayerData(d);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->FillRoundRect(r,xrad,yrad,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
 	drawview->FillRoundRect(r,xrad,yrad,*((pattern*)pat.GetInt8()));
 	drawview->Sync();
-	screenwin->view->Invalidate(r);
+	screenwin->view->Invalidate();
 	framebuffer->Unlock();
 	screenwin->Unlock();
-
+	Unlock();
 }
 
-void ViewDriver::FillTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
+void ViewDriver::FillTriangle(BPoint *pts, RGBColor& color)
 {
-	if(!pts)
+	Lock();
-		return;
 	screenwin->Lock();
 	framebuffer->Lock();
-	BPoint first=pts[0],second=pts[1],third=pts[2];
+	drawview->SetDrawingMode(B_OP_COPY);
-	SetLayerData(d);
+	drawview->SetHighColor(color.GetColor32());
-	drawview->FillTriangle(first,second,third,r,*((pattern*)pat.GetInt8()));
+	drawview->SetLowColor(color.GetColor32());
+	BRect r(pts[0],pts[0]);
+	int i;
+	for (i=1; i<3; i++)
+	{
+		if ( pts[i].x < r.left )
+			r.left = pts[i].x;
+		if ( pts[i].x > r.right )
+			r.right = pts[i].x;
+		if ( pts[i].y < r.top )
+			r.top = pts[i].y;
+		if ( pts[i].y > r.bottom )
+			r.bottom = pts[i].y;
+	}
+	drawview->FillTriangle(pts[0],pts[1],pts[2],r,B_SOLID_HIGH);
 	drawview->Sync();
-	screenwin->view->Invalidate(r);
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::FillTriangle(BPoint *pts, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	BRect r(pts[0],pts[0]);
+	int i;
+	for (i=1; i<3; i++)
+	{
+		if ( pts[i].x < r.left )
+			r.left = pts[i].x;
+		if ( pts[i].x > r.right )
+			r.right = pts[i].x;
+		if ( pts[i].y < r.top )
+			r.top = pts[i].y;
+		if ( pts[i].y > r.bottom )
+			r.bottom = pts[i].y;
+	}
+	drawview->FillTriangle(pts[0],pts[1],pts[2],r,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeArc(r,angle,span,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeArc(r,angle,span,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeBezier(BPoint *pts, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeBezier(pts,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeBezier(BPoint *pts, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeBezier(pts,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeEllipse(BRect r, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeEllipse(r,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeEllipse(BRect r, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeEllipse(r,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeLine(start,end,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeLine(start,end,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokePoint(BPoint& pt, RGBColor& color)
+{
+	Lock();
+	Unlock();
+}
+
+void ViewDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed)
+{
+	if(!ptlist)
+		return;
+
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+
+	BRegion invalid;
+
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->BeginLineArray(numpts+2);
+	for(int i=1;i<numpts;i++)
+	{
+		drawview->AddLine(ptlist[i-1],ptlist[i],color.GetColor32());
+		invalid.Include(BRect(ptlist[i-1],ptlist[i]));
+	}
+
+	if(is_closed)
+	{
+		drawview->AddLine(ptlist[numpts-1],ptlist[0],color.GetColor32());
+		invalid.Include(BRect(ptlist[numpts-1],ptlist[0]));
+	}
+	drawview->EndLineArray();
+
+	drawview->Sync();
+	screenwin->view->Invalidate(invalid.Frame());
 	framebuffer->Unlock();
 	screenwin->Unlock();
 
+
+	Unlock();
 }
 
+void ViewDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color, bool is_closed)
+{
+	StrokePolygon(ptlist,numpts,pensize,high_color,is_closed);
+}
+
+void ViewDriver::StrokeRect(BRect r, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeRect(r,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeRect(BRect r, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeRect(r,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(color.GetColor32());
+	drawview->SetLowColor(color.GetColor32());
+	drawview->StrokeRoundRect(r,xrad,yrad,B_SOLID_HIGH);
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+void ViewDriver::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pat, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+	drawview->SetHighColor(high_color.GetColor32());
+	drawview->SetLowColor(low_color.GetColor32());
+	drawview->StrokeRoundRect(r,xrad,yrad,*((pattern*)pat.GetInt8()));
+	drawview->Sync();
+	screenwin->view->Invalidate();
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+/*!
+	\brief Draws a series of lines - optimized for speed
+	\param pts Array of BPoints pairs
+	\param numlines Number of lines to be drawn
+	\param pensize The thickness of the lines
+	\param colors Array of colors for each respective line
+*/
+void ViewDriver::StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors)
+{
+	if( !numlines || !pts || !colors)
+		return;
+	
+	Lock();
+	screenwin->Lock();
+	framebuffer->Lock();
+	drawview->SetPenSize(pensize);
+	drawview->SetDrawingMode(B_OP_COPY);
+
+	int32 ptindex=0;
+
+	drawview->BeginLineArray(numlines);
+	for(int32 i=0; i<numlines; i++)
+	{
+		BPoint pt1=pts[ptindex++];
+		BPoint pt2=pts[ptindex++];
+		rgb_color col=colors[i].GetColor32();
+		
+		drawview->AddLine(pt1,pt2,col);
+		
+	}
+	drawview->EndLineArray();
+	
+	drawview->Sync();
+	screenwin->view->Invalidate();
+
+	framebuffer->Unlock();
+	screenwin->Unlock();
+	Unlock();
+}
+
+
+
+
+
 void ViewDriver::HideCursor(void)
 {
 	screenwin->Lock();
@@ -997,189 +1463,6 @@ void ViewDriver::ShowCursor(void)
 
 }
 
-void ViewDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat)
-{
-	if(!d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeArc(r,angle,span,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(r);
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat)
-{
-	if(!pts)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeBezier(pts,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	
-	// Invalidate the whole view until I get around to adding in the invalid rect calc code
-	screenwin->view->Invalidate();
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokeEllipse(BRect r, LayerData *d, const Pattern &pat)
-{
-	if(!d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeEllipse(r,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(r);
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat)
-{
-	if(!d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeLine(start,end,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(BRect(start,end));
-	framebuffer->Unlock();
-	screenwin->Unlock();
-}
-
-void ViewDriver::StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d)
-{
-	if(!d || numlines==0 || !pts || !colors)
-		return;
-	
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-
-	// Old stand-in for real StrokeLineArray stuff
-/*	int32 ptindex=0;
-	
-	for(int32 i=0; i<numlines; i++)
-	{
-		BPoint pt1=pts[ptindex++];
-		BPoint pt2=pts[ptindex++];
-		rgb_color col=colors[i].GetColor32();
-		
-		drawview->SetHighColor(col);
-		drawview->StrokeLine(pt1,pt2,B_SOLID_HIGH);
-		
-	}
-*/
-
-	int32 ptindex=0;
-
-	drawview->BeginLineArray(numlines);
-	for(int32 i=0; i<numlines; i++)
-	{
-		BPoint pt1=pts[ptindex++];
-		BPoint pt2=pts[ptindex++];
-		rgb_color col=colors[i].GetColor32();
-		
-		drawview->AddLine(pt1,pt2,col);
-		
-	}
-	drawview->EndLineArray();
-	
-	drawview->Sync();
-	screenwin->view->Invalidate();
-
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed)
-{
-	if(!ptlist)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-
-	BRegion invalid;
-
-	SetLayerData(d);
-	drawview->BeginLineArray(numpts+2);
-	for(int i=1;i<numpts;i++)
-	{
-		drawview->AddLine(ptlist[i-1],ptlist[i],d->highcolor.GetColor32());
-		invalid.Include(BRect(ptlist[i-1],ptlist[i]));
-	}
-
-	if(is_closed)
-	{
-		drawview->AddLine(ptlist[numpts-1],ptlist[0],d->highcolor.GetColor32());
-		invalid.Include(BRect(ptlist[numpts-1],ptlist[0]));
-	}
-	drawview->EndLineArray();
-
-	drawview->Sync();
-	screenwin->view->Invalidate(invalid.Frame());
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokeRect(BRect r, LayerData *d, const Pattern &pat)
-{
-	if(!d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeRect(r,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(r);
-	framebuffer->Unlock();
-	screenwin->Unlock();
-}
-
-void ViewDriver::StrokeRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
-{
-	if(!d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	SetLayerData(d);
-	drawview->StrokeRoundRect(r,xrad,yrad,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(r);
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
-void ViewDriver::StrokeTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
-{
-	if(!pts || !d)
-		return;
-	screenwin->Lock();
-	framebuffer->Lock();
-	BPoint first=pts[0],second=pts[1],third=pts[2];
-	SetLayerData(d);
-	drawview->StrokeTriangle(first,second,third,r,*((pattern*)pat.GetInt8()));
-	drawview->Sync();
-	screenwin->view->Invalidate(r);
-	framebuffer->Unlock();
-	screenwin->Unlock();
-
-}
-
 void ViewDriver::SetLayerData(LayerData *d, bool set_font_data)
 {
 	if(!d)

src/servers/app/server/ViewDriver.h

@@ -113,15 +113,6 @@ public:
 //	virtual void DrawPicture(SPicture *pic, BPoint pt);
 	void DrawString(const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *delta=NULL);
 
-	void FillArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	void FillBezier(BPoint *pts, LayerData *d, const Pattern &pat);
-	void FillEllipse(BRect r, LayerData *d, const Pattern &pat);
-	void FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat);
-	void FillRect(BRect r, LayerData *d, const Pattern &pat);
-	void FillRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
-//	void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
-	void FillTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
-
 	void HideCursor(void);
 	void InvertRect(BRect r);
 	bool IsCursorHidden(void);
@@ -135,16 +126,41 @@ public:
 //	void SetDrawingMode(drawing_mode mode);
 	void ShowCursor(void);
 
-	void StrokeArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
+virtual void FillArc(const BRect r, float angle, float span, RGBColor& color);
-	void StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat);
+	virtual void FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
-	void StrokeEllipse(BRect r, LayerData *d, const Pattern &pat);
+	virtual void FillBezier(BPoint *pts, RGBColor& color);
-	void StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat);
+	virtual void FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
-	void StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
+	virtual void FillEllipse(BRect r, RGBColor& color);
-	void StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
+	virtual void FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
-	void StrokeRect(BRect r, LayerData *d, const Pattern &pat);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color);
-	void StrokeRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
+	virtual void FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
-//	void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
+	virtual void FillRect(const BRect r, RGBColor& color);
-	void StrokeTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
+	virtual void FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color);
+	virtual void FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+//	virtual void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
+	virtual void FillTriangle(BPoint *pts, RGBColor& color);
+	virtual void FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color);
+	virtual void StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, RGBColor& color);
+	virtual void StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeEllipse(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color);
+	virtual void StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokePoint(BPoint& pt, RGBColor& color);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed=true);
+	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed=true);
+	virtual void StrokeRect(BRect r, float pensize, RGBColor& color);
+	virtual void StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color);
+	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color);
+//	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
+
+	virtual void StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors);
+
 	void SetMode(int32 mode);
 	float StringWidth(const char *string, int32 length, LayerData *d);
 	float StringHeight(const char *string, int32 length, LayerData *d);