Reduce redundant code in drivers (we can unvirtualize stuff as speed requires after implementation is complete)

Fix some color handling for 15/16 bit.
Implement HLine functions for BitmapDriver.
I forget what I did to Clipper.


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

src/servers/app/server/AccelerantDriver.h

@@ -28,54 +28,13 @@
 #ifndef _ACCELERANTDRIVER_H_
 #define _ACCELERANTDRIVER_H_
 
-#if 0
-#include <Application.h>
-#include <WindowScreen.h>
-#include <View.h>
-#include <GraphicsCard.h>
-#include <Message.h>
-#include <OS.h>
-#include <Locker.h>
-#include <Region.h>	// for clipping_rect definition
-#include <Bitmap.h>
-#endif
 #include <Accelerant.h>
 #include "DisplayDriver.h"
 #include "PatternHandler.h"
 #include "FontServer.h"
-#if 0
-class VDWindow;
-class RGBColor;
-class PortLink;
-#endif
 class ServerBitmap;
 class ServerCursor;
 
-class AccLineCalc
-{
-public:
-	AccLineCalc();
-	AccLineCalc(const BPoint &pta, const BPoint &ptb);
-	void SetPoints(const BPoint &pta, const BPoint &ptb);
-	float GetX(float y);
-	float GetY(float x);
-	float Slope(void) { return slope; }
-	float Offset(void) { return offset; }
-	float MinX();
-	float MinY();
-	float MaxX();
-	float MaxY();
-	void Swap(AccLineCalc &from);
-private:
-	float slope;
-	float offset;
-	BPoint start, end;
-	float minx;
-	float miny;
-	float maxx;
-	float maxy;
-};
-
 class AccelerantDriver : public DisplayDriver
 {
 public:
@@ -90,14 +49,8 @@ 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 FillArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	virtual void FillBezier(BPoint *pts, LayerData *d, const Pattern &pat);
-	virtual void FillEllipse(BRect r, LayerData *d, const Pattern &pat);
-	virtual void FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat);
 	virtual void FillRect(BRect r, LayerData *d, const Pattern &pat);
-	virtual void FillRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
 //	virtual void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
-	virtual void FillTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
 
 	virtual void HideCursor(void);
 	virtual void MoveCursorTo(float x, float y);
@@ -106,15 +59,7 @@ public:
 	virtual void ObscureCursor(void);
 	virtual void SetCursor(ServerCursor *csr);
 
-	virtual void StrokeArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	virtual void StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat);
-	virtual void StrokeEllipse(BRect r, LayerData *d, const Pattern &pat);
-	virtual void StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat);
-	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
-	virtual void StrokeRect(BRect r, LayerData *d, const Pattern &pat);
-	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
 //	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
-	virtual void StrokeTriangle(BPoint *pts, BRect r, 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);

src/servers/app/server/BitmapDriver.h

@@ -79,14 +79,8 @@ 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 FillArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	virtual void FillBezier(BPoint *pts, LayerData *d, const Pattern &pat);
-	virtual void FillEllipse(BRect r, LayerData *d, const Pattern &pat);
-	virtual void FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat);
 	virtual void FillRect(BRect r, LayerData *d, const Pattern &pat);
-	virtual void FillRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
 //	virtual void FillShape(SShape *sh, LayerData *d, const Pattern &pat);
-	virtual void FillTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
 
 	virtual void HideCursor(void);
 	virtual void MoveCursorTo(float x, float y);
@@ -95,15 +89,7 @@ public:
 	virtual void ObscureCursor(void);
 	virtual void SetCursor(ServerCursor *cursor);
 
-	virtual void StrokeArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	virtual void StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat);
-	virtual void StrokeEllipse(BRect r, LayerData *d, const Pattern &pat);
-	virtual void StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat);
-	virtual void StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
-	virtual void StrokeRect(BRect r, LayerData *d, const Pattern &pat);
-	virtual void StrokeRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
 //	virtual void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat);
-	virtual void StrokeTriangle(BPoint *pts, BRect r, 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);

src/servers/app/server/Clipper.cpp

@@ -36,37 +36,37 @@ Clipper::~Clipper()
 {
 }
 
-void Clipper::DrawBitmap(BRegion* clip_reg, BPicture* clip_pic, ServerBitmap *bmp, BRect src, BRect dest, LayerData *d)
+void Clipper::DrawBitmap(BRegion* clip_reg, ServerBitmap *bmp, BRect src, BRect dest, LayerData *d)
 {
 	fDriver->DrawBitmap(bmp,src,dest,d);
 }
 
