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.cpp

@@ -39,13 +39,7 @@
 #include <unistd.h>
 
 #define RUN_UNDER_R5
-
+#define DRAW_TEST
-#define CLIP_X(a) ( (a < 0) ? 0 : ((a > mDisplayMode.virtual_width-1) ? \
-			mDisplayMode.virtual_width-1 : a) )
-#define CLIP_Y(a) ( (a < 0) ? 0 : ((a > mDisplayMode.virtual_height-1) ? \
-			mDisplayMode.virtual_height-1 : a) )
-#define CHECK_X(a) ( (a >= 0) || (a <= mDisplayMode.virtual_width-1) )
-#define CHECK_Y(a) ( (a >= 0) || (a <= mDisplayMode.virtual_height-1) )
 
 /* TODO: Add handling of draw modes */
 
@@ -185,6 +179,12 @@ bool AccelerantDriver::Initialize(void)
 	accMoveCursor = (move_cursor)accelerant_hook(B_MOVE_CURSOR,NULL);
 	accShowCursor = (show_cursor)accelerant_hook(B_SHOW_CURSOR,NULL);
 
+#ifdef DRAW_TEST
+	RGBColor red(255,0,0,0);
+	RGBColor green(0,255,0,0);
+	RGBColor blue(0,0,255,0);
+	FillRect(BRect(0,0,1024,768),blue);
+#endif
 	return true;
 }
 
@@ -399,161 +399,351 @@ void AccelerantDriver::DrawString(const char *string, int32 length, BPoint pt, L
 	Unlock();
 }
 
