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

Begin transfering implementations to the new API functions

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@6836 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
shadow303 2004-03-01 02:21:14 +00:00
parent 52c2367204
commit f0446088b3
5 changed files with 280 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
src/servers/app/server/AccelerantDriver.cpp
View File

@ -82,7 +82,7 @@ AccelerantDriver::~AccelerantDriver(void)
*/ */
bool AccelerantDriver::Initialize(void) bool AccelerantDriver::Initialize(void)
{ {
/* int i; int i;
char signature[1024]; char signature[1024];
char path[PATH_MAX]; char path[PATH_MAX];
struct stat accelerant_stat; struct stat accelerant_stat;
@ -154,12 +154,7 @@ bool AccelerantDriver::Initialize(void)
return false; return false;
if ( GetDisplayMode(&mDisplayMode) != B_OK ) if ( GetDisplayMode(&mDisplayMode) != B_OK )
return false; return false;
_SetDepth(GetDepthFromColorspace(mDisplayMode.space)); SetMode(mDisplayMode);
_SetWidth(mDisplayMode.virtual_width);
_SetHeight(mDisplayMode.virtual_height);
_SetMode(GetModeFromResolution(mDisplayMode.virtual_width,mDisplayMode.virtual_height,
GetDepthFromColorspace(mDisplayMode.space)));
memcpy(&R5DisplayMode,&mDisplayMode,sizeof(display_mode)); memcpy(&R5DisplayMode,&mDisplayMode,sizeof(display_mode));
#else #else
SetMode(B_8_BIT_640x480); SetMode(B_8_BIT_640x480);
@ -187,7 +182,6 @@ bool AccelerantDriver::Initialize(void)
FillRect(BRect(0,0,1024,768),blue); FillRect(BRect(0,0,1024,768),blue);
#endif #endif
*/
return true; return true;
} }
@ -199,7 +193,6 @@ bool AccelerantDriver::Initialize(void)
*/ */
void AccelerantDriver::Shutdown(void) void AccelerantDriver::Shutdown(void)
{ {
/*
#ifdef RUN_UNDER_R5 #ifdef RUN_UNDER_R5
set_display_mode SetDisplayMode = (set_display_mode)accelerant_hook(B_SET_DISPLAY_MODE, NULL); set_display_mode SetDisplayMode = (set_display_mode)accelerant_hook(B_SET_DISPLAY_MODE, NULL);
if ( SetDisplayMode ) if ( SetDisplayMode )
@ -212,7 +205,6 @@ void AccelerantDriver::Shutdown(void)
unload_add_on(accelerant_image); unload_add_on(accelerant_image);
if (card_fd >= 0) if (card_fd >= 0)
close(card_fd); close(card_fd);
*/
} }
/*! /*!
@ -1522,3 +1514,140 @@ int AccelerantDriver::GetDepthFromColorspace(int space)
} }
return depth; return depth;
} }
void AccelerantDriver::Blit(const BRect &src, const BRect &dest, const DrawData *d)
{
}
void AccelerantDriver::FillSolidRect(const BRect &rect, RGBColor &color)
{
}
void AccelerantDriver::FillPatternRect(const BRect &rect, const DrawData *d)
{
}
void AccelerantDriver::StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color)
{
}
void AccelerantDriver::StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d)
{
int32 dx = x2 - x1;
int32 dy = y2 - y1;
int32 steps, k;
double xInc, yInc;
double x = x1;
double y = y1;
if ( abs(dx) > abs(dy) )
steps = abs(dx);
else
steps = abs(dy);
xInc = dx / (double) steps;
yInc = dy / (double) steps;
//(driver->*setPixel)(ROUND(x),ROUND(y));
for (k=0; k<steps; k++)
{
x += xInc;
y += yInc;
//(driver->*setPixel)(ROUND(x),ROUND(y));
}
}
void AccelerantDriver::StrokeSolidRect(const BRect &rect, RGBColor &color)
{
}
void AccelerantDriver::CopyBitmap(ServerBitmap *bitmap, const BRect &source, const BRect &dest, const DrawData *d)
{
}
void AccelerantDriver::CopyToBitmap(ServerBitmap *destbmp, const BRect &sourcerect)
{
/*
if(!destbmp)
{
printf("CopyToBitmap returned - not init or NULL bitmap\n");
return;
}
if(((uint32)destbmp->ColorSpace() & 0x000F) != (_displaymode.space & 0x000F))
{
printf("CopyToBitmap returned - unequal buffer pixel depth\n");
return;
}
BRect destrect(destbmp->Bounds()), source(sourcerect);
uint8 colorspace_size=destbmp->BitsPerPixel()/8;
// First, clip source rect to destination
if(source.Width() > destrect.Width())
source.right=source.left+destrect.Width();
if(source.Height() > destrect.Height())
source.bottom=source.top+destrect.Height();
// Second, check rectangle bounds against their own bitmaps
BRect work_rect(destbmp->Bounds());
if( !(work_rect.Contains(destrect)) )
{
// something in selection must be clipped
if(destrect.left < 0)
destrect.left = 0;
if(destrect.right > work_rect.right)
destrect.right = work_rect.right;
if(destrect.top < 0)
destrect.top = 0;
if(destrect.bottom > work_rect.bottom)
destrect.bottom = work_rect.bottom;
}
work_rect.Set(0,0,_displaymode.virtual_width-1,_displaymode.virtual_height-1);
if(!work_rect.Contains(sourcerect))
return;
if( !(work_rect.Contains(source)) )
{
// something in selection must be clipped
if(source.left < 0)
source.left = 0;
if(source.right > work_rect.right)
source.right = work_rect.right;
if(source.top < 0)
source.top = 0;
if(source.bottom > work_rect.bottom)
source.bottom = work_rect.bottom;
}
// Set pointers to the actual data
uint8 *dest_bits = (uint8*) destbmp->Bits();
uint8 *src_bits = (uint8*) _target->Bits();
// Get row widths for offset looping
uint32 dest_width = uint32 (destbmp->BytesPerRow());
uint32 src_width = uint32 (_target->BytesPerRow());
// Offset bitmap pointers to proper spot in each bitmap
src_bits += uint32 ( (source.top * src_width) + (source.left * colorspace_size) );
dest_bits += uint32 ( (destrect.top * dest_width) + (destrect.left * colorspace_size) );
uint32 line_length = uint32 ((destrect.right - destrect.left+1)*colorspace_size);
uint32 lines = uint32 (source.bottom-source.top+1);
for (uint32 pos_y=0; pos_y<lines; pos_y++)
{
memcpy(dest_bits,src_bits,line_length);
// Increment offsets
src_bits += src_width;
dest_bits += dest_width;
}
*/
}