-void Clipper::DrawString(BRegion* clip_reg, BPicture* clip_pic, const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta)
+void Clipper::DrawString(BRegion* clip_reg, const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta)
 {
 	fDriver->DrawString(string,length,pt,d,edelta);
 }
 
-void Clipper::FillArc(BRegion* clip_reg, BPicture* clip_pic, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
+void Clipper::FillArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
 {
 	fDriver->FillArc(r,angle,span,d,pat);
 }
 
-void Clipper::FillBezier(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, LayerData *d, const Pattern &pat)
+void Clipper::FillBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat)
 {
 	fDriver->FillBezier(pts,d,pat);
 }
 
-void Clipper::FillEllipse(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
 {
 	fDriver->FillEllipse(r,d,pat);
 }
 
-void Clipper::FillPolygon(BRegion* clip_reg, BPicture* clip_pic, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat)
+void Clipper::FillPolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat)
 {
 	fDriver->FillPolygon(ptlist,numpts,rect,d,pat);
 }
 
-void Clipper::FillRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
 {
 	BRegion reg;
 
@@ -76,7 +76,7 @@ void Clipper::FillRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData
 	fDriver->FillRegion(&reg,d,pat);
 }
 
-void Clipper::FillRegion(BRegion* clip_reg, BPicture* clip_pic, BRegion *r, LayerData *d, const Pattern &pat)
+void Clipper::FillRegion(BRegion* clip_reg, BRegion *r, LayerData *d, const Pattern &pat)
 {
 	BRegion reg;
 
@@ -86,9 +86,9 @@ void Clipper::FillRegion(BRegion* clip_reg, BPicture* clip_pic, BRegion *r, Laye
 	fDriver->FillRegion(&reg,d,pat);
 }
 
-void Clipper::FillRoundRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
+void Clipper::FillRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
 {
-	if ( !clip_reg && !clip_pic )
+	if ( !clip_reg )
 		fDriver->FillRoundRect(r,xrad,yrad,d,pat);
 	else
 	{
@@ -103,64 +103,64 @@ void Clipper::FillRoundRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, floa
 		reg.Exclude(corner_rect);
 		corner_rect.OffsetTo(r.right-xrad,r.bottom-yrad);
 		reg.Exclude(corner_rect);
-		FillRegion(clip_reg,clip_pic,&reg,d,pat);
+		FillRegion(clip_reg,&reg,d,pat);
 		arc_rect.OffsetTo(r.left,r.top);
-		FillArc(clip_reg,clip_pic,arc_rect,90,90,d,pat);
+		FillArc(clip_reg,arc_rect,90,90,d,pat);
 		arc_rect.OffsetTo(r.left,r.bottom-2*yrad);
-		FillArc(clip_reg,clip_pic,arc_rect,180,90,d,pat);
+		FillArc(clip_reg,arc_rect,180,90,d,pat);
 		arc_rect.OffsetTo(r.right-2*xrad,r.bottom-2*yrad);
-		FillArc(clip_reg,clip_pic,arc_rect,270,90,d,pat);
+		FillArc(clip_reg,arc_rect,270,90,d,pat);
 		arc_rect.OffsetTo(r.right-2*xrad,r.top);
-		FillArc(clip_reg,clip_pic,arc_rect,0,90,d,pat);
+		FillArc(clip_reg,arc_rect,0,90,d,pat);
 	}
 }
 
-void Clipper::FillTriangle(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::FillTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
 {
 	fDriver->FillTriangle(pts,r,d,pat);
 }
 
-void Clipper::StrokeArc(BRegion* clip_reg, BPicture* clip_pic, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
+void Clipper::StrokeArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeArc(r,angle,span,d,pat);
 }
 
-void Clipper::StrokeBezier(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, LayerData *d, const Pattern &pat)
+void Clipper::StrokeBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeBezier(pts,d,pat);
 }
 
-void Clipper::StrokeEllipse(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeEllipse(r,d,pat);
 }
 
-void Clipper::StrokeLine(BRegion* clip_reg, BPicture* clip_pic, BPoint start, BPoint end, LayerData *d, const Pattern &pat)
+void Clipper::StrokeLine(BRegion* clip_reg, BPoint start, BPoint end, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeLine(start,end,d,pat);
 }
 
-void Clipper::StrokePolygon(BRegion* clip_reg, BPicture* clip_pic, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed)
+void Clipper::StrokePolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed)
 {
 	fDriver->StrokePolygon(ptlist,numpts,rect,d,pat,is_closed);
 }
 