+
+void AccelerantDriver::FillArc(const BRect r, float angle, float span, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::FillArc(r,angle,span,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillArc(r,angle,span,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillBezier(BPoint *pts, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::FillBezier(pts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillBezier(pts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillEllipse(BRect r, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::FillEllipse(r,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillEllipse(r,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::FillPolygon(ptlist,numpts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillPolygon(ptlist,numpts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillRect(const BRect r, RGBColor& color)
+{
+	Lock();
+	fDrawColor = color;
+	FillSolidRect((int32)r.left,(int32)r.top,(int32)r.right,(int32)r.bottom);
+	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 d Data structure containing any other data necessary for the call. Always non-NULL.
+	\param pattern The pattern to be used when filling the rectangle
-	\param pat 8-byte array containing the pattern to use. Always non-NULL.
+	\param high_color The high color of the pattern to fill
-
+	\param low_color  The low color of the pattern to fill
 */
-void AccelerantDriver::FillRect(BRect r, LayerData *d, const Pattern &pattern)
+void AccelerantDriver::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
 {
 	Lock();
-	const int8 *pat=pattern.GetInt8();
+	fDrawPattern.SetTarget(pattern);
-#ifndef DISABLE_HARDWARE_ACCELERATION
+	fDrawPattern.SetColors(high_color,low_color);
-	if ( accFillRect && AcquireEngine && (((uint8)*pat == 0xFF) || (*pat == 0)) )
+	FillPatternRect((int32)r.left,(int32)r.top,(int32)r.right,(int32)r.bottom);
+	Unlock();
+}
+
+void AccelerantDriver::FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color)
 {
-		bool solidColor = true;
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	fDrawColor = color;
+	DisplayDriver::FillRoundRect(r,xrad,yrad,this,(SetRectangleFuncType)&AccelerantDriver::FillSolidRect,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillRoundRect(BRect r, float xrad, float yrad, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillRoundRect(r,xrad,yrad,this,(SetRectangleFuncType)&AccelerantDriver::FillPatternRect,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillTriangle(BPoint *pts, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::FillTriangle(pts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::FillTriangle(pts,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeArc(r,angle,span,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeArc(r,angle,span,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeBezier(BPoint *pts, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeBezier(pts,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeBezier(pts,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeEllipse(BRect r, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeEllipse(r,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeEllipse(r,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeLine(start,end,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeLine(start,end,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokePoint(BPoint& pt, RGBColor& color)
+{
+	Lock();
+	fLineThickness = 1;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	SetThickPatternPixel((int)pt.x,(int)pt.y);
+	Unlock();
+}
+
+void AccelerantDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokePolygon(ptlist,numpts,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel,is_closed);
+	Unlock();
+}
+
+void AccelerantDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokePolygon(ptlist,numpts,this,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeRect(BRect r, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeRect(r,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick,(SetVerticalLineFuncType)&AccelerantDriver::VLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeRect(r,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick,(SetVerticalLineFuncType)&AccelerantDriver::VLinePatternThick);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, RGBColor& color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	fDrawPattern.SetColors(color,color);
+	DisplayDriver::StrokeRoundRect(r,xrad,yrad,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick,(SetVerticalLineFuncType)&AccelerantDriver::VLinePatternThick,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	Unlock();
+}
+
+void AccelerantDriver::StrokeRoundRect(BRect r, float xrad, float yrad, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color)
+{
+	Lock();
+	fLineThickness = (int)pensize;
+	fDrawPattern.SetTarget(pattern);
+	fDrawPattern.SetColors(high_color,low_color);
+	DisplayDriver::StrokeRoundRect(r,xrad,yrad,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick,(SetVerticalLineFuncType)&AccelerantDriver::VLinePatternThick,(SetPixelFuncType)&AccelerantDriver::SetThickPatternPixel);
+	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 AccelerantDriver::StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors)
+{
+	int x1, y1, x2, y2, dx, dy;
+	int steps, k;
+	double xInc, yInc;
+	double x,y;
 	int i;
-		for (i=1; i<8; i++)
+
-			if ( pat[i] != pat[i-1] )
+	Lock();
-				solidColor = false;
+	fLineThickness = (int)pensize;
-		if ( solidColor && (AcquireEngine(0,0,NULL,&mEngineToken) == B_OK) )
+	fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH);
+	for (i=0; i<numlines; i++)
 	{
-			fill_rect_params fillParams;
+		//fDrawColor = colors[i];
-			uint32 color=0;
+		fDrawPattern.SetColors(colors[i],colors[i]);
-			fillParams.right = (uint16)r.right;
+		x1 = ROUND(pts[i*2].x);
-			fillParams.left = (uint16)r.left;
+		y1 = ROUND(pts[i*2].y);
-			fillParams.top = (uint16)r.top;
+		x2 = ROUND(pts[i*2+1].x);
-			fillParams.bottom = (uint16)r.bottom;
+		y2 = ROUND(pts[i*2+1].y);
-			if ( (uint8)*pat == 0xFF )
+		dx = x2-x1;
-			{
+		dy = y2-y1;
-				switch (mDisplayMode.space)
+		x = x1;
-				{
+		y = y1;
-					case B_CMAP8:
+		if ( abs(dx) > abs(dy) )
-					case B_GRAY8:
+			steps = abs(dx);
-						color = d->highcolor.GetColor8();
-						break;
-					case B_RGB16_BIG:
-					case B_RGB16_LITTLE:
-					case B_RGB15_BIG:
-					case B_RGBA15_BIG:
-					case B_RGB15_LITTLE:
-					case B_RGBA15_LITTLE:
-						color = d->highcolor.GetColor16();
-						break;
-					case B_RGB32_BIG:
-					case B_RGBA32_BIG:
-					case B_RGB32_LITTLE:
-					case B_RGBA32_LITTLE:
-					{
-						rgb_color rgbcolor = d->highcolor.GetColor32();
-						color = (rgbcolor.alpha << 24) | (rgbcolor.red << 16) | (rgbcolor.green << 8) | (rgbcolor.blue);
-					}
-						break;
-				}
-			}
 		else
-			{
+			steps = abs(dy);
-				switch (mDisplayMode.space)
+		xInc = dx / (double) steps;
-				{
+		yInc = dy / (double) steps;
-					case B_CMAP8:
-					case B_GRAY8:
-						color = d->lowcolor.GetColor8();
-						break;
-					case B_RGB16_BIG:
-					case B_RGB16_LITTLE:
-					case B_RGB15_BIG:
-					case B_RGBA15_BIG:
-					case B_RGB15_LITTLE:
-					case B_RGBA15_LITTLE:
-						color = d->lowcolor.GetColor16();
-						break;
-					case B_RGB32_BIG:
-					case B_RGBA32_BIG:
-					case B_RGB32_LITTLE:
-					case B_RGBA32_LITTLE:
-					{
-						rgb_color rgbcolor = d->lowcolor.GetColor32();
-						color = (rgbcolor.alpha << 24) | (rgbcolor.red << 16) | (rgbcolor.green << 8) | (rgbcolor.blue);
-					}
-						break;
-				}
-			}
-			accFillRect(mEngineToken, color, &fillParams, 1);
-			if ( ReleaseEngine )
-				ReleaseEngine(mEngineToken,NULL);
-			Unlock();
-			return;
-		}
-	}
-#endif
 
-	PatternHandler pathandler(pattern);
+		SetThickPatternPixel(ROUND(x),ROUND(y));
-	pathandler.SetColors(d->highcolor, d->lowcolor);
+		for (k=0; k<steps; k++)
-
-	switch (mDisplayMode.space)
 		{
-		case B_CMAP8:
+			x += xInc;
-		case B_GRAY8:
+			y += yInc;
-			{
+			SetThickPatternPixel(ROUND(x),ROUND(y));
-				uint8 *fb = (uint8 *)mFrameBufferConfig.frame_buffer + (int)r.top*mFrameBufferConfig.bytes_per_row;
-				int x,y;
-				for (y=(int)r.top; y<=(int)r.bottom; y++)
-				{
-					for (x=(int)r.left; x<=r.right; x++)
-					{
-						fb[x] = pathandler.GetColor(x,y).GetColor8();
 		}
-					fb += mFrameBufferConfig.bytes_per_row;
 	}
-			} break;
-		case B_RGB16_BIG:
-		case B_RGB16_LITTLE:
-		case B_RGB15_BIG:
-		case B_RGBA15_BIG:
-		case B_RGB15_LITTLE:
-		case B_RGBA15_LITTLE:
-			{
-				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + (int)r.top*mFrameBufferConfig.bytes_per_row);
-				int x,y;
-				for (y=(int)r.top; y<=(int)r.bottom; y++)
-				{
-					for (x=(int)r.left; x<=r.right; x++)
-					{
-						fb[x] = pathandler.GetColor(x,y).GetColor16();
-					}
-					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
-				}
-			} break;
-		case B_RGB32_BIG:
-		case B_RGBA32_BIG:
-		case B_RGB32_LITTLE:
-		case B_RGBA32_LITTLE:
-			{
-				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + (int)r.top*mFrameBufferConfig.bytes_per_row);
-				int x,y;
-				rgb_color color;
-				for (y=(int)r.top; y<=(int)r.bottom; y++)
-				{
-					for (x=(int)r.left; x<=r.right; x++)
-					{
-						color = pathandler.GetColor(x,y).GetColor32();
-						fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue);
-					}
-					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
-				}
-			} break;
-		default:
-			printf("Error: Unknown color space\n");
-	}
-
 	Unlock();
 }
 
-//void AccelerantDriver::FillShape(SShape *sh, LayerData *d, const Pattern &pat)
+
-//{
-//}
 
 /*!
 	\brief Hides the cursor.
@@ -821,28 +1011,6 @@ void AccelerantDriver::SetCursor(ServerCursor *csr)
 	Unlock();
 }
 
-//void AccelerantDriver::StrokeShape(SShape *sh, LayerData *d, const Pattern &pat)
-//{
-//}
-
-/*!
-	\brief Draws a series of lines - optimized for speed
-	\param pts Array of BPoints pairs
-	\param numlines Number of lines to be drawn
-	\param colors Array of colors for each respective line
-	\param d Data structure containing any other data necessary for the call. Always non-NULL.
-	
-	Data for this call is passed directly from userland - this call is responsible for all
-	checking. All lines are to be processed in the call using the same LayerData settings
-	for each line.
-*/
-void AccelerantDriver::StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d)
-{
-	Lock();
-	
-	Unlock();
-}
-
 /*!
 	\brief Sets the screen mode to specified resolution and color depth.
 	\param mode constant as defined in GraphicsDefs.h
@@ -1135,6 +1303,7 @@ void AccelerantDriver::GetTruncatedStrings( const char **instrings, int32 string
 	\param y The y coordinate (guaranteed to be in bounds)
 	\param col The color to draw
 */
+/*
 void AccelerantDriver::SetPixel(int x, int y, RGBColor col)
 {
 	switch (mDisplayMode.space)
@@ -1168,24 +1337,20 @@ void AccelerantDriver::SetPixel(int x, int y, RGBColor col)
 			printf("Error: Unknown color space\n");
 	}
 }
+*/
 
 /*!
-	\brief Draws a point of a specified thickness
+	\brief Draws a point using the display driver's specified thickness and pattern
 	\param x The x coordinate (not guaranteed to be in bounds)
 	\param y The y coordinate (not guaranteed to be in bounds)
-	\param thick The thickness of the point
-	\param pat The PatternHandler which detemines pixel colors
 */
-void AccelerantDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pat)
+void AccelerantDriver::SetThickPatternPixel(int x, int y)
 {
-	if ( (!CHECK_X(x-thick/2) && !CHECK_X(x+thick/2)) ||
-		(!CHECK_Y(y-thick/2) && !CHECK_Y(y+thick/2)) )
-		return;
 	int left, right, top, bottom;
-	left = CLIP_X(x-thick/2);
+	left = x - fLineThickness/2;
-	right = CLIP_X(x+thick/2);
+	right = x + fLineThickness/2;
-	top = CLIP_Y(y-thick/2);
+	top = y - fLineThickness/2;
-	bottom = CLIP_Y(y+thick/2);
+	bottom = y + fLineThickness/2;
 	switch (mDisplayMode.space)
 	{
 		case B_CMAP8:
@@ -1196,14 +1361,10 @@ void AccelerantDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pa
 				for (y=top; y<=bottom; y++)
 				{
 					for (x=left; x<=right; x++)
-					{
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor8();;
-						fb[x] = pat->GetColor(x,y).GetColor8();;
-					}
 					fb += mFrameBufferConfig.bytes_per_row;
 				}
 			} break;
-		case B_RGB16_BIG:
-		case B_RGB16_LITTLE:
 		case B_RGB15_BIG:
 		case B_RGBA15_BIG:
 		case B_RGB15_LITTLE:
@@ -1214,9 +1375,19 @@ void AccelerantDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pa
 				for (y=top; y<=bottom; y++)
 				{
 					for (x=left; x<=right; x++)
-					{
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor15();
-						fb[x] = pat->GetColor(x,y).GetColor16();
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
 				}
+			} break;
+		case B_RGB16_BIG:
+		case B_RGB16_LITTLE:
+			{
+				int x,y;
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor16();
 					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
 				}
 			} break;
@@ -1232,7 +1403,7 @@ void AccelerantDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pa
 				{
 					for (x=left; x<=right; x++)
 					{
-						color = pat->GetColor(x,y).GetColor32();
+						color = fDrawPattern.GetColor(x,y).GetColor32();
 						fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue);
 					}
 					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
@@ -1250,9 +1421,9 @@ void AccelerantDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pa
 	\param y The y coordinate (guaranteed to be in bounds)
 	\param pat The PatternHandler which detemines pixel colors
 */
+/*
 void AccelerantDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat)
 {
-	/* TODO: Add hardware acceleration */
 	int x;
 	if ( x1 > x2 )
 	{
@@ -1302,18 +1473,16 @@ void AccelerantDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat)
 			printf("Error: Unknown color space\n");
 	}
 }
+*/
 
 /*!
-	\brief Draws a horizontal line
+	\brief Draws a horizontal line using the display driver's line thickness and pattern
 	\param x1 The first x coordinate (not guaranteed to be in bounds)
 	\param x2 The second x coordinate (not guaranteed to be in bounds)
 	\param y The y coordinate (not guaranteed to be in bounds)
-	\param thick The thickness of the line
-	\param pat The PatternHandler which detemines pixel colors
 */
-void AccelerantDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat)
+void AccelerantDriver::HLinePatternThick(int32 x1, int32 x2, int32 y)
 {
-	/* TODO: Add hardware acceleration */
 	int x, y1, y2;
 
 	if ( x1 > x2 )
@@ -1322,14 +1491,8 @@ void AccelerantDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, Patt
 		x2 = x1;
 		x1 = x;
 	}
-	y1 = y-thick/2;
+	y1 = y - fLineThickness/2;
-	y2 = y+thick/2;
+	y2 = y + fLineThickness/2;
-	if ( (x2 < 0) || (x1 >= mDisplayMode.virtual_width) || (!CHECK_Y(y1) && !CHECK_Y(y2)) )
-		return;
-	x1 = CLIP_X(x1);
-	x2 = CLIP_X(x2);
-	y1 = CLIP_Y(y1);
-	y2 = CLIP_Y(y2);
 	switch (mDisplayMode.space)
 	{
 		case B_CMAP8:
@@ -1339,7 +1502,7 @@ void AccelerantDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, Patt
 				for (y=y1; y<=y2; y++)
 				{
 					for (x=x1; x<=x2; x++)
-						fb[x] = pat->GetColor(x,y).GetColor8();
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor8();
 					fb += mFrameBufferConfig.bytes_per_row;
 				}
 			} break;
@@ -1348,22 +1511,22 @@ void AccelerantDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, Patt
 		case B_RGB15_LITTLE:
 		case B_RGBA15_LITTLE:
 			{
-				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y*mFrameBufferConfig.bytes_per_row);
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
 				for (y=y1; y<=y2; y++)
 				{
 					for (x=x1; x<=x2; x++)
-						fb[x] = pat->GetColor(x,y).GetColor15();
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor15();
 					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
 				}
 			} break;
 		case B_RGB16_BIG:
 		case B_RGB16_LITTLE:
 			{
-				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y*mFrameBufferConfig.bytes_per_row);
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
 				for (y=y1; y<=y2; y++)
 				{
 					for (x=x1; x<=x2; x++)
-						fb[x] = pat->GetColor(x,y).GetColor16();
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor16();
 					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
 				}
 			} break;
@@ -1372,13 +1535,267 @@ void AccelerantDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, Patt
 		case B_RGB32_LITTLE:
 		case B_RGBA32_LITTLE:
 			{
-				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + y*mFrameBufferConfig.bytes_per_row);
+				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
 				rgb_color color;
 				for (y=y1; y<=y2; y++)
 				{
 					for (x=x1; x<=x2; x++)
 					{
-						color = pat->GetColor(x,y).GetColor32();
+						color = fDrawPattern.GetColor(x,y).GetColor32();
+						fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue);
+					}
+					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		default:
+			printf("Error: Unknown color space\n");
+	}
+}
+
+/*!
+	\brief Draws a vertical line using the display driver's line thickness and pattern
+	\param x The x coordinate
+	\param y1 The first y coordinate
+	\param y2 The second y coordinate
+*/
+void AccelerantDriver::VLinePatternThick(int32 x, int32 y1, int32 y2)
+{
+	int y, x1, x2;
+
+	if ( y1 > y2 )
+	{
+		y = y2;
+		y2 = y1;
+		y1 = y;
+	}
+	x1 = x - fLineThickness/2;
+	x2 = x + fLineThickness/2;
+	switch (mDisplayMode.space)
+	{
+		case B_CMAP8:
+		case B_GRAY8:
+			{
+				uint8 *fb = (uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row;
+				for (y=y1; y<=y2; y++)
+				{
+					for (x=x1; x<=x2; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor8();
+					fb += mFrameBufferConfig.bytes_per_row;
+				}
+			} break;
+		case B_RGB15_BIG:
+		case B_RGBA15_BIG:
+		case B_RGB15_LITTLE:
+		case B_RGBA15_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
+				for (y=y1; y<=y2; y++)
+				{
+					for (x=x1; x<=x2; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor15();
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB16_BIG:
+		case B_RGB16_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
+				for (y=y1; y<=y2; y++)
+				{
+					for (x=x1; x<=x2; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor16();
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB32_BIG:
+		case B_RGBA32_BIG:
+		case B_RGB32_LITTLE:
+		case B_RGBA32_LITTLE:
+			{
+				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + y1*mFrameBufferConfig.bytes_per_row);
+				rgb_color color;
+				for (y=y1; y<=y2; y++)
+				{
+					for (x=x1; x<=x2; x++)
+					{
+						color = fDrawPattern.GetColor(x,y).GetColor32();
+						fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue);
+					}
+					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		default:
+			printf("Error: Unknown color space\n");
+	}
+}
+
+void AccelerantDriver::FillSolidRect(int32 left, int32 top, int32 right, int32 bottom)
+{
+#ifndef DISABLE_HARDWARE_ACCELERATION
+	if ( accFillRect && AcquireEngine )
+	{
+		if ( AcquireEngine(0,0,NULL,&mEngineToken) == B_OK )
+		{
+			fill_rect_params fillParams;
+			uint32 fill_color=0;
+			fillParams.right = (uint16)right;
+			fillParams.left = (uint16)left;
+			fillParams.top = (uint16)top;
+			fillParams.bottom = (uint16)bottom;
+			switch (mDisplayMode.space)
+			{
+				case B_CMAP8:
+				case B_GRAY8:
+					fill_color = fDrawColor.GetColor8();
+					break;
+				case B_RGB15_BIG:
+				case B_RGBA15_BIG:
+				case B_RGB15_LITTLE:
+				case B_RGBA15_LITTLE:
+					fill_color = fDrawColor.GetColor15();
+					break;
+				case B_RGB16_BIG:
+				case B_RGB16_LITTLE:
+					fill_color = fDrawColor.GetColor16();
+					break;
+				case B_RGB32_BIG:
+				case B_RGBA32_BIG:
+				case B_RGB32_LITTLE:
+				case B_RGBA32_LITTLE:
+				{
+					rgb_color rgbcolor = fDrawColor.GetColor32();
+					fill_color = (rgbcolor.alpha << 24) | (rgbcolor.red << 16) | (rgbcolor.green << 8) | (rgbcolor.blue);
+				}
+					break;
+			}
+			accFillRect(mEngineToken, fill_color, &fillParams, 1);
+			if ( ReleaseEngine )
+				ReleaseEngine(mEngineToken,NULL);
+			Unlock();
+			return;
+		}
+	}
+#endif
+
+	switch (mDisplayMode.space)
+	{
+		case B_CMAP8:
+		case B_GRAY8:
+			{
+				uint8 *fb = (uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row;
+				uint8 color8 = fDrawColor.GetColor8();
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = color8;
+					fb += mFrameBufferConfig.bytes_per_row;
+				}
+			} break;
+		case B_RGB15_BIG:
+		case B_RGBA15_BIG:
+		case B_RGB15_LITTLE:
+		case B_RGBA15_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				uint16 color15 = fDrawColor.GetColor15();
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = color15;
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB16_BIG:
+		case B_RGB16_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				uint16 color16 = fDrawColor.GetColor16();
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = color16;
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB32_BIG:
+		case B_RGBA32_BIG:
+		case B_RGB32_LITTLE:
+		case B_RGBA32_LITTLE:
+			{
+				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				rgb_color fill_color = fDrawColor.GetColor32();
+				uint32 color32 = (fill_color.alpha << 24) | (fill_color.red << 16) | (fill_color.green << 8) | (fill_color.blue);
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = color32;
+					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		default:
+			printf("Error: Unknown color space\n");
+	}
+}
+
+void AccelerantDriver::FillPatternRect(int32 left, int32 top, int32 right, int32 bottom)
+{
+	switch (mDisplayMode.space)
+	{
+		case B_CMAP8:
+		case B_GRAY8:
+			{
+				uint8 *fb = (uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row;
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor8();
+					fb += mFrameBufferConfig.bytes_per_row;
+				}
+			} break;
+		case B_RGB15_BIG:
+		case B_RGBA15_BIG:
+		case B_RGB15_LITTLE:
+		case B_RGBA15_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor15();
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB16_BIG:
+		case B_RGB16_LITTLE:
+			{
+				uint16 *fb = (uint16 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				int x,y;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+						fb[x] = fDrawPattern.GetColor(x,y).GetColor16();
+					fb = (uint16 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
+				}
+			} break;
+		case B_RGB32_BIG:
+		case B_RGBA32_BIG:
+		case B_RGB32_LITTLE:
+		case B_RGBA32_LITTLE:
+			{
+				uint32 *fb = (uint32 *)((uint8 *)mFrameBufferConfig.frame_buffer + top*mFrameBufferConfig.bytes_per_row);
+				int x,y;
+				rgb_color color;
+				for (y=top; y<=bottom; y++)
+				{
+					for (x=left; x<=right; x++)
+					{
+						color = fDrawPattern.GetColor(x,y).GetColor32();
 						fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue);
 					}
 					fb = (uint32 *)((uint8 *)fb + mFrameBufferConfig.bytes_per_row);
@@ -1938,12 +2355,14 @@ int AccelerantDriver::GetDepthFromColorspace(int space)
 		case B_GRAY8:
 			depth = 8;
 			break;
-		case B_RGB16:
 		case B_RGB15:
 		case B_RGBA15:
-		case B_RGB16_BIG:
 		case B_RGB15_BIG:
 		case B_RGBA15_BIG:
+			depth = 15;
+			break;
+		case B_RGB16:
+		case B_RGB16_BIG:
 			depth = 16;
 			break;
 		case B_RGB32:

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)
+{
+	fDriver->FillEllipse(r,color);
+}
+
+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);
-	if ( clip_reg )
 		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)
+{
+	if ( clip_reg )
 	{
 		BRegion reg;
-
+		reg.Set(r);
-	reg = *r;
-	if ( clip_reg )
 		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.cpp

@@ -153,47 +153,47 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 			{
 				BPoint start = GetCoord();
 				BPoint end = GetCoord();
-				fdriver->StrokeLine(start,end,&fldata,stipplepat);
+				fdriver->StrokeLine(start,end,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_STROKE_RECT:
 			{
 				BRect rect = GetRect();
-				fdriver->StrokeRect(rect,&fldata,stipplepat);
+				fdriver->StrokeRect(rect,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_FILL_RECT:
 			{
 				BRect rect = GetRect();
-				fdriver->FillRect(rect,&fldata,stipplepat);
+				fdriver->FillRect(rect,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_STROKE_ROUND_RECT:
 			{
 				BRect rect = GetRect();
 				BPoint radii = GetCoord();
-				fdriver->StrokeRoundRect(rect,radii.x,radii.y,&fldata,stipplepat);
+				fdriver->StrokeRoundRect(rect,radii.x,radii.y,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_FILL_ROUND_RECT:
 			{
 				BRect rect = GetRect();
 				BPoint radii = GetCoord();
-				fdriver->FillRoundRect(rect,radii.x,radii.y,&fldata,stipplepat);
+				fdriver->FillRoundRect(rect,radii.x,radii.y,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_STROKE_BEZIER:
 			{
 				BPoint control[4];
 				GetData(control, sizeof(control));
-				fdriver->StrokeBezier(control,&fldata,stipplepat);
+				fdriver->StrokeBezier(control,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_FILL_BEZIER:
 			{
 				BPoint control[4];
 				GetData(control, sizeof(control));
-				fdriver->FillBezier(control,&fldata,stipplepat);
+				fdriver->FillBezier(control,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_STROKE_POLYGON:
@@ -202,7 +202,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				BPoint *points = new BPoint[numPoints];
 				GetData(points, numPoints * sizeof(BPoint));
 				bool isClosed = GetBool();
-				fdriver->StrokePolygon(points,numPoints,BRect(0,0,0,0),&fldata,stipplepat,isClosed);
+				fdriver->StrokePolygon(points,numPoints,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor,isClosed);
 				delete points;
 				break;
 			}
@@ -211,7 +211,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				int32 numPoints = GetInt32();
 				BPoint *points = new BPoint[numPoints];
 				GetData(points, numPoints * sizeof(BPoint));
-				fdriver->FillPolygon(points,numPoints,BRect(0,0,0,0),&fldata,stipplepat);
+				fdriver->FillPolygon(points,numPoints,stipplepat,fldata.highcolor,fldata.lowcolor);
 				delete points;
 				break;
 			}
@@ -268,7 +268,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				float startTheta = GetFloat();
 				float arcTheta = GetFloat();
 				fdriver->StrokeArc(BRect(center.x-radii.x,center.y-radii.y,center.x+radii.x,
-						center.y+radii.y),startTheta, arcTheta, &fldata,stipplepat);
+						center.y+radii.y),startTheta, arcTheta, fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_FILL_ARC:
@@ -278,7 +278,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				float startTheta = GetFloat();
 				float arcTheta = GetFloat();
 				fdriver->FillArc(BRect(center.x-radii.x,center.y-radii.y,center.x+radii.x,
-						center.y+radii.y),startTheta, arcTheta, &fldata,stipplepat);
+						center.y+radii.y),startTheta, arcTheta, stipplepat, fldata.highcolor, fldata.lowcolor);
 				break;
 			}
 			case B_PIC_STROKE_ELLIPSE:
@@ -287,7 +287,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				BPoint center;
 				BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f);
 				center = rect.LeftTop() + radii;
-				fdriver->StrokeEllipse(rect,&fldata,stipplepat);
+				fdriver->StrokeEllipse(rect,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_FILL_ELLIPSE:
@@ -296,7 +296,7 @@ status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d)
 				BPoint center;
 				BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f);
 				center = rect.LeftTop() + radii;
-				fdriver->FillEllipse(rect,&fldata,stipplepat);
+				fdriver->FillEllipse(rect,stipplepat,fldata.highcolor,fldata.lowcolor);
 				break;
 			}
 			case B_PIC_ENTER_STATE_CHANGE:

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->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::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, LayerData *d, const Pattern &pat)
+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);