11
src/servers/app/server/AccelerantDriver.h
View File

@ -84,6 +84,17 @@ protected:
int GetHeightFromMode(int mode); int GetHeightFromMode(int mode);
int GetDepthFromMode(int mode); int GetDepthFromMode(int mode);
int GetDepthFromColorspace(int space); int GetDepthFromColorspace(int space);
// Support functions for the rest of the driver
void Blit(const BRect &src, const BRect &dest, const DrawData *d);
void FillSolidRect(const BRect &rect, RGBColor &color);
void FillPatternRect(const BRect &rect, const DrawData *d);
void StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color);
void StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d);
void StrokeSolidRect(const BRect &rect, RGBColor &color);
void CopyBitmap(ServerBitmap *bitmap, const BRect &source, const BRect &dest, const DrawData *d);
void CopyToBitmap(ServerBitmap *target, const BRect &source);
ServerCursor *cursor, *under_cursor; ServerCursor *cursor, *under_cursor;
BRect cursorframe; BRect cursorframe;

2
src/servers/app/server/BitmapDriver.cpp
View File

@ -762,7 +762,7 @@ void BitmapDriver::StrokeSolidLine(const BPoint &start, const BPoint &end, RGBCo
{ {
} }
void BitmapDriver::StrokePatternLine(const BPoint &start, const BPoint &end, const DrawData *d) void BitmapDriver::StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d)
{ {
} }

2
src/servers/app/server/BitmapDriver.h
View File

@ -84,7 +84,7 @@ protected:
virtual void FillSolidRect(const BRect &rect, RGBColor &color); virtual void FillSolidRect(const BRect &rect, RGBColor &color);
virtual void FillPatternRect(const BRect &rect, const DrawData *d); virtual void FillPatternRect(const BRect &rect, const DrawData *d);
virtual void StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color); virtual void StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color);
virtual void StrokePatternLine(const BPoint &start, const BPoint &end, const DrawData *d); virtual void StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d);
virtual void StrokeSolidRect(const BRect &rect, RGBColor &color); virtual void StrokeSolidRect(const BRect &rect, RGBColor &color);
virtual void CopyBitmap(ServerBitmap *bitmap, const BRect &source, const BRect &dest, const DrawData *d); virtual void CopyBitmap(ServerBitmap *bitmap, const BRect &source, const BRect &dest, const DrawData *d);
virtual void CopyToBitmap(ServerBitmap *target, const BRect &source); virtual void CopyToBitmap(ServerBitmap *target, const BRect &source);

310
src/servers/app/server/DisplayDriver.cpp
View File