-void Clipper::StrokeRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeRect(r,d,pat);
 }
 
-void Clipper::StrokeRoundRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
+void Clipper::StrokeRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeRoundRect(r,xrad,yrad,d,pat);
 }
 
-void Clipper::StrokeTriangle(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
+void Clipper::StrokeTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat)
 {
 	fDriver->StrokeTriangle(pts,r,d,pat);
 }
 
-void Clipper::StrokeLineArray(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d)
+void Clipper::StrokeLineArray(BRegion* clip_reg, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d)
 {
 	fDriver->StrokeLineArray(pts,numlines,colors,d);
 }

src/servers/app/server/Clipper.h

@@ -38,29 +38,29 @@ public:
 	Clipper(DisplayDriver* driver);
 	~Clipper();
 
-	void DrawBitmap(BRegion* clip_reg, BPicture* clip_pic, ServerBitmap *bmp, BRect src, BRect dest, LayerData *d);
+	void DrawBitmap(BRegion* clip_reg, ServerBitmap *bmp, BRect src, BRect dest, LayerData *d);
-	void DrawString(BRegion* clip_reg, BPicture* clip_pic, const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta=NULL);
+	void DrawString(BRegion* clip_reg, const char *string, int32 length, BPoint pt, LayerData *d, escapement_delta *edelta=NULL);
 
-	void FillArc(BRegion* clip_reg, BPicture* clip_pic, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
+	void FillArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	void FillBezier(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, LayerData *d, const Pattern &pat);
+	void FillBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat);
-	void FillEllipse(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat);
+	void FillEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void FillPolygon(BRegion* clip_reg, BPicture* clip_pic, BPoint *ptlist, int32 numpts, BRect rect, 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, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat);
+	void FillRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void FillRegion(BRegion* clip_reg, BPicture* clip_pic, BRegion* r, LayerData *d, const Pattern &pat);
+	void FillRegion(BRegion* clip_reg, BRegion* r, LayerData *d, const Pattern &pat);
-	void FillRoundRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, float xrad, float yrad, 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, BPicture* clip_pic, SShape *sh, LayerData *d, const Pattern &pat);
+//	void FillShape(BRegion* clip_reg, SShape *sh, LayerData *d, const Pattern &pat);
-	void FillTriangle(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
+	void FillTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
 
-	void StrokeArc(BRegion* clip_reg, BPicture* clip_pic, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
+	void StrokeArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat);
-	void StrokeBezier(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, LayerData *d, const Pattern &pat);
+	void StrokeBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat);
-	void StrokeEllipse(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat);
+	void StrokeEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void StrokeLine(BRegion* clip_reg, BPicture* clip_pic, BPoint start, BPoint end, LayerData *d, const Pattern &pat);
+	void StrokeLine(BRegion* clip_reg, BPoint start, BPoint end, LayerData *d, const Pattern &pat);
-	void StrokePolygon(BRegion* clip_reg, BPicture* clip_pic, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
+	void StrokePolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true);
-	void StrokeRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, LayerData *d, const Pattern &pat);
+	void StrokeRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat);
-	void StrokeRoundRect(BRegion* clip_reg, BPicture* clip_pic, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
+	void StrokeRoundRect(BRegion* clip_reg, BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat);
-//	void StrokeShape(BRegion* clip_reg, BPicture* clip_pic, SShape *sh, LayerData *d, const Pattern &pat);
+//	void StrokeShape(BRegion* clip_reg, SShape *sh, LayerData *d, const Pattern &pat);
-	void StrokeTriangle(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
+	void StrokeTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat);
-	void StrokeLineArray(BRegion* clip_reg, BPicture* clip_pic, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
+	void StrokeLineArray(BRegion* clip_reg, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d);
 private:
 	DisplayDriver* fDriver;
 };

src/servers/app/server/RGBColor.cpp

@@ -121,9 +121,24 @@ uint8 RGBColor::GetColor8(void)
 	return color8;
 }
 
+/*!
+	\brief Returns the color as the closest 15-bit color
+	\return 15-bit value of the current color plus 1-bit alpha
+*/
+uint16 RGBColor::GetColor15(void)
+{
+	if(update15)
+	{
+		color15=FindClosestColor15(color32);
+		update15=false;
+	}
+	
+	return color15;
+}
+
 /*!
 	\brief Returns the color as the closest 16-bit color
-	\return 16-bit value of the current color, including alpha
+	\return 16-bit value of the current color
 */
 uint16 RGBColor::GetColor16(void)
 {