Fixed build

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

src/prefs/appearance/DecView.cpp

@@ -98,7 +98,7 @@ DecView::DecView(BRect frame, const char *name, int32 resize, int32 flags)
 
 
 	// Finish setup
-	ldata.highcolor.SetColor(51,102,160);
+	ldata.SetHighColor(RGBColor(51,102,160));
 	pat_solid_high=0xFFFFFFFFFFFFFFFFLL;
 	driver->FillRect(preview_bounds,&ldata);
 

src/prefs/appearance/PreviewDriver.cpp

@@ -95,42 +95,38 @@ void PVView::Draw(BRect rect)
 
 PreviewDriver::PreviewDriver(void)
 {
-	view=new PVView(preview_bounds);
-	drawview=new BView(preview_bounds,"drawview",B_FOLLOW_ALL, 0);
+	fView=new PVView(preview_bounds);
+	fDrawView=new BView(preview_bounds,"drawview",B_FOLLOW_ALL, 0);
 }
 
 PreviewDriver::~PreviewDriver(void)
 {
-	delete view;
-	delete drawview;
+	delete fView;
+	delete fDrawView;
 }
 
 bool PreviewDriver::Initialize(void)
 {
-	view->viewbmp->Lock();
-	view->viewbmp->AddChild(drawview);
-	view->viewbmp->Unlock();
+	fView->viewbmp->Lock();
+	fView->viewbmp->AddChild(fDrawView);
+	fView->viewbmp->Unlock();
 	return true;
 }
 
 void PreviewDriver::Shutdown(void)
 {
-	view->viewbmp->Lock();
-	view->viewbmp->RemoveChild(drawview);
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::DrawBitmap(ServerBitmap *bmp, const BRect &src, const BRect &dest, const DrawData *d)
-{
+	fView->viewbmp->Lock();
+	fView->viewbmp->RemoveChild(fDrawView);
+	fView->viewbmp->Unlock();
 }
 
 void PreviewDriver::InvertRect(const BRect &r)
 {
-	view->viewbmp->Lock();
-	drawview->InvertRect(r);
-	drawview->Sync();
-	view->Invalidate(r);
-	view->viewbmp->Unlock();
+	fView->viewbmp->Lock();
+	fDrawView->InvertRect(r);
+	fDrawView->Sync();
+	fView->Invalidate(r);
+	fView->viewbmp->Unlock();
 }
 
 void PreviewDriver::StrokeLineArray(const int32 &numlines, const LineArrayData *linedata,
@@ -139,113 +135,20 @@ void PreviewDriver::StrokeLineArray(const int32 &numlines, const LineArrayData *
 	if(!linedata || !d)
 		return;
 	
-	view->viewbmp->Lock();
-	drawview->SetHighColor(d->highcolor.GetColor32());
-	drawview->SetLowColor(d->lowcolor.GetColor32());
-	drawview->SetPenSize(d->pensize);
-	drawview->BeginLineArray(numlines);
+	fView->viewbmp->Lock();
+	fDrawView->SetHighColor(d->HighColor().GetColor32());
+	fDrawView->SetLowColor(d->LowColor().GetColor32());
+	fDrawView->SetPenSize(d->PenSize());
+	fDrawView->BeginLineArray(numlines);
 	for(int32 i=0; i<numlines; i++)
 	{
 		const LineArrayData *data=&(linedata[i]);
-		drawview->AddLine(data->pt1,data->pt2,data->color);
+		fDrawView->AddLine(data->pt1,data->pt2,data->color);
 	}
-	drawview->EndLineArray();
-	drawview->Sync();
-	view->Invalidate();
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::SetMode(const int32 &mode)
-{
-}
-
-void PreviewDriver::SetMode(const display_mode &mode)
-{
-}
-
-void PreviewDriver::FillSolidRect(const BRect &rect, const RGBColor &color)
-{
-	view->viewbmp->Lock();
-	drawview->SetHighColor(color.GetColor32());
-	drawview->FillRect(rect);
-	drawview->Sync();
-	view->Invalidate(rect);
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::FillPatternRect(const BRect &rect, const DrawData *d)
-{
-	if(!d)
-		return;
-	
-	view->viewbmp->Lock();
-	drawview->SetHighColor(d->highcolor.GetColor32());
-	drawview->SetLowColor(d->lowcolor.GetColor32());
-	drawview->FillRect(rect,*((pattern*)d->patt.GetInt8()));
-	drawview->Sync();
-	view->Invalidate(rect);
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::StrokeSolidLine(int32 x1, int32 y1, int32 x2, int32 y2, const RGBColor &color)
-{
-	BPoint start(x1,y1);
-	BPoint end(x2,y2);
-	
-	view->viewbmp->Lock();
-	drawview->SetHighColor(color.GetColor32());
-	drawview->StrokeLine(start,end);
-	drawview->Sync();
-	view->Invalidate(BRect(start,end));
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d)
-{
-	if(!d)
-		return;
-	
-	BPoint start(x1,y1);
-	BPoint end(x2,y2);
-
-	view->viewbmp->Lock();
-	drawview->SetHighColor(d->highcolor.GetColor32());
-	drawview->SetLowColor(d->lowcolor.GetColor32());
-	drawview->StrokeLine(start,end,*((pattern*)d->patt.GetInt8()));
-	drawview->Sync();
-	view->Invalidate(BRect(start,end));
-	view->viewbmp->Unlock();
-}
-
-void PreviewDriver::StrokeSolidRect(const BRect &rect, const RGBColor &color)
-{
-	view->viewbmp->Lock();
-	drawview->SetHighColor(color.GetColor32());
-	drawview->StrokeRect(rect);
-	drawview->Sync();
-	view->Invalidate(rect);
-	view->viewbmp->Unlock();
-}
-
-bool PreviewDriver::AcquireBuffer(FBBitmap *bmp)
-{
-	if(!bmp)
-		return false;
-
-	view->viewbmp->Lock();
-	bmp->SetBuffer(view->viewbmp->Bits());
-	bmp->SetSpace(view->viewbmp->ColorSpace());
-	bmp->SetBytesPerRow(view->viewbmp->BytesPerRow());
-	bmp->SetSize(view->viewbmp->Bounds().IntegerWidth(),
-			view->viewbmp->Bounds().IntegerHeight());
-	bmp->SetBitsPerPixel(view->viewbmp->ColorSpace(),view->viewbmp->BytesPerRow());
-	
-	return true;
-}
-
-void PreviewDriver::ReleaseBuffer(void)
-{
-	view->viewbmp->Unlock();
+	fDrawView->EndLineArray();
+	fDrawView->Sync();
+	fView->Invalidate();
+	fView->viewbmp->Unlock();
 }
 
 bool PreviewDriver::Lock(bigtime_t timeout=B_INFINITE_TIMEOUT)
@@ -256,3 +159,82 @@ bool PreviewDriver::Lock(bigtime_t timeout=B_INFINITE_TIMEOUT)
 void PreviewDriver::Unlock(void)
 {
 }
+
+float
+PreviewDriver::StringWidth(const char *string, int32 length, const DrawData *d)
+{
+	SetDrawData(d,true);
+	fView->viewbmp->Lock();
+	float value=fDrawView->StringWidth(string,length);
+	fView->viewbmp->Unlock();
+	
+	return value;
+}
+
+float
+PreviewDriver::StringWidth(const char *string,int32 length, const ServerFont &font)
+{
+	DrawData d;
+	d.SetFont(font);
+	return StringWidth(string,length,&d);
+}
+
+void
+PreviewDriver::SetDrawData(const DrawData *d, bool set_font_data)
+{
+	if(!d)
+		return;
+	
+	fView->viewbmp->Lock();
+	
+	BRegion reg=*d->ClippingRegion();
+	fDrawView->ConstrainClippingRegion(&reg);
+	
+	fDrawView->SetPenSize(d->PenSize());
+	fDrawView->SetDrawingMode(d->GetDrawingMode());
+	
+	fDrawView->SetHighColor(d->HighColor().GetColor32());
+	fDrawView->SetLowColor(d->LowColor().GetColor32());
+	
+	fDrawView->SetScale(d->Scale());
+	fDrawView->MovePenTo(d->PenLocation());
+	
+	if(set_font_data)
+	{
+		BFont font;
+		const ServerFont *sf=&(d->Font());
+
+		if(!sf)
+			return;
+
+		font.SetFamilyAndStyle(sf->GetFamily(),sf->GetStyle());
+		font.SetFlags(sf->Flags());
+		font.SetEncoding(sf->Encoding());
+		font.SetSize(sf->Size());
+		font.SetRotation(sf->Rotation());
+		font.SetShear(sf->Shear());
+		font.SetSpacing(sf->Spacing());
+		fDrawView->SetFont(&font);
+	}
+	
+	fView->viewbmp->Unlock();
+}
+
+float
+PreviewDriver::StringHeight(const char *string,int32 length,
+							const DrawData *d)
+{
+	SetDrawData(d,true);
+	
+	fView->viewbmp->Lock();
+	
+	font_height fh;
+	
+	fDrawView->GetFontHeight(&fh);
+	
+	float value=fh.ascent+fh.descent+fh.leading;
+	
+	fView->viewbmp->Unlock();
+	
+	return value;
+}

src/prefs/appearance/PreviewDriver.h

@@ -57,43 +57,256 @@ public:
 
 class PreviewDriver : public DisplayDriver
 {
-public:
-	PreviewDriver(void);
-	~PreviewDriver(void);
+ public:
+								PreviewDriver();
+	virtual						~PreviewDriver();
 
-	bool Initialize(void);		// Sets the driver
-	void Shutdown(void);		// You never know when you'll need this
+	// when implementing, be sure to call the inherited version
+	virtual bool				Initialize();
+	virtual void				Shutdown();
+
+	// clipping for all drawing functions
+	virtual	void				ConstrainClippingRegion(BRegion* region) {}
+
+	// Graphics calls implemented in DisplayDriver
+	virtual	void				CopyRegion(		/*const*/ BRegion* region,
+												int32 xOffset,
+												int32 yOffset) {}
+
+	virtual	void				CopyRegionList(	BList* list,
+												BList* pList,
+												int32 rCount,
+												BRegion* clipReg) {}
+
+	virtual void				InvertRect(		const BRect &r);
+
+	virtual	void				DrawBitmap(		BRegion *region,
+												ServerBitmap *bitmap,
+												const BRect &source,
+												const BRect &dest,
+												const DrawData *d) {}
+
+	virtual	void				FillArc(		const BRect &r,
+												const float &angle,
+												const float &span,
+												const DrawData *d) {}
+
+	virtual	void				FillBezier(		BPoint *pts,
+												const DrawData *d) {}
+
+	virtual	void				FillEllipse(	const BRect &r,
+												const DrawData *d) {}
+
+	virtual	void				FillPolygon(	BPoint *ptlist,
+												int32 numpts,
+												const BRect &bounds,
+												const DrawData *d) {}
+
+	virtual	void				FillRect(		const BRect &r,
+												const RGBColor &color) {}
+
+	virtual	void				FillRect(		const BRect &r,
+												const DrawData *d) {}
+
+	virtual	void				FillRegion(		BRegion &r,
+												const DrawData *d) {}
+
+	virtual	void				FillRoundRect(	const BRect &r,
+												const float &xrad,
+												const float &yrad,
+												const DrawData *d) {}
+
+	virtual	void				FillShape(		const BRect &bounds,
+												const int32 &opcount,
+												const int32 *oplist, 
+												const int32 &ptcount,
+												const BPoint *ptlist,
+												const DrawData *d) {}
+
+	virtual	void				FillTriangle(	BPoint *pts,
+												const BRect &bounds,
+												const DrawData *d) {}
+
+	virtual	void				StrokeArc(		const BRect &r,
+												const float &angle,
+												const float &span,
+												const DrawData *d) {}
+
+	virtual	void				StrokeBezier(	BPoint *pts,
+												const DrawData *d) {}
+
+	virtual	void				StrokeEllipse(	const BRect &r,
+												const DrawData *d) {}
+
+	// this version used by Decorator
+	virtual	void				StrokeLine(		const BPoint &start,
+												const BPoint &end,
+												const RGBColor &color) {}
+
+	virtual	void				StrokeLine(		const BPoint &start,
+												const BPoint &end,
+												DrawData *d) {}
+
+	virtual void				StrokeLineArray(const int32 &numlines,
+												const LineArrayData *data,
+												const DrawData *d);
+
+	// this version used by Decorator
+	virtual	void				StrokePoint(	const BPoint &pt,
+												const RGBColor &color) {}
+
+	virtual	void				StrokePoint(	const BPoint &pt,
+												DrawData *d) {}
+
+	virtual	void				StrokePolygon(	BPoint *ptlist,
+												int32 numpts,
+												const BRect &bounds,
+												const DrawData *d,
+												bool is_closed=true) {}
+
+	// this version used by Decorator
+	virtual	void				StrokeRect(		const BRect &r,
+												const RGBColor &color) {}
+
+	virtual	void				StrokeRect(		const BRect &r,
+												const DrawData *d) {}
+
+	virtual	void				StrokeRegion(	BRegion &r,
+												const DrawData *d) {}
+
+	virtual	void				StrokeRoundRect(const BRect &r,
+												const float &xrad,
+												const float &yrad,
+												const DrawData *d) {}
+
+	virtual	void				StrokeShape(	const BRect &bounds,
+												const int32 &opcount,
+												const int32 *oplist, 
+												const int32 &ptcount,
+												const BPoint *ptlist,
+												const DrawData *d) {}
+
+	virtual	void				StrokeTriangle(	BPoint *pts,
+												const BRect &bounds,
+												const DrawData *d) {}
+
+	// Font-related calls
 	
-	// Drawing functions
-	void DrawBitmap(ServerBitmap *bmp, const BRect &src, const BRect &dest, const DrawData *d);
+	// DrawData is NOT const because this call updates the pen position in the passed DrawData
+	virtual	void				DrawString(		const char *string,
+												const int32 &length,
+												const BPoint &pt,
+												DrawData *d) {}
 
-	void InvertRect(const BRect &r);
+	virtual	void				DrawString(		const char *string,
+												const int32 &length,
+												const BPoint &pt,
+												const RGBColor &color,
+												escapement_delta *delta=NULL) {}
 
-	virtual void StrokeLineArray(const int32 &numlines, const LineArrayData *linedata,const DrawData *d);
+	virtual	float				StringWidth(	const char *string,
+												int32 length,
+												const DrawData *d);
 
-	void SetMode(const int32 &mode);
-	void SetMode(const display_mode &mode);
+	virtual	float				StringWidth(	const char *string,
+												int32 length,
+												const ServerFont &font);
+
+	virtual	float				StringHeight(	const char *string,
+												int32 length,
+												const DrawData *d);
+
+	virtual	void				GetBoundingBoxes(const char *string,
+												 int32 count,
+												 font_metric_mode mode, 
+												 escapement_delta *delta,
+												 BRect *rectarray,
+												 const DrawData *d) {}
+
+	virtual	void				GetEscapements(	const char *string,
+												int32 charcount,
+												escapement_delta *delta, 
+												escapement_delta *escapements,
+												escapement_delta *offsets,
+												const DrawData *d) {}
+
+	virtual	void				GetEdges(		const char *string,
+												int32 charcount,
+												edge_info *edgearray,
+												const DrawData *d) {}
+
+	virtual	void				GetHasGlyphs(	const char *string,
+												int32 charcount,
+												bool *hasarray) {}
+
+	virtual	void				GetTruncatedStrings(const char **instrings,
+													const int32 &stringcount,
+													const uint32 &mode, 
+													const float &maxwidth,
+													char **outstrings) {}
 	
-	BView *View(void) { return (BView*)view; };
-	virtual bool Lock(bigtime_t timeout=B_INFINITE_TIMEOUT);
-	virtual void Unlock(void);
+	virtual	void				HideCursor() {}
+	virtual	bool				IsCursorHidden() { return false; }
+	virtual	void				MoveCursorTo(	const float &x,
+												const float &y) {}
+	virtual	void				ShowCursor() {}
+	virtual	void				ObscureCursor() {}
+	virtual	void				SetCursor(ServerCursor *cursor) {}
+	virtual	BPoint				GetCursorPosition() { return BPoint(0,0); }
+	virtual	bool				IsCursorObscured(bool state) { return false; }
+	
+	
+	// Virtual methods which need to be implemented by each subclass
 
-protected:
-	virtual void FillSolidRect(const BRect &rect, const RGBColor &color);
-	virtual void FillPatternRect(const BRect &rect, const DrawData *d);
-	virtual void StrokeSolidLine(int32 x1, int32 y1, int32 x2, int32 y2, const RGBColor &color);
-	virtual void StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d);
-	virtual void StrokeSolidRect(const BRect &rect, const RGBColor &color);
+	// These two will rarely be implemented by subclasses,
+	// but it still needs to be possible
+	virtual bool				Lock(bigtime_t timeout = B_INFINITE_TIMEOUT);
+	virtual void				Unlock();
 
-	virtual bool AcquireBuffer(FBBitmap *bmp);
-	virtual void ReleaseBuffer(void);
+	// display mode access
+	virtual void				SetMode(const display_mode &mode) {}
+	virtual	void				GetMode(display_mode *mode) {}
+			const display_mode*	DisplayMode()
+									{ return &fDisplayMode; }
+	
+	virtual bool				DumpToFile(const char *path) { return false; }
+	virtual ServerBitmap*		DumpToBitmap() { return NULL; }
 
-	BBitmap *framebuffer;
-	BView *drawview;
+	virtual status_t			SetDPMSMode(const uint32 &state) { return B_ERROR; }
+	virtual uint32				DPMSMode() { return 0; }
+	virtual uint32				DPMSCapabilities() { return 0; }
+	virtual status_t			GetDeviceInfo(accelerant_device_info *info) { return B_ERROR; }
 
-	// Region used to track of invalid areas for the Begin/EndLineArray functions
-	BRegion laregion;
-	PVView *view;
+	virtual status_t			GetModeList(display_mode **mode_list,
+											uint32 *count) { return B_ERROR; }
+
+	virtual status_t			GetPixelClockLimits(display_mode *mode,
+													uint32 *low,
+													uint32 *high) { return B_ERROR; }
+
+	virtual status_t			GetTimingConstraints(display_timing_constraints *dtc) { return B_ERROR; }
+	virtual status_t			ProposeMode(display_mode *candidate,
+											const display_mode *low,
+											const display_mode *high) { return B_ERROR; }
+
+	virtual status_t			WaitForRetrace(bigtime_t timeout = B_INFINITE_TIMEOUT) { return B_ERROR; }
+	
+			// This is only for the PreviewDriver
+			BView *				View(void) { return (BView*)fView; };
+
+ protected:
+			void				SetDrawData(const DrawData *d, 
+											bool set_font_data);
+			
+			display_mode		fDisplayMode;
+			
+			BBitmap 			*fFramebuffer;
+			BView 				*fDrawView;
+			
+			// Region used to track of invalid areas for the 
+			// Begin/EndLineArray functions
+			BRegion				fArrayRegion;
+			PVView 				*fView;
 };
 
 extern BRect preview_bounds;