@ -34,11 +34,9 @@
#include "RectUtils.h" #include "RectUtils.h"
#include "ServerCursor.h" #include "ServerCursor.h"
// TODO: Major cleanup is left. Public functions should be repsonsible for locking. // TODO: Remove remnants of old API. Inplement all functions. Bounds checking needs to be
// Clean the locking code from the protected functions. Remove bounds checking stuff // handled by the public drawing functions.
// since clipper must handle all needed boundary checks (otherwise we could have windows // Add clipping and make sure public functions have Lock & Unlock.
// bleeding into other windows).
// TODO: Add pixel, line, and rect functions for handling all of the options from LayerData
LineCalc::LineCalc() LineCalc::LineCalc()
{ {
@ -849,20 +847,15 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
{ {
} }
void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &span, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::FillArc calls \brief Called for all BView::FillArc calls
\param r Rectangle enclosing the entire arc \param r Rectangle enclosing the entire arc
\param angle Starting angle for the arc in degrees \param angle Starting angle for the arc in degrees
\param span Span of the arc in degrees. Ending angle = angle+span. \param span Span of the arc in degrees. Ending angle = angle+span.
\param setLIne The horizontal line drawing function which handles needed things like pattern, \param d Object holding the bazillion other options
color, and line thickness
*/ */
void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &span,
DisplayDriver* driver, SetHorizontalLineFuncType setLine) void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &span, const DrawData *d)
{ {
float xc = (r.left+r.right)/2; float xc = (r.left+r.right)/2;
float yc = (r.top+r.bottom)/2; float yc = (r.top+r.bottom)/2;
@ -883,12 +876,11 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
int startQuad, endQuad; int startQuad, endQuad;
bool useQuad1, useQuad2, useQuad3, useQuad4; bool useQuad1, useQuad2, useQuad3, useQuad4;
bool shortspan = false; bool shortspan = false;
//BPoint center(xc,yc);
// Watch out for bozos giving us whacko spans // Watch out for bozos giving us whacko spans
if ( (span >= 360) || (span <= -360) ) if ( (span >= 360) || (span <= -360) )
{ {
FillEllipse(r,driver,setLine); FillEllipse(r,d);
return; return;
} }
@ -939,27 +931,13 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
} }
if ( useQuad1 ) if ( useQuad1 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
if ( useQuad2 ) if ( useQuad2 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc-x),ROUND(yc-y),d);
if ( useQuad3 ) if ( useQuad3 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc-x),ROUND(yc+y),d);
if ( useQuad4 ) if ( useQuad4 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
/*
if ( (!shortspan && (((startQuad == 1) && (x <= startx)) || ((endQuad == 1) && (x >= endx)))) ||
(shortspan && (startQuad == 1) && (x <= startx) && (x >= endx)) )
StrokeLine(BPoint(xc+x,yc-y),center,d,pat);
if ( (!shortspan && (((startQuad == 2) && (x >= startx)) || ((endQuad == 2) && (x <= endx)))) ||
(shortspan && (startQuad == 2) && (x >= startx) && (x <= endx)) )
StrokeLine(BPoint(xc-x,yc-y),center,d,pat);
if ( (!shortspan && (((startQuad == 3) && (x <= startx)) || ((endQuad == 3) && (x >= endx)))) ||
(shortspan && (startQuad == 3) && (x <= startx) && (x >= endx)) )
StrokeLine(BPoint(xc-x,yc+y),center,d,pat);
if ( (!shortspan && (((startQuad == 4) && (x >= startx)) || ((endQuad == 4) && (x <= endx)))) ||
(shortspan && (startQuad == 4) && (x >= startx) && (x <= endx)) )
StrokeLine(BPoint(xc+x,yc+y),center,d,pat);
*/
p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2)); p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2));
while (px < py) while (px < py)
@ -976,23 +954,23 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
} }
if ( useQuad1 ) if ( useQuad1 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
if ( useQuad2 ) if ( useQuad2 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc-x),ROUND(yc-y),d);
if ( useQuad3 ) if ( useQuad3 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc-x),ROUND(yc+y),d);
if ( useQuad4 ) if ( useQuad4 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
if ( !shortspan ) if ( !shortspan )
{ {
if ( startQuad == 1 ) if ( startQuad == 1 )
{ {
if ( x <= startx ) if ( x <= startx )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
else else
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+xclip),ROUND(yc-y),d);
} }
} }
else if ( startQuad == 2 ) else if ( startQuad == 2 )
@ -1000,17 +978,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= startx ) if ( x >= startx )
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc-xclip),ROUND(yc-y),d);
} }
} }
else if ( startQuad == 3 ) else if ( startQuad == 3 )
{ {
if ( x <= startx ) if ( x <= startx )
(driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc),ROUND(yc+y),d);
else else
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc+y)); StrokePatternLine(ROUND(xc-xclip),ROUND(yc+y),ROUND(xc),ROUND(yc+y),d);
} }
} }
else if ( startQuad == 4 ) else if ( startQuad == 4 )
@ -1018,7 +996,7 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= startx ) if ( x >= startx )
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc+xclip),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
} }
} }
@ -1027,17 +1005,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= endx ) if ( x >= endx )
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc+xclip),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
} }
} }
else if ( endQuad == 2 ) else if ( endQuad == 2 )
{ {
if ( x <= endx ) if ( x <= endx )
(driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc),ROUND(yc-y),d);
else else
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc-y)); StrokePatternLine(ROUND(xc-xclip),ROUND(yc-y),ROUND(xc),ROUND(yc-y),d);
} }
} }
else if ( endQuad == 3 ) else if ( endQuad == 3 )
@ -1045,17 +1023,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= endx ) if ( x >= endx )
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc-xclip),ROUND(yc+y),d);
} }
} }
else if ( endQuad == 4 ) else if ( endQuad == 4 )
{ {
if ( x <= endx ) if ( x <= endx )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
else else
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+xclip),ROUND(yc+y),d);
} }
} }
} }
@ -1066,30 +1044,30 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( startQuad == 1 ) if ( startQuad == 1 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc+endclip),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc+endclip),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
else else
(driver->*setLine)(ROUND(xc+endclip),ROUND(xc+startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc+endclip),ROUND(yc-y),ROUND(xc+startclip),ROUND(yc-y),d);
} }
else if ( startQuad == 2 ) else if ( startQuad == 2 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc-x),ROUND(xc-startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc-startclip),ROUND(yc-y),d);
else else
(driver->*setLine)(ROUND(xc-endclip),ROUND(xc-startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-endclip),ROUND(yc-y),ROUND(xc-startclip),ROUND(yc-y),d);
} }
else if ( startQuad == 3 ) else if ( startQuad == 3 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc-x),ROUND(xc-endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc-endclip),ROUND(yc+y),d);
else else
(driver->*setLine)(ROUND(xc-startclip),ROUND(xc-endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-startclip),ROUND(yc+y),ROUND(xc-endclip),ROUND(yc+y),d);
} }
else if ( startQuad == 4 ) else if ( startQuad == 4 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc+startclip),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc+startclip),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
else else
(driver->*setLine)(ROUND(xc+startclip),ROUND(xc+endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc+startclip),ROUND(yc+y),ROUND(xc+endclip),ROUND(yc+y),d);
} }
} }
} }
@ -1109,23 +1087,23 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
} }
if ( useQuad1 ) if ( useQuad1 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
if ( useQuad2 ) if ( useQuad2 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc-x),ROUND(yc-y),d);
if ( useQuad3 ) if ( useQuad3 )
(driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc-x),ROUND(yc+y),d);
if ( useQuad4 ) if ( useQuad4 )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
if ( !shortspan ) if ( !shortspan )
{ {
if ( startQuad == 1 ) if ( startQuad == 1 )
{ {
if ( x <= startx ) if ( x <= startx )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
else else
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc+xclip),ROUND(yc-y),d);
} }
} }
else if ( startQuad == 2 ) else if ( startQuad == 2 )
@ -1133,17 +1111,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= startx ) if ( x >= startx )
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc-xclip),ROUND(yc-y),d);
} }
} }
else if ( startQuad == 3 ) else if ( startQuad == 3 )
{ {
if ( x <= startx ) if ( x <= startx )
(driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc),ROUND(yc+y),d);
else else
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc+y)); StrokePatternLine(ROUND(xc-xclip),ROUND(yc+y),ROUND(xc),ROUND(yc+y),d);
} }
} }
else if ( startQuad == 4 ) else if ( startQuad == 4 )
@ -1151,7 +1129,7 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= startx ) if ( x >= startx )
{ {
xclip = ROUND(y*startx/(double)starty); xclip = ROUND(y*startx/(double)starty);
(driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc+xclip),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
} }
} }
@ -1160,17 +1138,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= endx ) if ( x >= endx )
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc+xclip),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
} }
} }
else if ( endQuad == 2 ) else if ( endQuad == 2 )
{ {
if ( x <= endx ) if ( x <= endx )
(driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc),ROUND(yc-y),d);
else else
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc-y)); StrokePatternLine(ROUND(xc-xclip),ROUND(yc-y),ROUND(xc),ROUND(yc-y),d);
} }
} }
else if ( endQuad == 3 ) else if ( endQuad == 3 )
@ -1178,17 +1156,17 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( x >= endx ) if ( x >= endx )
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc-xclip),ROUND(yc+y),d);
} }
} }
else if ( endQuad == 4 ) else if ( endQuad == 4 )
{ {
if ( x <= endx ) if ( x <= endx )
(driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
else else
{ {
xclip = ROUND(y*endx/(double)endy); xclip = ROUND(y*endx/(double)endy);
(driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc+xclip),ROUND(yc+y),d);
} }
} }
} }
@ -1199,34 +1177,35 @@ void DisplayDriver::FillArc(const BRect &r, const float &angle, const float &spa
if ( startQuad == 1 ) if ( startQuad == 1 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc+endclip),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc+endclip),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
else else
(driver->*setLine)(ROUND(xc+endclip),ROUND(xc+startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc+endclip),ROUND(yc-y),ROUND(xc+startclip),ROUND(yc-y),d);
} }
else if ( startQuad == 2 ) else if ( startQuad == 2 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc-x),ROUND(xc-startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc-startclip),ROUND(yc-y),d);
else else
(driver->*setLine)(ROUND(xc-endclip),ROUND(xc-startclip),ROUND(yc-y)); StrokePatternLine(ROUND(xc-endclip),ROUND(yc-y),ROUND(xc-startclip),ROUND(yc-y),d);
} }
else if ( startQuad == 3 ) else if ( startQuad == 3 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc-x),ROUND(xc-endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc-endclip),ROUND(yc+y),d);
else else
(driver->*setLine)(ROUND(xc-startclip),ROUND(xc-endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc-startclip),ROUND(yc+y),ROUND(xc-endclip),ROUND(yc+y),d);
} }
else if ( startQuad == 4 ) else if ( startQuad == 4 )
{ {
if ( (x <= startx) && (x >= endx) ) if ( (x <= startx) && (x >= endx) )
(driver->*setLine)(ROUND(xc+startclip),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc+startclip),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
else else
(driver->*setLine)(ROUND(xc+startclip),ROUND(xc+endclip),ROUND(yc+y)); StrokePatternLine(ROUND(xc+startclip),ROUND(yc+y),ROUND(xc+endclip),ROUND(yc+y),d);
} }
} }
} }
Unlock(); Unlock();
} }
void DisplayDriver::FillBezier(BPoint *pts, RGBColor &color) void DisplayDriver::FillBezier(BPoint *pts, RGBColor &color)
@ -1321,16 +1300,13 @@ void DisplayDriver::FillEllipse(const BRect &r, RGBColor &color)
{ {
} }
void DisplayDriver::FillEllipse(const BRect &r, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::FillEllipse calls \brief Called for all BView::FillEllipse calls
\param r BRect enclosing the ellipse to be drawn. \param r BRect enclosing the ellipse to be drawn.
\param setLine Horizontal line drawing routine which handles things like color and pattern. \param d DrawData containing the endless options
*/ */
void DisplayDriver::FillEllipse(const BRect &r, DisplayDriver* driver, SetHorizontalLineFuncType setLine)
void DisplayDriver::FillEllipse(const BRect &r, const DrawData *d)
{ {
float xc = (r.left+r.right)/2; float xc = (r.left+r.right)/2;
float yc = (r.top+r.bottom)/2; float yc = (r.top+r.bottom)/2;
@ -1348,10 +1324,8 @@ void DisplayDriver::FillEllipse(const BRect &r, DisplayDriver* driver, SetHorizo
Lock(); Lock();
//SetPixel(ROUND(xc),ROUND(yc-y),pattern.GetColor(xc,yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc-y),ROUND(xc),ROUND(yc-y),d);
(driver->*setLine)(ROUND(xc),ROUND(xc),ROUND(yc-y)); StrokePatternLine(ROUND(xc),ROUND(yc+y),ROUND(xc),ROUND(yc+y),d);
//SetPixel(ROUND(xc),ROUND(yc+y),pattern.GetColor(xc,yc+y));
(driver->*setLine)(ROUND(xc),ROUND(xc),ROUND(yc+y));
p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2)); p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2));
while (px < py) while (px < py)
@ -1367,8 +1341,8 @@ void DisplayDriver::FillEllipse(const BRect &r, DisplayDriver* driver, SetHorizo
p += Ry2 + px - py; p += Ry2 + px - py;
} }
(driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
(driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
} }
p = ROUND(Ry2*(x+.5)*(x+.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2); p = ROUND(Ry2*(x+.5)*(x+.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2);
@ -1385,8 +1359,8 @@ void DisplayDriver::FillEllipse(const BRect &r, DisplayDriver* driver, SetHorizo
p += Rx2 - py +px; p += Rx2 - py +px;
} }
(driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc-y)); StrokePatternLine(ROUND(xc-x),ROUND(yc-y),ROUND(xc+x),ROUND(yc-y),d);
(driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc+y)); StrokePatternLine(ROUND(xc-x),ROUND(yc+y),ROUND(xc+x),ROUND(yc+y),d);
} }
Unlock(); Unlock();
} }
@ -1395,20 +1369,13 @@ void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor &color)
{ {
} }
void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::FillPolygon calls \brief Called for all BView::FillPolygon calls
\param ptlist Array of BPoints defining the polygon. \param ptlist Array of BPoints defining the polygon.
\param numpts Number of points in the BPoint array. \param numpts Number of points in the BPoint array.
\param setLine Horizontal line drawing routine which handles things like color and pattern. \param d The 50 bazillion drawing options (inluding clip region)
The points in the array are not guaranteed to be within the framebuffer's
coordinate range.
*/ */
void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, DisplayDriver* driver, SetHorizontalLineFuncType setLine) void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, const DrawData *d)
{ {
/* Here's the plan. Record all line segments in polygon. If a line segments crosses /* Here's the plan. Record all line segments in polygon. If a line segments crosses
the y-value of a point not in the segment, split the segment into 2 segments. the y-value of a point not in the segment, split the segment into 2 segments.
@ -1508,16 +1475,16 @@ void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, DisplayDriver* dri
{ {
if ( (segmentArray[i].MinX() < _displaymode.virtual_width) && if ( (segmentArray[i].MinX() < _displaymode.virtual_width) &&
(segmentArray[i].MaxX() >= 0) ) (segmentArray[i].MaxX() >= 0) )
(driver->*setLine)(ROUND(segmentArray[i].MinX()), StrokePatternLine(ROUND(segmentArray[i].MinX()), y,
ROUND(segmentArray[i].MaxX()), y); ROUND(segmentArray[i].MaxX()), y, d);
i++; i++;
} }
else else
{ {
if ( (segmentArray[i].GetX(y) < _displaymode.virtual_width) && if ( (segmentArray[i].GetX(y) < _displaymode.virtual_width) &&
(segmentArray[i+1].GetX(y) >= 0) ) (segmentArray[i+1].GetX(y) >= 0) )
(driver->*setLine)(ROUND(segmentArray[i].GetX(y)), StrokePatternLine(ROUND(segmentArray[i].GetX(y)), y,
ROUND(segmentArray[i+1].GetX(y)), y); ROUND(segmentArray[i+1].GetX(y)), y, d);
i+=2; i+=2;
} }
} }
@ -1591,19 +1558,14 @@ void DisplayDriver::FillRoundRect(const BRect &r, const float &xrad, const float
{ {
} }
void DisplayDriver::FillRoundRect(const BRect &r, const float &xrad, const float &yrad, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::FillRoundRect calls \brief Called for all BView::FillRoundRect calls
\param r The rectangle itself \param r The rectangle itself
\param xrad X radius of the corner arcs \param xrad X radius of the corner arcs
\param yrad Y radius of the corner arcs \param yrad Y radius of the corner arcs
\param setRect Rectangle filling routine which handles things like color and pattern \param d DrawData containing all other options
\param setLine Horizontal line drawing function which handles things like color and pattern
*/ */
void DisplayDriver::FillRoundRect(const BRect &r, const float &xrad, const float &yrad, DisplayDriver* driver, SetRectangleFuncType setRect, SetHorizontalLineFuncType setLine) void DisplayDriver::FillRoundRect(const BRect &r, const float &xrad, const float &yrad, const DrawData *d)
{ {
float arc_x; float arc_x;
float yrad2 = yrad*yrad; float yrad2 = yrad*yrad;
@ -1612,12 +1574,13 @@ void DisplayDriver::FillRoundRect(const BRect &r, const float &xrad, const float
for (i=0; i<=(int)yrad; i++) for (i=0; i<=(int)yrad; i++)
{ {
arc_x = xrad*sqrt(1-i*i/yrad2); arc_x = xrad*sqrt(1-i*i/yrad2);
(driver->*setLine)(ROUND(r.left+xrad-arc_x), ROUND(r.right-xrad+arc_x), StrokePatternLine(ROUND(r.left+xrad-arc_x), ROUND(r.top+yrad-i),
ROUND(r.top+yrad-i)); ROUND(r.right-xrad+arc_x), ROUND(r.top+yrad-i),d);
(driver->*setLine)(ROUND(r.left+xrad-arc_x), ROUND(r.right-xrad+arc_x), StrokePatternLine(ROUND(r.left+xrad-arc_x), ROUND(r.bottom-yrad+i),
ROUND(r.bottom-yrad+i)); ROUND(r.right-xrad+arc_x), ROUND(r.bottom-yrad+i),d);
} }
(driver->*setRect)((int)(r.left),(int)(r.top+yrad),(int)(r.right),(int)(r.bottom-yrad)); FillPatternRect(BRect(r.left,r.top+yrad,r.right,r.bottom-yrad),d);
} }
//void DisplayDriver::FillShape(SShape *sh, const DrawData *d, const Pattern &pat) //void DisplayDriver::FillShape(SShape *sh, const DrawData *d, const Pattern &pat)
@ -1628,16 +1591,12 @@ void DisplayDriver::FillTriangle(BPoint *pts, RGBColor &color)
{ {
} }
void DisplayDriver::FillTriangle(BPoint *pts, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::FillTriangle calls \brief Called for all BView::FillTriangle calls
\param pts Array of 3 BPoints. Always non-NULL. \param pts Array of 3 BPoints. Always non-NULL.
\param setLine Horizontal line drawing routine which handles things like color and pattern. \param setLine Horizontal line drawing routine which handles things like color and pattern.
*/ */
void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizontalLineFuncType setLine) void DisplayDriver::FillTriangle(BPoint *pts, const DrawData *d)
{ {
if ( !pts ) if ( !pts )
return; return;
@ -1686,7 +1645,7 @@ void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizont
end.y=first.y; end.y=first.y;
start.x=MIN(first.x,MIN(second.x,third.x)); start.x=MIN(first.x,MIN(second.x,third.x));
end.x=MAX(first.x,MAX(second.x,third.x)); end.x=MAX(first.x,MAX(second.x,third.x));
(driver->*setLine)(ROUND(start.x), ROUND(end.x), ROUND(start.y)); StrokePatternLine(ROUND(start.x), ROUND(start.y), ROUND(end.x), ROUND(start.y), d);
return; return;
} }
@ -1698,9 +1657,9 @@ void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizont
LineCalc lineA(first, third); LineCalc lineA(first, third);
LineCalc lineB(second, third); LineCalc lineB(second, third);
(driver->*setLine)(ROUND(first.x), ROUND(second.x), ROUND(first.y)); StrokePatternLine(ROUND(first.x), ROUND(first.y), ROUND(second.x), ROUND(first.y), d);
for(i=(int32)first.y+1; i<=third.y; i++) for(i=(int32)first.y+1; i<=third.y; i++)
(driver->*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); StrokePatternLine(ROUND(lineA.GetX(i)), i, ROUND(lineB.GetX(i)), i, d);
return; return;
} }
@ -1710,9 +1669,9 @@ void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizont
LineCalc lineA(first, second); LineCalc lineA(first, second);
LineCalc lineB(first, third); LineCalc lineB(first, third);
(driver->*setLine)(ROUND(second.x), ROUND(third.x), ROUND(second.y)); StrokePatternLine(ROUND(second.x), ROUND(second.y), ROUND(third.x), ROUND(second.y), d);
for(i=(int32)first.y; i<third.y; i++) for(i=(int32)first.y; i<third.y; i++)
(driver->*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); StrokePatternLine(ROUND(lineA.GetX(i)), i, ROUND(lineB.GetX(i)), i, d);
return; return;
} }
@ -1722,10 +1681,11 @@ void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizont
LineCalc lineC(second, third); LineCalc lineC(second, third);
for(i=(int32)first.y; i<(int32)second.y; i++) for(i=(int32)first.y; i<(int32)second.y; i++)
(driver->*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); StrokePatternLine(ROUND(lineA.GetX(i)), i, ROUND(lineB.GetX(i)), i, d);
for(i=(int32)second.y; i<=third.y; i++) for(i=(int32)second.y; i<=third.y; i++)
(driver->*setLine)(ROUND(lineC.GetX(i)), ROUND(lineB.GetX(i)), i); StrokePatternLine(ROUND(lineC.GetX(i)), i, ROUND(lineB.GetX(i)), i, d);
} }
/*! /*!
@ -2236,7 +2196,8 @@ void DisplayDriver::StrokeEllipse(const BRect &r, DisplayDriver* driver, SetPixe
void DisplayDriver::StrokeLine(const BPoint &start, const BPoint &end, RGBColor &color) void DisplayDriver::StrokeLine(const BPoint &start, const BPoint &end, RGBColor &color)
{ {
Lock(); Lock();
StrokeSolidLine(start,end,color); //Not quite that simple bub
//StrokeSolidLine(start,end,color);
Unlock(); Unlock();
} }
@ -2289,23 +2250,12 @@ void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, RGBColor &color,
return; return;
Lock(); Lock();
/*
for(int32 i=0; i<(numpts-1); i++) for(int32 i=0; i<(numpts-1); i++)
StrokeSolidLine(ptlist[i],ptlist[i+1],color); StrokeSolidLine(ptlist[i],ptlist[i+1],color);
if(is_closed) if(is_closed)
StrokeSolidLine(ptlist[numpts-1],ptlist[0],color); StrokeSolidLine(ptlist[numpts-1],ptlist[0],color);
Unlock(); */
}
void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, const DrawData *d, bool is_closed)
{
if(!ptlist)
return;
Lock();
for(int32 i=0; i<(numpts-1); i++)
StrokePatternLine(ptlist[i],ptlist[i+1],d);
if(is_closed)
StrokePatternLine(ptlist[numpts-1],ptlist[0],d);
Unlock(); Unlock();
} }
@ -2313,14 +2263,19 @@ void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, const DrawData *
\brief Called for all BView::StrokePolygon calls \brief Called for all BView::StrokePolygon calls
\param ptlist Array of BPoints defining the polygon. \param ptlist Array of BPoints defining the polygon.
\param numpts Number of points in the BPoint array. \param numpts Number of points in the BPoint array.
\param setPixel Pixel drawing function which handles things like size and pattern. \param d DrawData containing all of the other options
*/ */
void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, DisplayDriver* driver, SetPixelFuncType setPixel, bool is_closed) void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, const DrawData *d, bool is_closed)
{ {
if(!ptlist)
return;
Lock();
for(int32 i=0; i<(numpts-1); i++) for(int32 i=0; i<(numpts-1); i++)
StrokeLine(ptlist[i],ptlist[i+1],driver,setPixel); StrokeLine(ptlist[i],ptlist[i+1],d);
if(is_closed) if(is_closed)
StrokeLine(ptlist[numpts-1],ptlist[0],driver,setPixel); StrokeLine(ptlist[numpts-1],ptlist[0],d);
Unlock();
} }
/*! /*!
@ -2339,21 +2294,13 @@ void DisplayDriver::StrokeRect(const BRect &r, RGBColor &color)
void DisplayDriver::StrokeRect(const BRect &r, const DrawData *d) void DisplayDriver::StrokeRect(const BRect &r, const DrawData *d)
{ {
Lock(); Lock();
StrokePatternLine(r.LeftTop(),r.RightTop(),d); StrokeLine(r.LeftTop(),r.RightTop(),d);
StrokePatternLine(r.LeftTop(),r.LeftBottom(),d); StrokeLine(r.LeftTop(),r.LeftBottom(),d);
StrokePatternLine(r.RightTop(),r.RightBottom(),d); StrokeLine(r.RightTop(),r.RightBottom(),d);
StrokePatternLine(r.LeftBottom(),r.RightBottom(),d); StrokeLine(r.LeftBottom(),r.RightBottom(),d);
Unlock(); Unlock();
} }
void DisplayDriver::StrokeRect(const BRect &r, DisplayDriver* driver, SetHorizontalLineFuncType setHLine, SetVerticalLineFuncType setVLine)
{
(driver->*setHLine)((int)ROUND(r.left), (int)ROUND(r.right), (int)ROUND(r.top));
(driver->*setVLine)((int)ROUND(r.right), (int)ROUND(r.top), (int)ROUND(r.bottom));
(driver->*setHLine)((int)ROUND(r.left), (int)ROUND(r.right), (int)ROUND(r.bottom));
(driver->*setVLine)((int)ROUND(r.left), (int)ROUND(r.top), (int)ROUND(r.bottom));
}
/*! /*!
\brief Convenience function for server use \brief Convenience function for server use
\param r BRegion to be stroked \param r BRegion to be stroked
@ -2385,20 +2332,14 @@ void DisplayDriver::StrokeRoundRect(const BRect &r, const float &xrad, const flo
{ {
} }
void DisplayDriver::StrokeRoundRect(const BRect &r, const float &xrad, const float &yrad, const DrawData *d)
{
}
/*! /*!
\brief Called for all BView::StrokeRoundRect calls \brief Called for all BView::StrokeRoundRect calls
\param r The rect itself \param r The rect itself
\param xrad X radius of the corner arcs \param xrad X radius of the corner arcs
\param yrad Y radius of the corner arcs \param yrad Y radius of the corner arcs
\param setHLine Horizontal line drawing function \param d DrawData containing all other options
\param setVLine Vertical line drawing function
\param setPixel Pixel drawing function
*/ */
void DisplayDriver::StrokeRoundRect(const BRect &r, const float &xrad, const float &yrad, DisplayDriver* driver, SetHorizontalLineFuncType setHLine, SetVerticalLineFuncType setVLine, SetPixelFuncType setPixel) void DisplayDriver::StrokeRoundRect(const BRect &r, const float &xrad, const float &yrad, const DrawData *d)
{ {
int hLeft, hRight; int hLeft, hRight;
int vTop, vBottom; int vTop, vBottom;
@ -2412,17 +2353,20 @@ void DisplayDriver::StrokeRoundRect(const BRect &r, const float &xrad, const flo
bRight = hRight -xrad; bRight = hRight -xrad;
bTop = vTop + yrad; bTop = vTop + yrad;
bBottom = vBottom - yrad; bBottom = vBottom - yrad;
StrokeArc(BRect(bRight, r.top, r.right, bTop), 0, 90, driver, setPixel);
(driver->*setHLine)(hRight, hLeft, (int)ROUND(r.top)); Lock();
StrokeArc(BRect(bRight, r.top, r.right, bTop), 0, 90, d);
StrokeLine(BPoint(hRight, r.top), BPoint(hLeft, r.top), d);
StrokeArc(BRect(r.left,r.top,bLeft,bTop), 90, 90, driver, setPixel); StrokeArc(BRect(r.left,r.top,bLeft,bTop), 90, 90, d);
(driver->*setVLine)((int)ROUND(r.left),vTop,vBottom); StrokeLine(BPoint(r.left, vTop), BPoint(r.left, vBottom), d);
StrokeArc(BRect(r.left,bBottom,bLeft,r.bottom), 180, 90, driver, setPixel); StrokeArc(BRect(r.left,bBottom,bLeft,r.bottom), 180, 90, d);
(driver->*setHLine)(hLeft, hRight, ROUND(r.bottom)); StrokeLine(BPoint(hLeft, r.bottom), BPoint(hRight, r.bottom), d);
StrokeArc(BRect(bRight,bBottom,r.right,r.bottom), 270, 90, driver, setPixel); StrokeArc(BRect(bRight,bBottom,r.right,r.bottom), 270, 90, d);
(driver->*setVLine)((int)ROUND(r.right),vBottom,vTop); StrokeLine(BPoint(r.right, vBottom), BPoint(r.right, vTop), d);
Unlock();
} }
//void DisplayDriver::StrokeShape(SShape *sh, const DrawData *d, const Pattern &pat) //void DisplayDriver::StrokeShape(SShape *sh, const DrawData *d, const Pattern &pat)
@ -2447,9 +2391,9 @@ void DisplayDriver::StrokeTriangle(BPoint *pts, RGBColor &color)
void DisplayDriver::StrokeTriangle(BPoint *pts, const DrawData *d) void DisplayDriver::StrokeTriangle(BPoint *pts, const DrawData *d)
{ {
Lock(); Lock();
StrokePatternLine(pts[0],pts[1],d); StrokeLine(pts[0],pts[1],d);
StrokePatternLine(pts[1],pts[2],d); StrokeLine(pts[1],pts[2],d);
StrokePatternLine(pts[2],pts[0],d); StrokeLine(pts[2],pts[0],d);
Unlock(); Unlock();
} }
@ -3013,11 +2957,13 @@ void DisplayDriver::FillPatternRect(const BRect &rect, const DrawData *d)
{ {
} }
/* Draws a line with pensize 1. Coordinates are guarenteed to be in bounds */
void DisplayDriver::StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color) void DisplayDriver::StrokeSolidLine(const BPoint &start, const BPoint &end, RGBColor &color)
{ {
} }
void DisplayDriver::StrokePatternLine(const BPoint &start, const BPoint &end, const DrawData *d) /* Draws a line with pensize 1. Coordinates are guarenteed to be in bounds */
void DisplayDriver::StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d)
{ {
} }