From 4106b3dbdc017edbbc499bf48a3206e3d2ba0501 Mon Sep 17 00:00:00 2001 From: shadow303 Date: Sun, 7 Dec 2003 03:22:15 +0000 Subject: [PATCH] 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 | 861 +++++++++---- src/servers/app/server/AccelerantDriver.h | 53 +- src/servers/app/server/BitmapDriver.cpp | 916 +++++++++----- src/servers/app/server/BitmapDriver.h | 53 +- src/servers/app/server/Clipper.cpp | 298 ++++- src/servers/app/server/Clipper.h | 56 +- src/servers/app/server/DefaultDecorator.cpp | 54 +- src/servers/app/server/Desktop.cpp | 17 +- src/servers/app/server/DesktopClasses.cpp | 28 +- src/servers/app/server/DesktopClasses.h | 2 +- src/servers/app/server/DisplayDriver.cpp | 1245 +++++++++---------- src/servers/app/server/Layer.cpp | 18 +- src/servers/app/server/PicturePlayer.cpp | 1010 +++++++-------- src/servers/app/server/PicturePlayer.h | 196 +-- src/servers/app/server/RootLayer.cpp | 73 -- src/servers/app/server/RootLayer.h | 1 - src/servers/app/server/ServerWindow.cpp | 72 +- src/servers/app/server/ViewDriver.cpp | 721 +++++++---- src/servers/app/server/ViewDriver.h | 54 +- 19 files changed, 3447 insertions(+), 2281 deletions(-) diff --git a/src/servers/app/server/AccelerantDriver.cpp b/src/servers/app/server/AccelerantDriver.cpp index 6229acc489..bc9bfeb2e5 100644 --- a/src/servers/app/server/AccelerantDriver.cpp +++ b/src/servers/app/server/AccelerantDriver.cpp @@ -39,13 +39,7 @@ #include #define RUN_UNDER_R5 - -#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) ) +#define DRAW_TEST /* 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(); } -/*! - \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 pat 8-byte array containing the pattern to use. Always non-NULL. -*/ -void AccelerantDriver::FillRect(BRect r, LayerData *d, const Pattern &pattern) +void AccelerantDriver::FillArc(const BRect r, float angle, float span, RGBColor& color) { Lock(); - const int8 *pat=pattern.GetInt8(); -#ifndef DISABLE_HARDWARE_ACCELERATION - if ( accFillRect && AcquireEngine && (((uint8)*pat == 0xFF) || (*pat == 0)) ) - { - bool solidColor = true; - int i; - for (i=1; i<8; i++) - if ( pat[i] != pat[i-1] ) - solidColor = false; - if ( solidColor && (AcquireEngine(0,0,NULL,&mEngineToken) == B_OK) ) - { - fill_rect_params fillParams; - uint32 color=0; - fillParams.right = (uint16)r.right; - fillParams.left = (uint16)r.left; - fillParams.top = (uint16)r.top; - fillParams.bottom = (uint16)r.bottom; - if ( (uint8)*pat == 0xFF ) - { - switch (mDisplayMode.space) - { - case B_CMAP8: - case B_GRAY8: - 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 - { - switch (mDisplayMode.space) - { - 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); - pathandler.SetColors(d->highcolor, d->lowcolor); - - switch (mDisplayMode.space) - { - case B_CMAP8: - case B_GRAY8: - { - 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"); - } - + fLineThickness = 1; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + fDrawPattern.SetColors(color,color); + DisplayDriver::FillArc(r,angle,span,this,(SetHorizontalLineFuncType)&AccelerantDriver::HLinePatternThick); Unlock(); } -//void AccelerantDriver::FillShape(SShape *sh, LayerData *d, const Pattern &pat) -//{ -//} +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 pattern 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 AccelerantDriver::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ + Lock(); + fDrawPattern.SetTarget(pattern); + fDrawPattern.SetColors(high_color,low_color); + 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) +{ + 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; + + Lock(); + fLineThickness = (int)pensize; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + for (i=0; i abs(dy) ) + steps = abs(dx); + else + steps = abs(dy); + xInc = dx / (double) steps; + yInc = dy / (double) steps; + + SetThickPatternPixel(ROUND(x),ROUND(y)); + for (k=0; kGetColor(x,y).GetColor8();; - } + fb[x] = fDrawPattern.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] = pat->GetColor(x,y).GetColor16(); - } + fb[x] = fDrawPattern.GetColor(x,y).GetColor15(); + 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; - y2 = y+thick/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); + y1 = y - fLineThickness/2; + y2 = y + fLineThickness/2; 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: diff --git a/src/servers/app/server/AccelerantDriver.h b/src/servers/app/server/AccelerantDriver.h index 98c8a1e359..61cb49ca4e 100644 --- a/src/servers/app/server/AccelerantDriver.h +++ b/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 HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat); - void HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat); + //void SetPixelPattern(int x, int y, uint8 *pattern, uint8 patternindex); + //void HLine(int32 x1, int32 x2, int32 y, 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 SetThickPixel(int x, int y, int thick, PatternHandler *pat); + //void SetPixel(int x, int y, RGBColor col); + //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); diff --git a/src/servers/app/server/BitmapDriver.cpp b/src/servers/app/server/BitmapDriver.cpp index 610d828739..5696912676 100644 --- a/src/servers/app/server/BitmapDriver.cpp +++ b/src/servers/app/server/BitmapDriver.cpp @@ -21,7 +21,7 @@ // // File Name: BitmapDriver.cpp // Author: DarkWyrm -// +// Gabe Yoder // Description: Driver to draw on ServerBitmaps // //------------------------------------------------------------------------------ @@ -44,55 +44,8 @@ #include #include -#ifndef CLIP_X - -#define CLIP_X(a) ( (a < 0) ? 0 : ((a > _target->Width()-1) ? \ - _target->Width()-1 : a) ) -#define CLIP_Y(a) ( (a < 0) ? 0 : ((a > _target->Height()-1) ? \ - _target->Height()-1 : a) ) -#define CHECK_X(a) ( (a >= 0) || (a <= _target->Width()-1) ) -#define CHECK_Y(a) ( (a >= 0) || (a <= _target->Height()-1) ) - -#endif - extern RGBColor workspace_default_color; // defined in AppServer.cpp -void HLine_32Bit(graphics_card_info i, uint16 x, uint16 y, uint16 length, rgb_color col); -void HLine_16Bit(graphics_card_info i, uint16 x, uint16 y, uint16 length, uint16 col); -void HLine_16Bit(graphics_card_info i, uint16 x, uint16 y, uint16 length, uint8 col); - -class BitmapLineCalc -{ -public: - BitmapLineCalc(const BPoint &pta, const BPoint &ptb); - float GetX(float y); - float GetY(float x); - float Slope(void) { return slope; } - float Offset(void) { return offset; } -private: - float slope; - float offset; - BPoint start, end; -}; - -BitmapLineCalc::BitmapLineCalc(const BPoint &pta, const BPoint &ptb) -{ - start=pta; - end=ptb; - slope=(start.y-end.y)/(start.x-end.x); - offset=start.y-(slope * start.x); -} - -float BitmapLineCalc::GetX(float y) -{ - return ( (y-offset)/slope ); -} - -float BitmapLineCalc::GetY(float x) -{ - return ( (slope * x) + offset ); -} - /*! \brief Sets up internal variables needed by all DisplayDriver subclasses @@ -190,158 +143,355 @@ void BitmapDriver::DrawBitmap(ServerBitmap *bitmap, BRect source, BRect dest, La Unlock(); } + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::FillBezier(BPoint *pts, RGBColor& color) +{ + Lock(); + fLineThickness = 1; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + fDrawPattern.SetColors(color,color); + DisplayDriver::FillBezier(pts,this,(SetHorizontalLineFuncType)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::FillEllipse(BRect r, RGBColor& color) +{ + Lock(); + fLineThickness = 1; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + fDrawPattern.SetColors(color,color); + DisplayDriver::FillEllipse(r,this,(SetHorizontalLineFuncType)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + 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 pat 8-byte array containing the pattern to use. Always non-NULL. - + \param color The color used when filling the rectangle */ -void BitmapDriver::FillRect(BRect r, LayerData *d, const Pattern &pat) +void BitmapDriver::FillRect(const BRect r, RGBColor& color) { Lock(); - if(_target) + 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 pattern 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 BitmapDriver::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ + Lock(); + fDrawPattern.SetTarget(pattern); + fDrawPattern.SetColors(high_color,low_color); + FillPatternRect((int32)r.left,(int32)r.top,(int32)r.right,(int32)r.bottom); + Unlock(); +} + +void BitmapDriver::FillRoundRect(BRect r, float xrad, float yrad, RGBColor& color) +{ + Lock(); + fLineThickness = 1; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + fDrawPattern.SetColors(color,color); + fDrawColor = color; + DisplayDriver::FillRoundRect(r,xrad,yrad,this,(SetRectangleFuncType)&BitmapDriver::FillSolidRect,(SetHorizontalLineFuncType)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::FillPatternRect,(SetHorizontalLineFuncType)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::FillTriangle(BPoint *pts, RGBColor& color) +{ + Lock(); + fLineThickness = 1; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + fDrawPattern.SetColors(color,color); + DisplayDriver::FillTriangle(pts,this,(SetHorizontalLineFuncType)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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 BitmapDriver::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)&BitmapDriver::SetThickPatternPixel,is_closed); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick,(SetVerticalLineFuncType)&BitmapDriver::VLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick,(SetVerticalLineFuncType)&BitmapDriver::VLinePatternThick); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick,(SetVerticalLineFuncType)&BitmapDriver::VLinePatternThick,(SetPixelFuncType)&BitmapDriver::SetThickPatternPixel); + Unlock(); +} + +void BitmapDriver::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)&BitmapDriver::HLinePatternThick,(SetVerticalLineFuncType)&BitmapDriver::VLinePatternThick,(SetPixelFuncType)&BitmapDriver::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 BitmapDriver::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; + + Lock(); + fLineThickness = (int)pensize; + fDrawPattern.SetTarget((int8*)&B_SOLID_HIGH); + for (i=0; igcinfo,(int32)rect.left,i,width,col); - Line(BPoint(r.left,i),BPoint(r.right,i),d,pat); + //fDrawColor = colors[i]; + fDrawPattern.SetColors(colors[i],colors[i]); + x1 = ROUND(pts[i*2].x); + y1 = ROUND(pts[i*2].y); + x2 = ROUND(pts[i*2+1].x); + y2 = ROUND(pts[i*2+1].y); + dx = x2-x1; + dy = y2-y1; + x = x1; + y = y1; + if ( abs(dx) > abs(dy) ) + steps = abs(dx); + else + steps = abs(dy); + xInc = dx / (double) steps; + yInc = dy / (double) steps; + + SetThickPatternPixel(ROUND(x),ROUND(y)); + for (k=0; kBitsPerPixel()) - { - case 32: - case 24: - SetThickPixel32(x,y,thick,col.GetColor32()); - break; - case 16: - case 15: - SetThickPixel16(x,y,thick,col.GetColor16()); - break; - case 8: - SetThickPixel8(x,y,thick,col.GetColor8()); - break; - default: - printf("Unknown pixel depth %d in SetThickPixel\n",_target->BitsPerPixel()); - break; - } -} - -void BitmapDriver::SetThickPixel32(int x, int y, int thick, rgb_color col) -{ - // Code courtesy of YNOP's SecondDriver - union - { - uint8 bytes[4]; - uint32 word; - }c1; - - c1.bytes[0]=col.blue; - c1.bytes[1]=col.green; - c1.bytes[2]=col.red; - c1.bytes[3]=col.alpha; - - /* - uint32 *bits=(uint32*)_target->Bits(); - *(bits + x + (y*_target->Width()))=c1.word; - */ - uint32 *bits=(uint32*)_target->Bits()+(x-thick/2)+(y-thick/2)*_target->BytesPerRow(); - int i,j; - for (i=0; iBytesPerRow(); - } -} - -void BitmapDriver::SetThickPixel16(int x, int y, int thick, uint16 col) -{ -// TODO: Implement -printf("SetThickPixel16 unimplemented\n"); - -} - -void BitmapDriver::SetThickPixel8(int x, int y, int thick, uint8 col) -{ - // When the DisplayDriver API changes, we'll use the uint8 highcolor. Until then, - // we'll use *pattern - /* - uint8 *bits=(uint8*)_target->Bits(); - *(bits + x + (y*_target->BytesPerRow()))=col; - */ - - uint8 *bits=(uint8*)_target->Bits()+(x-thick/2)+(y-thick/2)*_target->BytesPerRow(); - int i,j; - for (i=0; iBytesPerRow(); - } -} - -void BitmapDriver::SetPixel(int x, int y, RGBColor col) -{ - switch(_target->BitsPerPixel()) - { - case 32: - case 24: - SetPixel32(x,y,col.GetColor32()); - break; - case 16: - case 15: - SetPixel16(x,y,col.GetColor16()); - break; - case 8: - SetPixel8(x,y,col.GetColor8()); - break; - default: - break; - } -} - -void BitmapDriver::SetPixel32(int x, int y, rgb_color col) -{ - // Code courtesy of YNOP's SecondDriver - union - { - uint8 bytes[4]; - uint32 word; - }c1; - - c1.bytes[0]=col.blue; - c1.bytes[1]=col.green; - c1.bytes[2]=col.red; - c1.bytes[3]=col.alpha; - - uint32 *bits=(uint32*)_target->Bits(); - *(bits + x + (y*_target->BytesPerRow()))=c1.word; -} - -void BitmapDriver::SetPixel16(int x, int y, uint16 col) -{ -// TODO: Implement -printf("SetPixel16 unimplemented\n"); - -} - -void BitmapDriver::SetPixel8(int x, int y, uint8 col) -{ - // When the DisplayDriver API changes, we'll use the uint8 highcolor. Until then, - // we'll use *pattern - uint8 *bits=(uint8*)_target->Bits(); - *(bits + x + (y*_target->BytesPerRow()))=col; - -} //! Empty void BitmapDriver::SetMode(int32 space) @@ -349,93 +499,6 @@ void BitmapDriver::SetMode(int32 space) // No need to reset a bitmap's color space } -void BitmapDriver::SetPixelPattern(int x, int y, uint8 *pattern, uint8 patternindex) -{ - // This function is designed to add pattern support to this thing. Should be - // inlined later to add speed lost in the multiple function calls. - if(patternindex>32) - return; - - if(_target) - { -// uint64 *p64=(uint64*)pattern; - - // check for transparency in mask. If transparent, we can quit here - -// bool transparent_bit= -// ( *p64 & ~((uint64)2 << (32-patternindex)))?true:false; - -// bool highcolor_bit= -// ( *p64 & ~((uint64)2 << (64-patternindex)))?true:false; - - switch(_target->BitsPerPixel()) - { - case 32: - case 24: - { - - break; - } - case 16: - case 15: - { - break; - } - case 8: - { - break; - } - default: - { - break; - } - } - } -} - -void BitmapDriver::Line(BPoint start, BPoint end, LayerData *d, const Pattern &pat) -{ - // Internal function which is called from within other functions - - // Courtesy YNOP's SecondDriver with minor changes by DW - int oct=0; - int xoff=(int32)end.x; - int yoff=(int32)end.y; - int32 x2=(int32)start.x-xoff; - int32 y2=(int32)start.y-yoff; - int32 x1=0; - int32 y1=0; - if(y2<0){ y2=-y2; oct+=4; }//bit2=1 - if(x2<0){ x2=-x2; oct+=2;}//bit1=1 - if(x2highcolor);break; - case 1:SetPixel(( y)+xoff,( x)+yoff,d->highcolor);break; - case 3:SetPixel((-y)+xoff,( x)+yoff,d->highcolor);break; - case 2:SetPixel((-x)+xoff,( y)+yoff,d->highcolor);break; - case 6:SetPixel((-x)+xoff,(-y)+yoff,d->highcolor);break; - case 7:SetPixel((-y)+xoff,(-x)+yoff,d->highcolor);break; - case 5:SetPixel(( y)+xoff,(-x)+yoff,d->highcolor);break; - case 4:SetPixel(( x)+xoff,(-y)+yoff,d->highcolor);break; - } - x++; - sum-=Dy; - if(sum < 0) - { - y++; - sum += Dx; - } - } -} - //! Empty void BitmapDriver::HideCursor(void) { @@ -1317,50 +1380,67 @@ rgb_color BitmapDriver::GetBlitColor(rgb_color src, rgb_color dest, LayerData *d } /*! - \brief Draws a horizontal line - \param x1 The first x coordinate (guaranteed to be in bounds) - \param x2 The second x coordinate (guaranteed to be in bounds) - \param y The y coordinate (guaranteed to be in bounds) - \param pat The PatternHandler which detemines pixel colors + \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) */ -void BitmapDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat) +void BitmapDriver::SetThickPatternPixel(int x, int y) { - int x; - if ( x1 > x2 ) - { - x = x2; - x2 = x1; - x1 = x; - } + int left, right, top, bottom; + int bytes_per_row = _target->BytesPerRow(); + left = x - fLineThickness/2; + right = x + fLineThickness/2; + top = y - fLineThickness/2; + bottom = y + fLineThickness/2; switch(_target->BitsPerPixel()) { case 8: { - uint8 *fb = (uint8 *)_target->Bits() + y*_target->BytesPerRow(); - for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor8(); + int x,y; + uint8 *fb = (uint8 *)_target->Bits() + top*bytes_per_row; + for (y=top; y<=bottom; y++) + { + for (x=left; x<=right; x++) + fb[x] = fDrawPattern.GetColor(x,y).GetColor8();; + fb += bytes_per_row; + } } break; case 15: { - uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y*_target->BytesPerRow()); - for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor15(); + int x,y; + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*bytes_per_row); + for (y=top; y<=bottom; y++) + { + for (x=left; x<=right; x++) + fb[x] = fDrawPattern.GetColor(x,y).GetColor15(); + fb = (uint16 *)((uint8 *)fb + bytes_per_row); + } } break; case 16: { - uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y*_target->BytesPerRow()); - for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor16(); + int x,y; + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } } break; case 24: case 32: { - uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + y*_target->BytesPerRow()); + int x,y; + uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + top*bytes_per_row); rgb_color color; - for (x=x1; x<=x2; x++) + for (y=top; y<=bottom; y++) { - color = pat->GetColor(x,y).GetColor32(); - fb[x] = (color.alpha << 24) | (color.red << 16) | (color.green << 8) | (color.blue); + 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 + bytes_per_row); } } break; default: @@ -1369,17 +1449,15 @@ void BitmapDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat) } /*! - \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 BitmapDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat) +void BitmapDriver::HLinePatternThick(int32 x1, int32 x2, int32 y) { int x, y1, y2; - int bytesPerRow = _target->BytesPerRow(); + int bytes_per_row = _target->BytesPerRow(); if ( x1 > x2 ) { @@ -1387,59 +1465,243 @@ void BitmapDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternH x2 = x1; x1 = x; } - y1 = y-thick/2; - y2 = y+thick/2; - if ( (x2 < 0) || (x1 >= _target->Width()) || (!CHECK_Y(y1) && !CHECK_Y(y2)) ) - return; - x1 = CLIP_X(x1); - x2 = CLIP_X(x2); - y1 = CLIP_Y(y1); - y2 = CLIP_Y(y2); + y1 = y - fLineThickness/2; + y2 = y + fLineThickness/2; switch(_target->BitsPerPixel()) { case 8: { - uint8 *fb = (uint8 *)_target->Bits() + y*bytesPerRow; + uint8 *fb = (uint8 *)_target->Bits() + y1*bytes_per_row; for (y=y1; y<=y2; y++) { for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor8(); - fb += bytesPerRow; + fb[x] = fDrawPattern.GetColor(x,y).GetColor8(); + fb += bytes_per_row; } } break; case 15: { - uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y*bytesPerRow); + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y1*bytes_per_row); for (y=y1; y<=y2; y++) { for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor15(); - fb = (uint16 *)((uint8 *)fb + bytesPerRow); + fb[x] = fDrawPattern.GetColor(x,y).GetColor15(); + fb = (uint16 *)((uint8 *)fb + bytes_per_row); } } break; case 16: { - uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y*bytesPerRow); + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y1*bytes_per_row); for (y=y1; y<=y2; y++) { for (x=x1; x<=x2; x++) - fb[x] = pat->GetColor(x,y).GetColor16(); - fb = (uint16 *)((uint8 *)fb + bytesPerRow); + fb[x] = fDrawPattern.GetColor(x,y).GetColor16(); + fb = (uint16 *)((uint8 *)fb + bytes_per_row); } } break; case 24: case 32: { - uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + y*bytesPerRow); + uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + y1*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 + bytesPerRow); + fb = (uint32 *)((uint8 *)fb + 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 BitmapDriver::VLinePatternThick(int32 x, int32 y1, int32 y2) +{ + int y, x1, x2; + int bytes_per_row = _target->BytesPerRow(); + + if ( y1 > y2 ) + { + y = y2; + y2 = y1; + y1 = y; + } + x1 = x - fLineThickness/2; + x2 = x + fLineThickness/2; + switch(_target->BitsPerPixel()) + { + case 8: + { + uint8 *fb = (uint8 *)_target->Bits() + y1*bytes_per_row; + for (y=y1; y<=y2; y++) + { + for (x=x1; x<=x2; x++) + fb[x] = fDrawPattern.GetColor(x,y).GetColor8(); + fb += bytes_per_row; + } + } break; + case 15: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y1*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 + bytes_per_row); + } + } break; + case 16: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + y1*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 + bytes_per_row); + } + } break; + case 24: + case 32: + { + uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + y1*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 + bytes_per_row); + } + } break; + default: + printf("Error: Unknown color space\n"); + } +} + +void BitmapDriver::FillSolidRect(int32 left, int32 top, int32 right, int32 bottom) +{ + int bytes_per_row = _target->BytesPerRow(); + switch(_target->BitsPerPixel()) + { + case 8: + { + uint8 *fb = (uint8 *)_target->Bits() + top*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 += bytes_per_row; + } + } break; + case 15: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } + } break; + case 16: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } + } break; + case 24: + case 32: + { + uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } + } break; + default: + printf("Error: Unknown color space\n"); + } +} + +void BitmapDriver::FillPatternRect(int32 left, int32 top, int32 right, int32 bottom) +{ + int bytes_per_row = _target->BytesPerRow(); + switch(_target->BitsPerPixel()) + { + case 8: + { + uint8 *fb = (uint8 *)_target->Bits() + top*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 += bytes_per_row; + } + } break; + case 15: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } + } break; + case 16: + { + uint16 *fb = (uint16 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); + } + } break; + case 24: + case 32: + { + uint32 *fb = (uint32 *)((uint8 *)_target->Bits() + top*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 + bytes_per_row); } } break; default: diff --git a/src/servers/app/server/BitmapDriver.h b/src/servers/app/server/BitmapDriver.h index 87e80da01c..fbdf8d3090 100644 --- a/src/servers/app/server/BitmapDriver.h +++ b/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 SetPixel32(int x, int y, rgb_color col); - void SetPixel16(int x, int y, uint16 col); - void SetPixel8(int x, int y, uint8 col); - void SetThickPixel(int x, int y, int thick, RGBColor col); - 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); + 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); + void SetThickPatternPixel(int x, int y); ServerBitmap *_target; }; diff --git a/src/servers/app/server/Clipper.cpp b/src/servers/app/server/Clipper.cpp index 03b8ee49ee..e30baa30ba 100644 --- a/src/servers/app/server/Clipper.cpp +++ b/src/servers/app/server/Clipper.cpp @@ -26,6 +26,7 @@ // //------------------------------------------------------------------------------ #include "Clipper.h" +#include "LayerData.h" Clipper::Clipper(DisplayDriver* driver) { @@ -46,50 +47,109 @@ void Clipper::DrawString(BRegion* clip_reg, const char *string, int32 length, BP fDriver->DrawString(string,length,pt,d,edelta); } -void Clipper::FillArc(BRegion* clip_reg, BRect r, float angle, float span, LayerData *d, const Pattern &pat) + + + + + + + +void Clipper::FillArc(const BRect r, float angle, float span, RGBColor& color, BRegion* clip_reg) { - fDriver->FillArc(r,angle,span,d,pat); + fDriver->FillArc(r,angle,span,color); } -void Clipper::FillBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat) +void Clipper::FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg) { - fDriver->FillBezier(pts,d,pat); + fDriver->FillArc(r,angle,span,pattern,high_color,low_color); } -void Clipper::FillEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat) +void Clipper::FillBezier(BPoint *pts, RGBColor& color, BRegion* clip_reg) { - fDriver->FillEllipse(r,d,pat); + fDriver->FillBezier(pts,color); } -void Clipper::FillPolygon(BRegion* clip_reg, BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat) +void Clipper::FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg) { - fDriver->FillPolygon(ptlist,numpts,rect,d,pat); + fDriver->FillBezier(pts,pattern,high_color,low_color); } -void Clipper::FillRect(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat) +void Clipper::FillEllipse(BRect r, RGBColor& color, BRegion* clip_reg) { - BRegion reg; + fDriver->FillEllipse(r,color); +} - reg.Set(r); +void Clipper::FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg) +{ + fDriver->FillEllipse(r,pattern,high_color,low_color); +} + +void Clipper::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color, BRegion* clip_reg) +{ + fDriver->FillPolygon(ptlist,numpts,color); +} + +void Clipper::FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg) +{ + fDriver->FillPolygon(ptlist,numpts,pattern,high_color,low_color); +} + +void Clipper::FillRect(const BRect r, RGBColor& color, BRegion* clip_reg) +{ if ( clip_reg ) + { + BRegion reg; + reg.Set(r); reg.IntersectWith(clip_reg); - fDriver->FillRegion(®,d,pat); + fDriver->FillRegion(reg,color); + } + else + fDriver->FillRect(r,color); } -void Clipper::FillRegion(BRegion* clip_reg, BRegion *r, LayerData *d, const Pattern &pat) +void Clipper::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg) { - BRegion reg; - - reg = *r; if ( clip_reg ) + { + BRegion reg; + reg.Set(r); reg.IntersectWith(clip_reg); - fDriver->FillRegion(®,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,®,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; iCountRects(); 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; iCountRects(); 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); } diff --git a/src/servers/app/server/Clipper.h b/src/servers/app/server/Clipper.h index 5f8d92d54c..b58d4c8170 100644 --- a/src/servers/app/server/Clipper.h +++ b/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 StrokeBezier(BRegion* clip_reg, BPoint *pts, LayerData *d, const Pattern &pat); - void StrokeEllipse(BRegion* clip_reg, BRect r, LayerData *d, const Pattern &pat); - void StrokeLine(BRegion* clip_reg, BPoint start, BPoint end, LayerData *d, const Pattern &pat); - 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, BRect r, 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, SShape *sh, LayerData *d, const Pattern &pat); - void StrokeTriangle(BRegion* clip_reg, BPoint *pts, BRect r, LayerData *d, const Pattern &pat); - void StrokeLineArray(BRegion* clip_reg, BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d); + void FillArc(const BRect r, float angle, float span, RGBColor& color, BRegion* clip_reg=NULL); + void FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL); + void FillBezier(BPoint *pts, RGBColor& color, BRegion* clip_reg=NULL); + void FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL); + void FillEllipse(BRect r, RGBColor& color, BRegion* clip_reg=NULL); + void FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL); + void FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color, BRegion* clip_reg=NULL); + void FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, BRegion* clip_reg=NULL); + void FillRect(const BRect r, RGBColor& color, BRegion* clip_reg=NULL); + 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; }; diff --git a/src/servers/app/server/DefaultDecorator.cpp b/src/servers/app/server/DefaultDecorator.cpp index 0d2d125a12..7a1f5bc08d 100644 --- a/src/servers/app/server/DefaultDecorator.cpp +++ b/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.RightTop(),&_layerdata,pat_solidhigh); + _driver->StrokeLine(_tabrect.LeftTop(),_tabrect.LeftBottom(),_layerdata.pensize,_layerdata.highcolor); + _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.LeftBottom(),&_layerdata,pat_solidhigh); + _driver->StrokeLine(r.LeftTop(),r.RightTop(),_layerdata.pensize,_layerdata.highcolor); + _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.LeftBottom(),&_layerdata,pat_solidhigh); + _driver->StrokeLine(r.LeftTop(),r.RightTop(),_layerdata.pensize,_layerdata.highcolor); + _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); } } diff --git a/src/servers/app/server/Desktop.cpp b/src/servers/app/server/Desktop.cpp index 7f7da31191..b11d4d3512 100644 --- a/src/servers/app/server/Desktop.cpp +++ b/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. - // For now, we'll just use 3 workspaces. - - s=new Screen(tdriver,3); + s=new Screen(tdriver); 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. - // For now, we'll just use 3 workspaces. - - s=new Screen(tdriver,3); + s=new Screen(tdriver); 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 diff --git a/src/servers/app/server/DesktopClasses.cpp b/src/servers/app/server/DesktopClasses.cpp index 13a2124e8e..1a69d89a0e 100644 --- a/src/servers/app/server/DesktopClasses.cpp +++ b/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); - _workspacecount = workspaces; - for (int i=0; iAddItem(new Workspace(_gcinfo,_fbinfo,this)); - } + _workspacelist = new BList(); + _workspacecount = 0; _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; iItemAt(0); + _activeworkspace->GetRoot()->Show(); +// _activeworkspace->GetRoot()->RequestDraw(); + } + } for (i=_workspacecount; i>count; i--) DeleteWorkspace(i-1); _workspacecount = count; diff --git a/src/servers/app/server/DesktopClasses.h b/src/servers/app/server/DesktopClasses.h index a9462b440c..7c5131fecc 100644 --- a/src/servers/app/server/DesktopClasses.h +++ b/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); diff --git a/src/servers/app/server/DisplayDriver.cpp b/src/servers/app/server/DisplayDriver.cpp index 79ac6014ed..6f2675cc52 100644 --- a/src/servers/app/server/DisplayDriver.cpp +++ b/src/servers/app/server/DisplayDriver.cpp @@ -21,6 +21,7 @@ // // File Name: DisplayDriver.cpp // Author: DarkWyrm +// Gabe Yoder // Description: Mostly abstract class which handles all graphics output // for the server // @@ -30,20 +31,17 @@ #include "LayerData.h" #include "ServerCursor.h" -#define CLIP_X(a) ( (a < 0) ? 0 : ((a > _buffer_width-1) ? \ - _buffer_width-1 : a) ) -#define CLIP_Y(a) ( (a < 0) ? 0 : ((a > _buffer_height-1) ? \ - _buffer_height-1 : a) ) -#define CHECK_X(a) ( (a >= 0) || (a <= _buffer_width-1) ) -#define CHECK_Y(a) ( (a >= 0) || (a <= _buffer_height-1) ) +// TODO: Major cleanup is left. Public functions should be repsonsible for locking. +// Clean the locking code from the protected functions. Remove bounds checking stuff +// since clipper must handle all needed boundary checks (otherwise we could have windows +// bleeding into other windows). +// TODO: Add pixel, line, and rect functions for handling all of the options from LayerData -/* TODO: Add handling of draw modes */ - -AccLineCalc::AccLineCalc() +LineCalc::LineCalc() { } -AccLineCalc::AccLineCalc(const BPoint &pta, const BPoint &ptb) +LineCalc::LineCalc(const BPoint &pta, const BPoint &ptb) { start=pta; end=ptb; @@ -55,7 +53,7 @@ AccLineCalc::AccLineCalc(const BPoint &pta, const BPoint &ptb) maxy = MAX(start.y,end.y); } -void AccLineCalc::SetPoints(const BPoint &pta, const BPoint &ptb) +void LineCalc::SetPoints(const BPoint &pta, const BPoint &ptb) { start=pta; end=ptb; @@ -67,7 +65,149 @@ void AccLineCalc::SetPoints(const BPoint &pta, const BPoint &ptb) maxy = MAX(start.y,end.y); } -void AccLineCalc::Swap(AccLineCalc &from) +bool LineCalc::ClipToRect(const BRect& rect) +{ + if ( (maxx < rect.left) || (minx > rect.right) || (miny < rect.top) || (maxy > rect.bottom) ) + return false; + BPoint newStart(-1,-1); + BPoint newEnd(-1,-1); + if ( maxx == minx ) + { + newStart.x = newEnd.x = minx; + if ( miny < rect.top ) + newStart.y = rect.top; + else + newStart.y = miny; + if ( maxy > rect.bottom ) + newEnd.y = rect.bottom; + else + newEnd.y = maxy; + } + else if ( maxy == miny ) + { + newStart.y = newEnd.y = miny; + if ( minx < rect.left ) + newStart.x = rect.left; + else + newStart.x = minx; + if ( maxx > rect.right ) + newEnd.x = rect.right; + else + newEnd.x = maxx; + } + else + { + float leftInt, rightInt, topInt, bottomInt; + BPoint tempPoint; + leftInt = GetY(rect.left); + rightInt = GetY(rect.right); + topInt = GetX(rect.top); + bottomInt = GetX(rect.bottom); + if ( end.x < start.x ) + { + tempPoint = start; + start = end; + end = tempPoint; + } + if ( start.x < rect.left ) + { + if ( (leftInt >= rect.top) && (leftInt <= rect.bottom) ) + { + newStart.x = rect.left; + newStart.y = leftInt; + } + if ( start.y < end.y ) + { + if ( (topInt >= rect.left) && (topInt <= rect.right) ) + { + newStart.x = topInt; + newStart.y = rect.top; + } + } + else + { + if ( (bottomInt >= rect.left) && (bottomInt <= rect.right) ) + { + newStart.x = bottomInt; + newStart.y = rect.bottom; + } + } + } + else + { + if ( start.y < rect.top ) + { + if ( (topInt >= rect.left) && (topInt <= rect.right) ) + { + newStart.x = topInt; + newStart.y = rect.top; + } + } + else if ( start.y > rect.bottom ) + { + if ( (bottomInt >= rect.left) && (bottomInt <= rect.right) ) + { + newStart.x = bottomInt; + newStart.y = rect.bottom; + } + } + else + newStart = start; + } + if ( end.x > rect.right ) + { + if ( (rightInt >= rect.top) && (rightInt <= rect.bottom) ) + { + newEnd.x = rect.right; + newEnd.y = rightInt; + } + if ( start.y < end.y ) + { + if ( (bottomInt >= rect.left) && (bottomInt <= rect.right) ) + { + newEnd.x = bottomInt; + newEnd.y = rect.bottom; + } + } + else + { + if ( (topInt >= rect.left) && (topInt <= rect.right) ) + { + newEnd.x = topInt; + newEnd.y = rect.top; + } + } + } + else + { + if ( end.y < rect.top ) + { + if ( (topInt >= rect.left) && (topInt <= rect.right) ) + { + newEnd.x = topInt; + newEnd.y = rect.top; + } + } + else if ( end.y > rect.bottom ) + { + if ( (bottomInt >= rect.left) && (bottomInt <= rect.right) ) + { + newEnd.x = bottomInt; + newEnd.y = rect.bottom; + } + } + else + newEnd = end; + } + } + if ( (newStart.x == -1) || (newStart.y == -1) || (newEnd.x == -1) || (newEnd.y == -1) ) + return false; + SetPoints(newStart,newEnd); + + return true; +} + +void LineCalc::Swap(LineCalc &from) { BPoint pta, ptb; pta = start; @@ -76,40 +216,20 @@ void AccLineCalc::Swap(AccLineCalc &from) from.SetPoints(pta,ptb); } -float AccLineCalc::GetX(float y) +float LineCalc::GetX(float y) { if (start.x == end.x) return start.x; return ( (y-offset)/slope ); } -float AccLineCalc::MinX() -{ - return minx; -} - -float AccLineCalc::MaxX() -{ - return maxx; -} - -float AccLineCalc::GetY(float x) +float LineCalc::GetY(float x) { if ( start.x == end.x ) return start.y; return ( (slope * x) + offset ); } -float AccLineCalc::MinY() -{ - return miny; -} - -float AccLineCalc::MaxY() -{ - return maxy; -} - /*! \brief Sets up internal variables needed by all DisplayDriver subclasses @@ -170,8 +290,7 @@ void DisplayDriver::Shutdown(void) \param src Source rectangle. \param dest Destination rectangle. - Bounds checking must be done in this call. If the destination is not the same size - as the source, the source should be scaled to fit. + If the destination is not the same size as the source, the source should be scaled to fit. */ void DisplayDriver::CopyBits(BRect src, BRect dest) { @@ -181,9 +300,6 @@ void DisplayDriver::CopyBits(BRect src, BRect dest) \brief A screen-to-screen blit (of sorts) which copies a BRegion \param src Source region \param lefttop Offset to which the region will be copied - - Bounds checking must be done in this call. This function needs to be literally as - fast as possible - all window moves will be done with it. */ void DisplayDriver::CopyRegion(BRegion *src, const BPoint &lefttop) { @@ -196,8 +312,6 @@ void DisplayDriver::CopyRegion(BRegion *src, const BPoint &lefttop) \param src Source rectangle \param dest Destination rectangle. Source will be scaled to fit if not the same size. \param d Data structure containing any other data necessary for the call. Always non-NULL. - - Bounds checking must be done in this call. */ void DisplayDriver::DrawBitmap(ServerBitmap *bmp, BRect src, BRect dest, LayerData *d) { @@ -218,18 +332,23 @@ void DisplayDriver::DrawString(const char *string, int32 length, BPoint pt, Laye { } +void DisplayDriver::FillArc(const BRect r, float angle, float span, RGBColor& color) +{ +} + +void DisplayDriver::FillArc(const BRect r, float angle, float span, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + /*! \brief Called for all BView::FillArc calls \param r Rectangle enclosing the entire arc \param angle Starting angle for the arc in degrees \param span Span of the arc in degrees. Ending angle = angle+span. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the arc may end up - being clipped. + \param setLIne The horizontal line drawing function which handles needed things like pattern, + color, and line thickness */ -void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat) +void DisplayDriver::FillArc(const BRect r, float angle, float span, DisplayDriver* driver, SetHorizontalLineFuncType setLine) { float xc = (r.left+r.right)/2; float yc = (r.top+r.bottom)/2; @@ -250,21 +369,16 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons int startQuad, endQuad; bool useQuad1, useQuad2, useQuad3, useQuad4; bool shortspan = false; - float oldpensize; - BPoint center(xc,yc); + //BPoint center(xc,yc); // Watch out for bozos giving us whacko spans if ( (span >= 360) || (span <= -360) ) { - FillEllipse(r,d,pat); + FillEllipse(r,driver,setLine); return; } Lock(); - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - oldpensize = d->pensize; - d->pensize = 1; if ( span > 0 ) { @@ -310,14 +424,15 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons } } - if ( useQuad1 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - if ( useQuad2 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc-y),&pattern); - if ( useQuad3 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc+y),&pattern); - if ( useQuad4 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); + if ( useQuad1 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); + if ( useQuad2 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); + if ( useQuad3 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); + if ( useQuad4 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); + /* 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); @@ -330,6 +445,7 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons 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)); while (px < py) @@ -345,131 +461,87 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons p += Ry2 + px - py; } - if ( useQuad1 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - if ( useQuad2 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc-y),&pattern); - if ( useQuad3 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc+y),&pattern); - if ( useQuad4 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); + if ( useQuad1 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); + if ( useQuad2 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); + if ( useQuad3 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); + if ( useQuad4 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); if ( !shortspan ) { if ( startQuad == 1 ) { - if ( CHECK_Y(yc-y) ) + if ( x <= startx ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); + else { - if ( x <= startx ) - { - if ( CHECK_X(xc) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } - else - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc) || CHECK_X(xc+xclip) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+xclip)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc-y)); } } else if ( startQuad == 2 ) { - if ( CHECK_Y(yc-y) ) + if ( x >= startx ) { - if ( x >= startx ) - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc-x) || CHECK_X(xc-xclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-xclip)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc-y)); } } else if ( startQuad == 3 ) { - if ( CHECK_Y(yc+y) ) + if ( x <= startx ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc+y)); + else { - if ( x <= startx ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc)),ROUND(yc+y),&pattern); - } - else - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc-xclip) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-xclip)),ROUND(CLIP_X(xc)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc+y)); } } else if ( startQuad == 4 ) { - if ( CHECK_Y(yc+y) ) + if ( x >= startx ) { - if ( x >= startx ) - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc+xclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+xclip)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc+y)); } } if ( endQuad == 1 ) { - if ( CHECK_Y(yc-y) ) + if ( x >= endx ) { - if ( x >= endx ) - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc+xclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+xclip)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc-y)); } } else if ( endQuad == 2 ) { - if ( CHECK_Y(yc-y) ) + if ( x <= endx ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc-y)); + else { - if ( x <= endx ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc)),ROUND(yc-y),&pattern); - } - else - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc-xclip) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-xclip)),ROUND(CLIP_X(xc)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc-y)); } } else if ( endQuad == 3 ) { - if ( CHECK_Y(yc+y) ) + if ( x >= endx ) { - if ( x >= endx ) - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc-x) || CHECK_X(xc-xclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-xclip)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc+y)); } } else if ( endQuad == 4 ) { - if ( CHECK_Y(yc+y) ) + if ( x <= endx ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); + else { - if ( x <= endx ) - { - if ( CHECK_X(xc) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } - else - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc) || CHECK_X(xc+xclip) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+xclip)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc+y)); } } } @@ -479,67 +551,31 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons endclip = ROUND(y*endx/(double)endy); if ( startQuad == 1 ) { - if ( CHECK_Y(yc-y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc+endclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+endclip)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } - else - { - if ( CHECK_X(xc+endclip) || CHECK_X(xc+startclip) ) - HLine(ROUND(CLIP_X(xc+endclip)),ROUND(CLIP_X(xc+startclip)),ROUND(yc-y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc+endclip),ROUND(xc+x),ROUND(yc-y)); + else + (driver->*setLine)(ROUND(xc+endclip),ROUND(xc+startclip),ROUND(yc-y)); } else if ( startQuad == 2 ) { - if ( CHECK_Y(yc-y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc-startclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-startclip)),ROUND(yc-y),&pattern); - } - else - { - if ( CHECK_X(xc-endclip) || CHECK_X(xc-startclip) ) - HLine(ROUND(CLIP_X(xc-endclip)),ROUND(CLIP_X(xc-startclip)),ROUND(yc-y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc-startclip),ROUND(yc-y)); + else + (driver->*setLine)(ROUND(xc-endclip),ROUND(xc-startclip),ROUND(yc-y)); } else if ( startQuad == 3 ) { - if ( CHECK_Y(yc+y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc-endclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-endclip)),ROUND(yc+y),&pattern); - } - else - { - if ( CHECK_X(xc-startclip) || CHECK_X(xc-endclip) ) - HLine(ROUND(CLIP_X(xc-startclip)),ROUND(CLIP_X(xc-endclip)),ROUND(yc+y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc-endclip),ROUND(yc+y)); + else + (driver->*setLine)(ROUND(xc-startclip),ROUND(xc-endclip),ROUND(yc+y)); } else if ( startQuad == 4 ) { - if ( CHECK_Y(yc+y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc+startclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+startclip)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } - else - { - if ( CHECK_X(xc+startclip) || CHECK_X(xc+endclip) ) - HLine(ROUND(CLIP_X(xc+startclip)),ROUND(CLIP_X(xc+endclip)),ROUND(yc+y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc+startclip),ROUND(xc+x),ROUND(yc+y)); + else + (driver->*setLine)(ROUND(xc+startclip),ROUND(xc+endclip),ROUND(yc+y)); } } } @@ -558,131 +594,87 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons p += Rx2 - py +px; } - if ( useQuad1 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - if ( useQuad2 && CHECK_Y(yc-y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc-y),&pattern); - if ( useQuad3 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc-x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc-x)),ROUND(yc+y),&pattern); - if ( useQuad4 && CHECK_Y(yc+y) && (CHECK_X(xc) || CHECK_X(xc+x)) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); + if ( useQuad1 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); + if ( useQuad2 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc-y)); + if ( useQuad3 ) + (driver->*setLine)(ROUND(xc),ROUND(xc-x),ROUND(yc+y)); + if ( useQuad4 ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); if ( !shortspan ) { if ( startQuad == 1 ) { - if ( CHECK_Y(yc-y) ) + if ( x <= startx ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc-y)); + else { - if ( x <= startx ) - { - if ( CHECK_X(xc) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } - else - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc) || CHECK_X(xc+xclip) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+xclip)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc-y)); } } else if ( startQuad == 2 ) { - if ( CHECK_Y(yc-y) ) + if ( x >= startx ) { - if ( x >= startx ) - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc-x) || CHECK_X(xc-xclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-xclip)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc-y)); } } else if ( startQuad == 3 ) { - if ( CHECK_Y(yc+y) ) + if ( x <= startx ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc+y)); + else { - if ( x <= startx ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc)),ROUND(yc+y),&pattern); - } - else - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc-xclip) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-xclip)),ROUND(CLIP_X(xc)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc+y)); } } else if ( startQuad == 4 ) { - if ( CHECK_Y(yc+y) ) + if ( x >= startx ) { - if ( x >= startx ) - { - xclip = ROUND(y*startx/(double)starty); - if ( CHECK_X(xc+xclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+xclip)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*startx/(double)starty); + (driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc+y)); } } if ( endQuad == 1 ) { - if ( CHECK_Y(yc-y) ) + if ( x >= endx ) { - if ( x >= endx ) - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc+xclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+xclip)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc+xclip),ROUND(xc+x),ROUND(yc-y)); } } else if ( endQuad == 2 ) { - if ( CHECK_Y(yc-y) ) + if ( x <= endx ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc),ROUND(yc-y)); + else { - if ( x <= endx ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc)),ROUND(yc-y),&pattern); - } - else - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc-xclip) || CHECK_X(xc) ) - HLine(ROUND(CLIP_X(xc-xclip)),ROUND(CLIP_X(xc)),ROUND(yc-y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc-xclip),ROUND(xc),ROUND(yc-y)); } } else if ( endQuad == 3 ) { - if ( CHECK_Y(yc+y) ) + if ( x >= endx ) { - if ( x >= endx ) - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc-x) || CHECK_X(xc-xclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-xclip)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc-x),ROUND(xc-xclip),ROUND(yc+y)); } } else if ( endQuad == 4 ) { - if ( CHECK_Y(yc+y) ) + if ( x <= endx ) + (driver->*setLine)(ROUND(xc),ROUND(xc+x),ROUND(yc+y)); + else { - if ( x <= endx ) - { - if ( CHECK_X(xc) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } - else - { - xclip = ROUND(y*endx/(double)endy); - if ( CHECK_X(xc) || CHECK_X(xc+xclip) ) - HLine(ROUND(CLIP_X(xc)),ROUND(CLIP_X(xc+xclip)),ROUND(yc+y),&pattern); - } + xclip = ROUND(y*endx/(double)endy); + (driver->*setLine)(ROUND(xc),ROUND(xc+xclip),ROUND(yc+y)); } } } @@ -692,86 +684,56 @@ void DisplayDriver::FillArc(BRect r, float angle, float span, LayerData *d, cons endclip = ROUND(y*endx/(double)endy); if ( startQuad == 1 ) { - if ( CHECK_Y(yc-y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc+endclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+endclip)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - } - else - { - if ( CHECK_X(xc+endclip) || CHECK_X(xc+startclip) ) - HLine(ROUND(CLIP_X(xc+endclip)),ROUND(CLIP_X(xc+startclip)),ROUND(yc-y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc+endclip),ROUND(xc+x),ROUND(yc-y)); + else + (driver->*setLine)(ROUND(xc+endclip),ROUND(xc+startclip),ROUND(yc-y)); } else if ( startQuad == 2 ) { - if ( CHECK_Y(yc-y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc-startclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-startclip)),ROUND(yc-y),&pattern); - } - else - { - if ( CHECK_X(xc-endclip) || CHECK_X(xc-startclip) ) - HLine(ROUND(CLIP_X(xc-endclip)),ROUND(CLIP_X(xc-startclip)),ROUND(yc-y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc-startclip),ROUND(yc-y)); + else + (driver->*setLine)(ROUND(xc-endclip),ROUND(xc-startclip),ROUND(yc-y)); } else if ( startQuad == 3 ) { - if ( CHECK_Y(yc+y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc-x) || CHECK_X(xc-endclip) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc-endclip)),ROUND(yc+y),&pattern); - } - else - { - if ( CHECK_X(xc-startclip) || CHECK_X(xc-endclip) ) - HLine(ROUND(CLIP_X(xc-startclip)),ROUND(CLIP_X(xc-endclip)),ROUND(yc+y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc-x),ROUND(xc-endclip),ROUND(yc+y)); + else + (driver->*setLine)(ROUND(xc-startclip),ROUND(xc-endclip),ROUND(yc+y)); } else if ( startQuad == 4 ) { - if ( CHECK_Y(yc+y) ) - { - if ( (x <= startx) && (x >= endx) ) - { - if ( CHECK_X(xc+startclip) || CHECK_X(xc+x) ) - HLine(ROUND(CLIP_X(xc+startclip)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } - else - { - if ( CHECK_X(xc+startclip) || CHECK_X(xc+endclip) ) - HLine(ROUND(CLIP_X(xc+startclip)),ROUND(CLIP_X(xc+endclip)),ROUND(yc+y),&pattern); - } - } + if ( (x <= startx) && (x >= endx) ) + (driver->*setLine)(ROUND(xc+startclip),ROUND(xc+x),ROUND(yc+y)); + else + (driver->*setLine)(ROUND(xc+startclip),ROUND(xc+endclip),ROUND(yc+y)); } } } - d->pensize = oldpensize; Unlock(); } +void DisplayDriver::FillBezier(BPoint *pts, RGBColor& color) +{ +} + +void DisplayDriver::FillBezier(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + /*! \brief Called for all BView::FillBezier calls. \param pts 4-element array of BPoints in the order of start, end, and then the two control points. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. + \param setLine Horizontal ine drawing routine which handles things like color and pattern. - Bounds checking must be done in this call. Does not work quite right, need to redo this. */ -void DisplayDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat) +void DisplayDriver::FillBezier(BPoint *pts, DisplayDriver* driver, SetHorizontalLineFuncType setLine) { + /* double Ax, Bx, Cx, Dx; double Ay, By, Cy, Dy; int x, y; @@ -787,7 +749,7 @@ void DisplayDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat) if ( fabs(pts[3].y-pts[0].y) > fabs(pts[3].x-pts[0].x) ) steep = true; - AccLineCalc line(pts[0], pts[3]); + LineCalc line(pts[0], pts[3]); oldpensize = d->pensize; d->pensize = 1; @@ -838,18 +800,23 @@ void DisplayDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat) } d->pensize = oldpensize; Unlock(); + */ +} + +void DisplayDriver::FillEllipse(BRect r, RGBColor& color) +{ +} + +void DisplayDriver::FillEllipse(BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ } /*! \brief Called for all BView::FillEllipse calls \param r BRect enclosing the ellipse to be drawn. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the ellipse may end up - being clipped. + \param setLine Horizontal line drawing routine which handles things like color and pattern. */ -void DisplayDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::FillEllipse(BRect r, DisplayDriver* driver, SetHorizontalLineFuncType setLine) { float xc = (r.left+r.right)/2; float yc = (r.top+r.bottom)/2; @@ -866,16 +833,11 @@ void DisplayDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat) int py = twoRx2 * y; Lock(); - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - if ( CHECK_X(xc) ) - { - if ( CHECK_Y(yc-y) ) - SetPixel(ROUND(xc),ROUND(yc-y),pattern.GetColor(xc,yc-y)); - if ( CHECK_Y(yc+y) ) - SetPixel(ROUND(xc),ROUND(yc+y),pattern.GetColor(xc,yc+y)); - } + //SetPixel(ROUND(xc),ROUND(yc-y),pattern.GetColor(xc,yc-y)); + (driver->*setLine)(ROUND(xc),ROUND(xc),ROUND(yc-y)); + //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)); while (px < py) @@ -891,13 +853,8 @@ void DisplayDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat) p += Ry2 + px - py; } - if ( CHECK_X(xc-x) || CHECK_X(xc+x) ) - { - if ( CHECK_Y(yc-y) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - if ( CHECK_Y(yc+y) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } + (driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc-y)); + (driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc+y)); } p = ROUND(Ry2*(x+.5)*(x+.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2); @@ -914,29 +871,30 @@ void DisplayDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat) p += Rx2 - py +px; } - if ( CHECK_X(xc-x) || CHECK_X(xc+x) ) - { - if ( CHECK_Y(yc-y) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc+x)),ROUND(yc-y),&pattern); - if ( CHECK_Y(yc+y) ) - HLine(ROUND(CLIP_X(xc-x)),ROUND(CLIP_X(xc+x)),ROUND(yc+y),&pattern); - } + (driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc-y)); + (driver->*setLine)(ROUND(xc-x),ROUND(xc+x),ROUND(yc+y)); } Unlock(); } +void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, RGBColor& color) +{ +} + +void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + /*! \brief Called for all BView::FillPolygon calls \param ptlist Array of BPoints defining the polygon. \param numpts Number of points in the BPoint array. - \param rect Rectangle which contains the polygon - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. + \param setLine Horizontal line drawing routine which handles things like color and pattern. The points in the array are not guaranteed to be within the framebuffer's coordinate range. */ -void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat) +void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, DisplayDriver* driver, SetHorizontalLineFuncType setLine) { /* 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. @@ -952,14 +910,12 @@ void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerD Unlock(); return; } - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); BPoint *currentPoint, *nextPoint; BPoint tempNextPoint; BPoint tempCurrentPoint; int currentIndex, bestIndex, i, j, y; - AccLineCalc *segmentArray = new AccLineCalc[2*numpts]; + LineCalc *segmentArray = new LineCalc[2*numpts]; int numSegments = 0; /* Generate the segment list */ @@ -1023,38 +979,33 @@ void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerD } /* Draw the lines */ - for (y=ROUND(rect.top); y<=ROUND(rect.bottom); y++) + for (y=(int)segmentArray[0].MinY(); y<=segmentArray[numSegments-1].MaxY(); y++) { - if ( CHECK_Y(y) ) + i = 0; + while (i y) + break; + if (segmentArray[i].MaxY() < y) { - if (segmentArray[i].MinY() > y) - break; - if (segmentArray[i].MaxY() < y) - { - i++; - continue; - } - if (segmentArray[i].MinY() == segmentArray[i].MaxY()) - { - if ( (segmentArray[i].MinX() < _buffer_width) && - (segmentArray[i].MaxX() >= 0) ) - HLine(CLIP_X(ROUND(segmentArray[i].MinX())), - CLIP_X(ROUND(segmentArray[i].MaxX())), - y, &pattern); - i++; - } - else - { - if ( (segmentArray[i].GetX(y) < _buffer_width) && - (segmentArray[i+1].GetX(y) >= 0) ) - HLine(CLIP_X(ROUND(segmentArray[i].GetX(y))), - CLIP_X(ROUND(segmentArray[i+1].GetX(y))), - y, &pattern); - i+=2; - } + i++; + continue; + } + if (segmentArray[i].MinY() == segmentArray[i].MaxY()) + { + if ( (segmentArray[i].MinX() < _buffer_width) && + (segmentArray[i].MaxX() >= 0) ) + (driver->*setLine)(ROUND(segmentArray[i].MinX()), + ROUND(segmentArray[i].MaxX()), y); + i++; + } + else + { + if ( (segmentArray[i].GetX(y) < _buffer_width) && + (segmentArray[i+1].GetX(y) >= 0) ) + (driver->*setLine)(ROUND(segmentArray[i].GetX(y)), + ROUND(segmentArray[i+1].GetX(y)), y); + i+=2; } } } @@ -1065,95 +1016,111 @@ void DisplayDriver::FillPolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerD /*! \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 pat 8-byte array containing the const Pattern &to use. Always non-NULL. - + \param color The color used to fill the rectangle */ -void DisplayDriver::FillRect(BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::FillRect(const BRect r, RGBColor& color) +{ +} + +/*! + \brief Called for all BView::FillRect calls + \param r BRect to be filled. Guaranteed to be in the frame buffer's coordinate space + \param pattern The pattern used to fill the rectangle + \param high_color The high color of the pattern + \param low_color The low color of the pattern +*/ +void DisplayDriver::FillRect(const BRect r, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) { } /*! \brief Convenience function for server use \param r BRegion to be filled - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - + \param color The color used to fill the region */ -void DisplayDriver::FillRegion(BRegion *r, LayerData *d, const Pattern &pat) +void DisplayDriver::FillRegion(BRegion& r, RGBColor& color) { - if(!r || !d) - return; - Lock(); - for(int32 i=0; iCountRects();i++) - FillRect(r->RectAt(i),d,pat); + for(int32 i=0; ihighcolor, d->lowcolor); - for (i=0; i<=(int)yrad; i++) { arc_x = xrad*sqrt(1-i*i/yrad2); - if ( CHECK_Y(r.top+yrad-i) ) - HLine(ROUND(CLIP_X(r.left+xrad-arc_x)), ROUND(CLIP_X(r.right-xrad+arc_x)), - ROUND(r.top+yrad-i), &pattern); - if ( CHECK_Y(r.bottom-yrad+i) ) - HLine(ROUND(CLIP_X(r.left+xrad-arc_x)), ROUND(CLIP_X(r.right-xrad+arc_x)), - ROUND(r.bottom-yrad+i), &pattern); + (driver->*setLine)(ROUND(r.left+xrad-arc_x), ROUND(r.right-xrad+arc_x), + ROUND(r.top+yrad-i)); + (driver->*setLine)(ROUND(r.left+xrad-arc_x), ROUND(r.right-xrad+arc_x), + ROUND(r.bottom-yrad+i)); } - FillRect(BRect(CLIP_X(r.left),CLIP_Y(r.top+yrad), - CLIP_X(r.right),CLIP_Y(r.bottom-yrad)), d, pat); - - Unlock(); + (driver->*setRect)((int)(r.left),(int)(r.top+yrad),(int)(r.right),(int)(r.bottom-yrad)); } //void DisplayDriver::FillShape(SShape *sh, LayerData *d, const Pattern &pat) //{ //} +void DisplayDriver::FillTriangle(BPoint *pts, RGBColor& color) +{ +} + +void DisplayDriver::FillTriangle(BPoint *pts, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + /*! \brief Called for all BView::FillTriangle calls \param pts Array of 3 BPoints. Always non-NULL. - \param r BRect enclosing the triangle. While it will definitely enclose the triangle, - it may not be within the frame buffer's bounds. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the triangle may end - up being clipped. + \param setLine Horizontal line drawing routine which handles things like color and pattern. */ -void DisplayDriver::FillTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::FillTriangle(BPoint *pts, DisplayDriver* driver, SetHorizontalLineFuncType setLine) { - if(!pts || !d) + if ( !pts ) return; - Lock(); BPoint first, second, third; - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); // Sort points according to their y values and x values (y is primary) if ( (pts[0].y < pts[1].y) || @@ -1197,9 +1164,7 @@ void DisplayDriver::FillTriangle(BPoint *pts, BRect r, LayerData *d, const Patte end.y=first.y; start.x=MIN(first.x,MIN(second.x,third.x)); end.x=MAX(first.x,MAX(second.x,third.x)); - if ( CHECK_Y(start.y) && (CHECK_X(start.x) || CHECK_X(end.x)) ) - HLine(ROUND(CLIP_X(start.x)), ROUND(CLIP_X(end.x)), ROUND(start.y), &pattern); - Unlock(); + (driver->*setLine)(ROUND(start.x), ROUND(end.x), ROUND(start.y)); return; } @@ -1208,47 +1173,37 @@ void DisplayDriver::FillTriangle(BPoint *pts, BRect r, LayerData *d, const Patte // Special case #1: first and second in the same row if(first.y==second.y) { - AccLineCalc lineA(first, third); - AccLineCalc lineB(second, third); + LineCalc lineA(first, third); + LineCalc lineB(second, third); - if ( CHECK_Y(first.y) && (CHECK_X(first.x) || CHECK_X(second.x)) ) - HLine(ROUND(CLIP_X(first.x)), ROUND(CLIP_X(second.x)), ROUND(first.y), &pattern); + (driver->*setLine)(ROUND(first.x), ROUND(second.x), ROUND(first.y)); for(i=(int32)first.y+1; i<=third.y; i++) - if ( CHECK_Y(i) && (CHECK_X(lineA.GetX(i)) || CHECK_X(lineB.GetX(i))) ) - HLine(ROUND(CLIP_X(lineA.GetX(i))), ROUND(CLIP_X(lineB.GetX(i))), i, &pattern); - Unlock(); + (driver->*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); return; } // Special case #2: second and third in the same row if(second.y==third.y) { - AccLineCalc lineA(first, second); - AccLineCalc lineB(first, third); + LineCalc lineA(first, second); + LineCalc lineB(first, third); - if ( CHECK_Y(second.y) && (CHECK_X(second.x) || CHECK_X(third.x)) ) - HLine(ROUND(CLIP_X(second.x)), ROUND(CLIP_X(third.x)), ROUND(second.y), &pattern); + (driver->*setLine)(ROUND(second.x), ROUND(third.x), ROUND(second.y)); for(i=(int32)first.y; i*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); return; } // Normal case. - AccLineCalc lineA(first, second); - AccLineCalc lineB(first, third); - AccLineCalc lineC(second, third); + LineCalc lineA(first, second); + LineCalc lineB(first, third); + LineCalc lineC(second, third); for(i=(int32)first.y; i<(int32)second.y; i++) - if ( CHECK_Y(i) && (CHECK_X(lineA.GetX(i)) || CHECK_X(lineB.GetX(i))) ) - HLine(ROUND(CLIP_X(lineA.GetX(i))), ROUND(CLIP_X(lineB.GetX(i))), i, &pattern); + (driver->*setLine)(ROUND(lineA.GetX(i)), ROUND(lineB.GetX(i)), i); for(i=(int32)second.y; i<=third.y; i++) - if ( CHECK_Y(i) && (CHECK_X(lineC.GetX(i)) || CHECK_X(lineB.GetX(i))) ) - HLine(ROUND(CLIP_X(lineC.GetX(i))), ROUND(CLIP_X(lineB.GetX(i))), i, &pattern); - - Unlock(); + (driver->*setLine)(ROUND(lineC.GetX(i)), ROUND(lineB.GetX(i)), i); } /*! @@ -1351,18 +1306,22 @@ void DisplayDriver::SetCursor(ServerCursor *cursor) Unlock(); } +void DisplayDriver::StrokeArc(BRect r, float angle, float span, float pensize, RGBColor& color) +{ +} + +void DisplayDriver::StrokeArc(BRect r, float angle, float span, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + /*! \brief Called for all BView::StrokeArc calls \param r Rectangle enclosing the entire arc \param angle Starting angle for the arc in degrees \param span Span of the arc in degrees. Ending angle = angle+span. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the arc may end up - being clipped. + \param setPixel Pixel drawing function which handles things like size and pattern. */ -void DisplayDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeArc(BRect r, float angle, float span, DisplayDriver* driver, SetPixelFuncType setPixel) { float xc = (r.left+r.right)/2; float yc = (r.top+r.bottom)/2; @@ -1381,20 +1340,14 @@ void DisplayDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, co int startQuad, endQuad; bool useQuad1, useQuad2, useQuad3, useQuad4; bool shortspan = false; - int thick; // Watch out for bozos giving us whacko spans if ( (span >= 360) || (span <= -360) ) { - StrokeEllipse(r,d,pat); + StrokeEllipse(r,driver,setPixel); return; } - Lock(); - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - - thick = (int)d->pensize; if ( span > 0 ) { startQuad = (int)(angle/90)%4+1; @@ -1436,23 +1389,22 @@ void DisplayDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, co } } - /* SetThickPixel does bounds checking, so we don't have to worry about it here */ if ( useQuad1 || (!shortspan && (((startQuad == 1) && (x <= startx)) || ((endQuad == 1) && (x >= endx)))) || (shortspan && (startQuad == 1) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); if ( useQuad2 || (!shortspan && (((startQuad == 2) && (x >= startx)) || ((endQuad == 2) && (x <= endx)))) || (shortspan && (startQuad == 2) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); if ( useQuad3 || (!shortspan && (((startQuad == 3) && (x <= startx)) || ((endQuad == 3) && (x >= endx)))) || (shortspan && (startQuad == 3) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); if ( useQuad4 || (!shortspan && (((startQuad == 4) && (x >= startx)) || ((endQuad == 4) && (x <= endx)))) || (shortspan && (startQuad == 4) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2)); while (px < py) @@ -1471,19 +1423,19 @@ void DisplayDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, co if ( useQuad1 || (!shortspan && (((startQuad == 1) && (x <= startx)) || ((endQuad == 1) && (x >= endx)))) || (shortspan && (startQuad == 1) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); if ( useQuad2 || (!shortspan && (((startQuad == 2) && (x >= startx)) || ((endQuad == 2) && (x <= endx)))) || (shortspan && (startQuad == 2) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); if ( useQuad3 || (!shortspan && (((startQuad == 3) && (x <= startx)) || ((endQuad == 3) && (x >= endx)))) || (shortspan && (startQuad == 3) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); if ( useQuad4 || (!shortspan && (((startQuad == 4) && (x >= startx)) || ((endQuad == 4) && (x <= endx)))) || (shortspan && (startQuad == 4) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); } p = ROUND(Ry2*(x+.5)*(x+.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2); @@ -1503,33 +1455,38 @@ void DisplayDriver::StrokeArc(BRect r, float angle, float span, LayerData *d, co if ( useQuad1 || (!shortspan && (((startQuad == 1) && (x <= startx)) || ((endQuad == 1) && (x >= endx)))) || (shortspan && (startQuad == 1) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); if ( useQuad2 || (!shortspan && (((startQuad == 2) && (x >= startx)) || ((endQuad == 2) && (x <= endx)))) || (shortspan && (startQuad == 2) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); if ( useQuad3 || (!shortspan && (((startQuad == 3) && (x <= startx)) || ((endQuad == 3) && (x >= endx)))) || (shortspan && (startQuad == 3) && (x <= startx) && (x >= endx)) ) - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); if ( useQuad4 || (!shortspan && (((startQuad == 4) && (x >= startx)) || ((endQuad == 4) && (x <= endx)))) || (shortspan && (startQuad == 4) && (x >= startx) && (x <= endx)) ) - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); } - Unlock(); +} + + +void DisplayDriver::StrokeBezier(BPoint *pts, float pensize, RGBColor& color) +{ +} + +void DisplayDriver::StrokeBezier(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ } /*! \brief Called for all BView::StrokeBezier calls. \param pts 4-element array of BPoints in the order of start, end, and then the two control points. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call. + \param setPixel Pixel drawing function which handles things like size and pattern. */ -void DisplayDriver::StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeBezier(BPoint *pts, DisplayDriver* driver, SetPixelFuncType setPixel) { double Ax, Bx, Cx, Dx; double Ay, By, Cy, Dy; @@ -1540,10 +1497,6 @@ void DisplayDriver::StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat) double dt2, dt3; double X, Y, dx, ddx, dddx, dy, ddy, dddy; - Lock(); - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - Ax = -pts[0].x + 3*pts[1].x - 3*pts[2].x + pts[3].x; Bx = 3*pts[0].x - 6*pts[1].x + 3*pts[2].x; Cx = -3*pts[0].x + 3*pts[1].x; @@ -1572,9 +1525,8 @@ void DisplayDriver::StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat) { x = ROUND(X); y = ROUND(Y); - /* SetThickPixel does bounds checking, so we don't have to worry about it */ if ( (x!=lastx) || (y!=lasty) ) - SetThickPixel(x,y,ROUND(d->pensize),&pattern); + (driver->*setPixel)(x,y); lastx = x; lasty = y; @@ -1585,19 +1537,22 @@ void DisplayDriver::StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat) dy += ddy; ddy += dddy; } - Unlock(); +} + +void DisplayDriver::StrokeEllipse(BRect r, float pensize, RGBColor& color) +{ +} + +void DisplayDriver::StrokeEllipse(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ } /*! \brief Called for all BView::StrokeEllipse calls \param r BRect enclosing the ellipse to be drawn. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the ellipse may end up - being clipped. + \param setPixel Pixel drawing function which handles things like size and pattern. */ -void DisplayDriver::StrokeEllipse(BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeEllipse(BRect r, DisplayDriver* driver, SetPixelFuncType setPixel) { float xc = (r.left+r.right)/2; float yc = (r.top+r.bottom)/2; @@ -1612,19 +1567,11 @@ void DisplayDriver::StrokeEllipse(BRect r, LayerData *d, const Pattern &pat) int y = (int)ry; int px = 0; int py = twoRx2 * y; - int thick; - Lock(); - thick = (int)d->pensize; - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - - /* SetThickPixel does bounds checking, so we don't have to worry about it */ - - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); p = ROUND (Ry2 - (Rx2 * ry) + (.25 * Rx2)); while (px < py) @@ -1640,10 +1587,10 @@ void DisplayDriver::StrokeEllipse(BRect r, LayerData *d, const Pattern &pat) p += Ry2 + px - py; } - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); } p = ROUND(Ry2*(x+.5)*(x+.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2); @@ -1660,25 +1607,28 @@ void DisplayDriver::StrokeEllipse(BRect r, LayerData *d, const Pattern &pat) p += Rx2 - py +px; } - SetThickPixel(ROUND(xc+x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc-y),thick,&pattern); - SetThickPixel(ROUND(xc-x),ROUND(yc+y),thick,&pattern); - SetThickPixel(ROUND(xc+x),ROUND(yc+y),thick,&pattern); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc-y)); + (driver->*setPixel)(ROUND(xc-x),ROUND(yc+y)); + (driver->*setPixel)(ROUND(xc+x),ROUND(yc+y)); } - Unlock(); +} + +void DisplayDriver::StrokeLine(BPoint start, BPoint end, float pensize, RGBColor& color) +{ +} + +void DisplayDriver::StrokeLine(BPoint start, BPoint end, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ } /*! \brief Draws a line. Really. \param start Starting point \param end Ending point - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - The endpoints themselves are guaranteed to be in bounds, but clipping for lines with - a thickness greater than 1 will need to be done. + \param setPixel Pixel drawing function which handles things like size and pattern. */ -void DisplayDriver::StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeLine(BPoint start, BPoint end, DisplayDriver* driver, SetPixelFuncType setPixel) { int x1 = ROUND(start.x); int y1 = ROUND(start.y); @@ -1690,12 +1640,6 @@ void DisplayDriver::StrokeLine(BPoint start, BPoint end, LayerData *d, const Pat double xInc, yInc; double x = x1; double y = y1; - int thick; - - Lock(); - thick = (int)d->pensize; - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); if ( abs(dx) > abs(dy) ) steps = abs(dx); @@ -1704,58 +1648,61 @@ void DisplayDriver::StrokeLine(BPoint start, BPoint end, LayerData *d, const Pat xInc = dx / (double) steps; yInc = dy / (double) steps; - /* SetThickPixel does bounds checking, so we don't have to worry about it */ - SetThickPixel(ROUND(x),ROUND(y),thick,&pattern); + (driver->*setPixel)(ROUND(x),ROUND(y)); for (k=0; k*setPixel)(ROUND(x),ROUND(y)); } - Unlock(); +} + +void DisplayDriver::StrokePoint(BPoint& pt, RGBColor& color) +{ +} + +void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, RGBColor& color, bool is_closed) +{ +} + +void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color, bool is_closed) +{ } /*! \brief Called for all BView::StrokePolygon calls \param ptlist Array of BPoints defining the polygon. \param numpts Number of points in the BPoint array. - \param rect Rectangle which contains the polygon - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - The points in the array are not guaranteed to be within the framebuffer's - coordinate range. + \param setPixel Pixel drawing function which handles things like size and pattern. */ -void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed) +void DisplayDriver::StrokePolygon(BPoint *ptlist, int32 numpts, DisplayDriver* driver, SetPixelFuncType setPixel, bool is_closed) { - /* Bounds checking is handled by StrokeLine and the functions it uses */ - Lock(); for(int32 i=0; i<(numpts-1); i++) - StrokeLine(ptlist[i],ptlist[i+1],d,pat); + StrokeLine(ptlist[i],ptlist[i+1],driver,setPixel); if(is_closed) - StrokeLine(ptlist[numpts-1],ptlist[0],d,pat); - Unlock(); + StrokeLine(ptlist[numpts-1],ptlist[0],driver,setPixel); } /*! \brief Called for all BView::StrokeRect 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 pat 8-byte array containing the const Pattern &to use. Always non-NULL. - + \param r BRect to be drawn + \param pensize Thickness of the lines + \param color The color of the rectangle */ -void DisplayDriver::StrokeRect(BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeRect(BRect r, float pensize, RGBColor& color) { - Lock(); - int thick = (int)d->pensize; - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); +} - HLineThick(ROUND(r.left), ROUND(r.right), ROUND(r.top), thick, &pattern); - StrokeLine(r.RightTop(), r.RightBottom(), d, pat); - HLineThick(ROUND(r.right), ROUND(r.left), ROUND(r.bottom), thick, &pattern); - StrokeLine(r.LeftTop(), r.LeftBottom(), d, pat); - Unlock(); +void DisplayDriver::StrokeRect(BRect r, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ +} + +void DisplayDriver::StrokeRect(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)); } /*! @@ -1765,60 +1712,68 @@ void DisplayDriver::StrokeRect(BRect r, LayerData *d, const Pattern &pat) \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. */ -void DisplayDriver::StrokeRegion(BRegion *r, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeRegion(BRegion& r, float pensize, RGBColor& color) { - if(!r || !d) - return; - Lock(); - for(int32 i=0; iCountRects();i++) - StrokeRect(r->RectAt(i),d,pat); + for(int32 i=0; ipensize; - PatternHandler pattern(pat); - pattern.SetColors(d->highcolor, d->lowcolor); - hLeft = r.left + xrad; - hRight = r.right - xrad; - vTop = r.top + yrad; - vBottom = r.bottom - yrad; + hLeft = (int)ROUND(r.left + xrad); + hRight = (int)ROUND(r.right - xrad); + vTop = (int)ROUND(r.top + yrad); + vBottom = (int)ROUND(r.bottom - yrad); bLeft = hLeft + xrad; bRight = hRight -xrad; bTop = vTop + yrad; bBottom = vBottom - yrad; - StrokeArc(BRect(bRight, r.top, r.right, bTop), 0, 90, d, pat); - HLineThick(ROUND(hRight), ROUND(hLeft), ROUND(r.top), thick, &pattern); + StrokeArc(BRect(bRight, r.top, r.right, bTop), 0, 90, driver, setPixel); + (driver->*setHLine)(hRight, hLeft, (int)ROUND(r.top)); - StrokeArc(BRect(r.left,r.top,bLeft,bTop), 90, 90, d, pat); - StrokeLine(BPoint(r.left,vTop),BPoint(r.left,vBottom),d,pat); + StrokeArc(BRect(r.left,r.top,bLeft,bTop), 90, 90, driver, setPixel); + (driver->*setVLine)((int)ROUND(r.left),vTop,vBottom); - StrokeArc(BRect(r.left,bBottom,bLeft,r.bottom), 180, 90, d, pat); - HLineThick(ROUND(hLeft), ROUND(hRight), ROUND(r.bottom), thick, &pattern); + StrokeArc(BRect(r.left,bBottom,bLeft,r.bottom), 180, 90, driver, setPixel); + (driver->*setHLine)(hLeft, hRight, ROUND(r.bottom)); - StrokeArc(BRect(bRight,bBottom,r.right,r.bottom), 270, 90, d, pat); - StrokeLine(BPoint(r.right,vBottom),BPoint(r.right,vTop),d,pat); - Unlock(); + StrokeArc(BRect(bRight,bBottom,r.right,r.bottom), 270, 90, driver, setPixel); + (driver->*setVLine)((int)ROUND(r.right),vBottom,vTop); } //void DisplayDriver::StrokeShape(SShape *sh, LayerData *d, const Pattern &pat) @@ -1828,21 +1783,24 @@ void DisplayDriver::StrokeRoundRect(BRect r, float xrad, float yrad, LayerData * /*! \brief Called for all BView::StrokeTriangle calls \param pts Array of 3 BPoints. Always non-NULL. - \param r BRect enclosing the triangle. While it will definitely enclose the triangle, - it may not be within the frame buffer's bounds. - \param d Data structure containing any other data necessary for the call. Always non-NULL. - \param pat 8-byte array containing the const Pattern &to use. Always non-NULL. - - Bounds checking must be done in this call because only part of the triangle may end - up being clipped. + \param pensize The line thickness + \param color The color of the lines */ -void DisplayDriver::StrokeTriangle(BPoint *pts, BRect r, LayerData *d, const Pattern &pat) +void DisplayDriver::StrokeTriangle(BPoint *pts, float pensize, RGBColor& color) { - /* Bounds checking is handled by StrokeLine and the functions it calls */ Lock(); - StrokeLine(pts[0],pts[1],d,pat); - StrokeLine(pts[1],pts[2],d,pat); - StrokeLine(pts[2],pts[0],d,pat); + StrokeLine(pts[0],pts[1],pensize,color); + StrokeLine(pts[1],pts[2],pensize,color); + StrokeLine(pts[2],pts[0],pensize,color); + Unlock(); +} + +void DisplayDriver::StrokeTriangle(BPoint *pts, float pensize, const Pattern& pattern, RGBColor& high_color, RGBColor& low_color) +{ + Lock(); + StrokeLine(pts[0],pts[1],pensize,pattern,high_color,low_color); + StrokeLine(pts[1],pts[2],pensize,pattern,high_color,low_color); + StrokeLine(pts[2],pts[0],pensize,pattern,high_color,low_color); Unlock(); } @@ -1850,14 +1808,10 @@ void DisplayDriver::StrokeTriangle(BPoint *pts, BRect r, LayerData *d, const 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 pensize The thickness of the lines \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 DisplayDriver::StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d) +void DisplayDriver::StrokeLineArray(BPoint *pts, int32 numlines, float pensize, RGBColor *colors) { } @@ -2336,9 +2290,11 @@ ServerCursor *DisplayDriver::_GetCursor(void) \param col The color to draw Must be implemented in subclasses */ +/* void DisplayDriver::SetPixel(int x, int y, RGBColor col) { } +*/ /*! \brief Draws a point of a specified thickness @@ -2348,9 +2304,14 @@ void DisplayDriver::SetPixel(int x, int y, RGBColor col) \param pat The PatternHandler which detemines pixel colors Must be implemented in subclasses */ +/* void DisplayDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pat) { } +*/ +void DisplayDriver::SetThickPatternPixel(int x, int y) +{ +} /*! \brief Draws a horizontal line @@ -2360,9 +2321,11 @@ void DisplayDriver::SetThickPixel(int x, int y, int thick, PatternHandler *pat) \param pat The PatternHandler which detemines pixel colors Must be implemented in subclasses */ +/* void DisplayDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat) { } +*/ /*! \brief Draws a horizontal line @@ -2373,8 +2336,24 @@ void DisplayDriver::HLine(int32 x1, int32 x2, int32 y, PatternHandler *pat) \param pat The PatternHandler which detemines pixel colors Must be implemented in subclasses */ +/* void DisplayDriver::HLineThick(int32 x1, int32 x2, int32 y, int32 thick, PatternHandler *pat) { } +*/ +void DisplayDriver::HLinePatternThick(int32 x1, int32 x2, int32 y) +{ +} +void DisplayDriver::VLinePatternThick(int32 x1, int32 x2, int32 y) +{ +} + +void DisplayDriver::FillSolidRect(int32 left, int32 top, int32 right, int32 bottom) +{ +} + +void DisplayDriver::FillPatternRect(int32 left, int32 top, int32 right, int32 bottom) +{ +} diff --git a/src/servers/app/server/Layer.cpp b/src/servers/app/server/Layer.cpp index 7bc8a410d2..bd1fe46b55 100644 --- a/src/servers/app/server/Layer.cpp +++ b/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 = _layerdata->lowcolor; - _layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR ); + RGBColor tempColor(B_TRANSPARENT_COLOR); + //_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR ); - fDriver->StrokeRect(rect, _layerdata, pat_solidlow); - // .. hack continued - _layerdata->lowcolor = tempColor; + fDriver->StrokeRect(rect, _layerdata->pensize, 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 = _layerdata->lowcolor; - _layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR ); + RGBColor tempColor(B_TRANSPARENT_COLOR); + //_layerdata->lowcolor.SetColor( B_TRANSPARENT_COLOR ); - fDriver->StrokeRect(r, _layerdata, pat_solidlow); - // .. hack continued - _layerdata->lowcolor = tempColor; + fDriver->StrokeRect(r, _layerdata->pensize, tempColor); // draw itself. Draw(r); diff --git a/src/servers/app/server/PicturePlayer.cpp b/src/servers/app/server/PicturePlayer.cpp index c220297a92..f0c5adb9a5 100644 --- a/src/servers/app/server/PicturePlayer.cpp +++ b/src/servers/app/server/PicturePlayer.cpp @@ -1,505 +1,505 @@ -//------------------------------------------------------------------------------ -// Copyright (c) 2001-2002, OpenBeOS -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. -// -// File Name: PicturePlayer.cpp -// Author: Marc Flerackers (mflerackers@androme.be) -// DarkWyrm -// Description: Server class to interpret and play BPicture data. Based on -// Marc Flerackers' TPicture class -//------------------------------------------------------------------------------ - -#include "PicturePlayer.h" -#include "PictureProtocol.h" -#include "DisplayDriver.h" -#include -#include - -PicturePlayer::PicturePlayer(DisplayDriver *d,void *data, int32 size) - : fData(data, size) -{ - fdriver=d; - stipplepat=0xFFFFFFFFFFFFFFFFLL; - clipreg=NULL; -} - -PicturePlayer::~PicturePlayer() -{ - if(clipreg) - delete clipreg; -} - -int16 PicturePlayer::GetOp() -{ - int16 data; - - fData.Read(&data, sizeof(int16)); - - return data; -} - -bool PicturePlayer::GetBool() -{ - bool data; - - fData.Read(&data, sizeof(bool)); - - return data; -} - -int16 PicturePlayer::GetInt16() -{ - int16 data; - - fData.Read(&data, sizeof(int16)); - - return data; -} - -int32 PicturePlayer::GetInt32() -{ - int32 data; - - fData.Read(&data, sizeof(int32)); - - return data; -} - -float PicturePlayer::GetFloat() -{ - float data; - - fData.Read(&data, sizeof(float)); - - return data; -} - -BPoint PicturePlayer::GetCoord() -{ - BPoint data; - - fData.Read(&data, sizeof(BPoint)); - - return data; -} - -BRect PicturePlayer::GetRect() -{ - BRect data; - - fData.Read(&data, sizeof(BRect)); - - return data; -} - -rgb_color PicturePlayer::GetColor() -{ - rgb_color data; - - fData.Read(&data, sizeof(rgb_color)); - - return data; -} - -void PicturePlayer::GetData(void *data, int32 size) -{ - fData.Read(data, size); -} - -status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d) -{ - if(!userData || !d) - return B_ERROR; - - int16 op; - int32 size=fData.Seek(0,SEEK_END); - fData.Seek(0,SEEK_SET); - off_t pos; - fldata=*d; - - while (fData.Position() < size) - { - op = GetOp(); - size = GetInt32(); - pos = fData.Position(); - - switch (op) - { - case B_PIC_MOVE_PEN_BY: - { - BPoint where = GetCoord(); - fldata.penlocation.x+=where.x; - fldata.penlocation.y+=where.y; - break; - } - case B_PIC_STROKE_LINE: - { - BPoint start = GetCoord(); - BPoint end = GetCoord(); - fdriver->StrokeLine(start,end,&fldata,stipplepat); - break; - } - case B_PIC_STROKE_RECT: - { - BRect rect = GetRect(); - fdriver->StrokeRect(rect,&fldata,stipplepat); - break; - } - case B_PIC_FILL_RECT: - { - BRect rect = GetRect(); - fdriver->FillRect(rect,&fldata,stipplepat); - break; - } - case B_PIC_STROKE_ROUND_RECT: - { - BRect rect = GetRect(); - BPoint radii = GetCoord(); - fdriver->StrokeRoundRect(rect,radii.x,radii.y,&fldata,stipplepat); - break; - } - case B_PIC_FILL_ROUND_RECT: - { - BRect rect = GetRect(); - BPoint radii = GetCoord(); - fdriver->FillRoundRect(rect,radii.x,radii.y,&fldata,stipplepat); - break; - } - case B_PIC_STROKE_BEZIER: - { - BPoint control[4]; - GetData(control, sizeof(control)); - fdriver->StrokeBezier(control,&fldata,stipplepat); - break; - } - case B_PIC_FILL_BEZIER: - { - BPoint control[4]; - GetData(control, sizeof(control)); - fdriver->FillBezier(control,&fldata,stipplepat); - break; - } - case B_PIC_STROKE_POLYGON: - { - int32 numPoints = GetInt32(); - 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); - delete points; - break; - } - case B_PIC_FILL_POLYGON: - { - int32 numPoints = GetInt32(); - BPoint *points = new BPoint[numPoints]; - GetData(points, numPoints * sizeof(BPoint)); - fdriver->FillPolygon(points,numPoints,BRect(0,0,0,0),&fldata,stipplepat); - delete points; - break; - } - case B_PIC_STROKE_SHAPE: - case B_PIC_FILL_SHAPE: - break; - case B_PIC_DRAW_STRING: - { - int32 len = GetInt32(); - char *string = new char[len + 1]; - GetData(string, len); - string[len] = '\0'; -// float deltax = GetFloat(); -// float deltay = GetFloat(); - - // TODO: The deltas given are escapements. Find out how they translate into - // escapement_delta units. - - fdriver->DrawString(string,len,fldata.penlocation,&fldata,NULL); - delete string; - break; - } - case B_PIC_DRAW_PIXELS: - { - // Equivalent of DrawBitmap(). - - // Normally, we wouldn't explicitly play around with ServerBitmap's buffer memory, but - // we don't want the overhead of going through the pool allocator for a quick bitmap. - BRect src = GetRect(); - BRect dest = GetRect(); - int32 width = GetInt32(); - int32 height = GetInt32(); - int32 bytesPerRow = GetInt32(); - int32 pixelFormat = GetInt32(); - int32 flags = GetInt32(); - - ServerBitmap sbmp(BRect(0,0,width-1,height-1), (color_space)pixelFormat, flags, bytesPerRow); - sbmp._AllocateBuffer(); - GetData(sbmp.Bits(), size - (fData.Position() - pos)); - fdriver->DrawBitmap(&sbmp,src,dest,&fldata); - sbmp._FreeBuffer(); - break; - } - case B_PIC_DRAW_PICTURE: - { - // TODO: Implement - printf("DEBUG: PicturePlayer::Play(): B_PIC_DRAW_PICTURE unimplemented!\n"); - break; - } - case B_PIC_STROKE_ARC: - { - BPoint center = GetCoord(); - BPoint radii = GetCoord(); - 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); - break; - } - case B_PIC_FILL_ARC: - { - BPoint center = GetCoord(); - BPoint radii = GetCoord(); - 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); - break; - } - case B_PIC_STROKE_ELLIPSE: - { - BRect rect = GetRect(); - BPoint center; - BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f); - center = rect.LeftTop() + radii; - fdriver->StrokeEllipse(rect,&fldata,stipplepat); - break; - } - case B_PIC_FILL_ELLIPSE: - { - BRect rect = GetRect(); - BPoint center; - BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f); - center = rect.LeftTop() + radii; - fdriver->FillEllipse(rect,&fldata,stipplepat); - break; - } - case B_PIC_ENTER_STATE_CHANGE: - { - // This simply signals that only state stuff will follow until - // B_PIC_EXIT_STATE_CHANGE is encountered. This doesn't affect us AFAIK, - // so we'll do absolutely nothing. - break; - } - case B_PIC_CLIP_TO_PICTURE: - { - //TODO: Implement - break; - } - case B_PIC_PUSH_STATE: - { - //TODO: Implement - break; - } - case B_PIC_POP_STATE: - { - //TODO: Implement - break; - } - case B_PIC_SET_CLIPPING_RECTS: - { - // TODO: Find out how the data will be stored and implement - break; - } - case B_PIC_CLEAR_CLIPPING_RECTS: - { - SetClippingRegion(NULL, 0); - break; - } - case B_PIC_SET_ORIGIN: - { - BPoint pt = GetCoord(); - forigin=pt; - break; - } - case B_PIC_SET_PEN_LOCATION: - { - BPoint pt = GetCoord(); - fldata.penlocation=pt; - break; - } - case B_PIC_SET_DRAWING_MODE: - { - int16 mode = GetInt16(); - fldata.draw_mode=(drawing_mode)mode; - break; - } - case B_PIC_SET_LINE_MODE: - { - GetData(&fldata.lineCap,sizeof(cap_mode)); - GetData(&fldata.lineJoin,sizeof(join_mode)); - fldata.miterLimit = GetFloat(); - break; - } - case B_PIC_SET_PEN_SIZE: - { - float size = GetFloat(); - fldata.pensize=size; - break; - } - case B_PIC_SET_SCALE: - { - float scale = GetFloat(); - fldata.scale=scale; - break; - } - case B_PIC_SET_FORE_COLOR: - { - rgb_color color = GetColor(); - fldata.highcolor=color; - break; - } - case B_PIC_SET_BACK_COLOR: - { - rgb_color color = GetColor(); - fldata.lowcolor=color; - break; - } - case B_PIC_SET_STIPLE_PATTERN: - { - pattern p; - GetData(&p, sizeof(p)); - stipplepat=*((uint64*)p.data); - break; - } - case B_PIC_ENTER_FONT_STATE: - { - // We don't really care about this call, so do nothing - break; - } - case B_PIC_SET_BLENDING_MODE: - { - int16 alphaSrcMode = GetInt16(); - int16 alphaFncMode = GetInt16(); - fldata.alphaSrcMode = (source_alpha)alphaSrcMode; - fldata.alphaFncMode = (alpha_function)alphaFncMode; - break; - } - case B_PIC_SET_FONT_FAMILY: - { - //TODO: Implement -/* int32 len = GetInt32(); - char *string = new char[len + 1]; - GetData(string, len); - string[len] = '\0'; - ((fnc_Pc)callBackTable[37])(userData, string); - delete string; -*/ break; - } - case B_PIC_SET_FONT_STYLE: - { - //TODO: Implement -/* int32 len = GetInt32(); - char *string = new char[len + 1]; - GetData(string, len); - string[len] = '\0'; - ((fnc_Pc)callBackTable[38])(userData, string); - delete string; -*/ break; - } - case B_PIC_SET_FONT_SPACING: - { - fldata.font.SetSpacing(GetInt32()); - break; - } - case B_PIC_SET_FONT_ENCODING: - { - fldata.font.SetEncoding(GetInt32()); - break; - } - case B_PIC_SET_FONT_FLAGS: - { - fldata.font.SetFlags(GetInt32()); - break; - } - case B_PIC_SET_FONT_SIZE: - { - fldata.font.SetSize(GetFloat()); - break; - } - case B_PIC_SET_FONT_ROTATE: - { - fldata.font.SetRotation(GetFloat()); - break; - } - case B_PIC_SET_FONT_SHEAR: - { - fldata.font.SetShear(GetFloat()); - break; - } - case B_PIC_SET_FONT_FACE: - { - fldata.font.SetFace(GetInt32()); - break; - } - default: - break; - } - - // If we didn't read enough bytes, skip them. This is not a error - // since the instructions can change over time. - if (fData.Position() - pos < size) - fData.Seek(size - (fData.Position() - pos), SEEK_CUR); - } - - return B_OK; -} - -void PicturePlayer::SetClippingRegion(BRect *rects, int32 numrects) -{ - // Sets the player's clipping region to the union of the rectangles passed to it. - // Passing NULL or 0 rectangles to the function empties the clipping region. The clipping - // region is also emptied if there is no union of all rectangles passed to the function. - - if(!rects || numrects) - { - delete clipreg; - clipreg=NULL; - return; - } - - if(!clipreg) - clipreg=new BRegion(); - else - clipreg->MakeEmpty(); - - *clipreg=rects[0]; - BRegion temp; - - for(int32 i=1; iIntersectWith(&temp); - } - - if(clipreg->CountRects()==0) - { - delete clipreg; - clipreg=NULL; - } -} +//------------------------------------------------------------------------------ +// Copyright (c) 2001-2002, OpenBeOS +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +// +// File Name: PicturePlayer.cpp +// Author: Marc Flerackers (mflerackers@androme.be) +// DarkWyrm +// Description: Server class to interpret and play BPicture data. Based on +// Marc Flerackers' TPicture class +//------------------------------------------------------------------------------ + +#include "PicturePlayer.h" +#include "PictureProtocol.h" +#include "DisplayDriver.h" +#include +#include + +PicturePlayer::PicturePlayer(DisplayDriver *d,void *data, int32 size) + : fData(data, size) +{ + fdriver=d; + stipplepat=0xFFFFFFFFFFFFFFFFLL; + clipreg=NULL; +} + +PicturePlayer::~PicturePlayer() +{ + if(clipreg) + delete clipreg; +} + +int16 PicturePlayer::GetOp() +{ + int16 data; + + fData.Read(&data, sizeof(int16)); + + return data; +} + +bool PicturePlayer::GetBool() +{ + bool data; + + fData.Read(&data, sizeof(bool)); + + return data; +} + +int16 PicturePlayer::GetInt16() +{ + int16 data; + + fData.Read(&data, sizeof(int16)); + + return data; +} + +int32 PicturePlayer::GetInt32() +{ + int32 data; + + fData.Read(&data, sizeof(int32)); + + return data; +} + +float PicturePlayer::GetFloat() +{ + float data; + + fData.Read(&data, sizeof(float)); + + return data; +} + +BPoint PicturePlayer::GetCoord() +{ + BPoint data; + + fData.Read(&data, sizeof(BPoint)); + + return data; +} + +BRect PicturePlayer::GetRect() +{ + BRect data; + + fData.Read(&data, sizeof(BRect)); + + return data; +} + +rgb_color PicturePlayer::GetColor() +{ + rgb_color data; + + fData.Read(&data, sizeof(rgb_color)); + + return data; +} + +void PicturePlayer::GetData(void *data, int32 size) +{ + fData.Read(data, size); +} + +status_t PicturePlayer::Play(int32 tableEntries,void *userData, LayerData *d) +{ + if(!userData || !d) + return B_ERROR; + + int16 op; + int32 size=fData.Seek(0,SEEK_END); + fData.Seek(0,SEEK_SET); + off_t pos; + fldata=*d; + + while (fData.Position() < size) + { + op = GetOp(); + size = GetInt32(); + pos = fData.Position(); + + switch (op) + { + case B_PIC_MOVE_PEN_BY: + { + BPoint where = GetCoord(); + fldata.penlocation.x+=where.x; + fldata.penlocation.y+=where.y; + break; + } + case B_PIC_STROKE_LINE: + { + BPoint start = GetCoord(); + BPoint end = GetCoord(); + fdriver->StrokeLine(start,end,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_STROKE_RECT: + { + BRect rect = GetRect(); + fdriver->StrokeRect(rect,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_FILL_RECT: + { + BRect rect = GetRect(); + 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.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,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_STROKE_BEZIER: + { + BPoint control[4]; + GetData(control, sizeof(control)); + 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,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_STROKE_POLYGON: + { + int32 numPoints = GetInt32(); + BPoint *points = new BPoint[numPoints]; + GetData(points, numPoints * sizeof(BPoint)); + bool isClosed = GetBool(); + fdriver->StrokePolygon(points,numPoints,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor,isClosed); + delete points; + break; + } + case B_PIC_FILL_POLYGON: + { + int32 numPoints = GetInt32(); + BPoint *points = new BPoint[numPoints]; + GetData(points, numPoints * sizeof(BPoint)); + fdriver->FillPolygon(points,numPoints,stipplepat,fldata.highcolor,fldata.lowcolor); + delete points; + break; + } + case B_PIC_STROKE_SHAPE: + case B_PIC_FILL_SHAPE: + break; + case B_PIC_DRAW_STRING: + { + int32 len = GetInt32(); + char *string = new char[len + 1]; + GetData(string, len); + string[len] = '\0'; +// float deltax = GetFloat(); +// float deltay = GetFloat(); + + // TODO: The deltas given are escapements. Find out how they translate into + // escapement_delta units. + + fdriver->DrawString(string,len,fldata.penlocation,&fldata,NULL); + delete string; + break; + } + case B_PIC_DRAW_PIXELS: + { + // Equivalent of DrawBitmap(). + + // Normally, we wouldn't explicitly play around with ServerBitmap's buffer memory, but + // we don't want the overhead of going through the pool allocator for a quick bitmap. + BRect src = GetRect(); + BRect dest = GetRect(); + int32 width = GetInt32(); + int32 height = GetInt32(); + int32 bytesPerRow = GetInt32(); + int32 pixelFormat = GetInt32(); + int32 flags = GetInt32(); + + ServerBitmap sbmp(BRect(0,0,width-1,height-1), (color_space)pixelFormat, flags, bytesPerRow); + sbmp._AllocateBuffer(); + GetData(sbmp.Bits(), size - (fData.Position() - pos)); + fdriver->DrawBitmap(&sbmp,src,dest,&fldata); + sbmp._FreeBuffer(); + break; + } + case B_PIC_DRAW_PICTURE: + { + // TODO: Implement + printf("DEBUG: PicturePlayer::Play(): B_PIC_DRAW_PICTURE unimplemented!\n"); + break; + } + case B_PIC_STROKE_ARC: + { + BPoint center = GetCoord(); + BPoint radii = GetCoord(); + 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.pensize,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_FILL_ARC: + { + BPoint center = GetCoord(); + BPoint radii = GetCoord(); + 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, stipplepat, fldata.highcolor, fldata.lowcolor); + break; + } + case B_PIC_STROKE_ELLIPSE: + { + BRect rect = GetRect(); + BPoint center; + BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f); + center = rect.LeftTop() + radii; + fdriver->StrokeEllipse(rect,fldata.pensize,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_FILL_ELLIPSE: + { + BRect rect = GetRect(); + BPoint center; + BPoint radii((rect.Width() + 1) / 2.0f, (rect.Height() + 1) / 2.0f); + center = rect.LeftTop() + radii; + fdriver->FillEllipse(rect,stipplepat,fldata.highcolor,fldata.lowcolor); + break; + } + case B_PIC_ENTER_STATE_CHANGE: + { + // This simply signals that only state stuff will follow until + // B_PIC_EXIT_STATE_CHANGE is encountered. This doesn't affect us AFAIK, + // so we'll do absolutely nothing. + break; + } + case B_PIC_CLIP_TO_PICTURE: + { + //TODO: Implement + break; + } + case B_PIC_PUSH_STATE: + { + //TODO: Implement + break; + } + case B_PIC_POP_STATE: + { + //TODO: Implement + break; + } + case B_PIC_SET_CLIPPING_RECTS: + { + // TODO: Find out how the data will be stored and implement + break; + } + case B_PIC_CLEAR_CLIPPING_RECTS: + { + SetClippingRegion(NULL, 0); + break; + } + case B_PIC_SET_ORIGIN: + { + BPoint pt = GetCoord(); + forigin=pt; + break; + } + case B_PIC_SET_PEN_LOCATION: + { + BPoint pt = GetCoord(); + fldata.penlocation=pt; + break; + } + case B_PIC_SET_DRAWING_MODE: + { + int16 mode = GetInt16(); + fldata.draw_mode=(drawing_mode)mode; + break; + } + case B_PIC_SET_LINE_MODE: + { + GetData(&fldata.lineCap,sizeof(cap_mode)); + GetData(&fldata.lineJoin,sizeof(join_mode)); + fldata.miterLimit = GetFloat(); + break; + } + case B_PIC_SET_PEN_SIZE: + { + float size = GetFloat(); + fldata.pensize=size; + break; + } + case B_PIC_SET_SCALE: + { + float scale = GetFloat(); + fldata.scale=scale; + break; + } + case B_PIC_SET_FORE_COLOR: + { + rgb_color color = GetColor(); + fldata.highcolor=color; + break; + } + case B_PIC_SET_BACK_COLOR: + { + rgb_color color = GetColor(); + fldata.lowcolor=color; + break; + } + case B_PIC_SET_STIPLE_PATTERN: + { + pattern p; + GetData(&p, sizeof(p)); + stipplepat=*((uint64*)p.data); + break; + } + case B_PIC_ENTER_FONT_STATE: + { + // We don't really care about this call, so do nothing + break; + } + case B_PIC_SET_BLENDING_MODE: + { + int16 alphaSrcMode = GetInt16(); + int16 alphaFncMode = GetInt16(); + fldata.alphaSrcMode = (source_alpha)alphaSrcMode; + fldata.alphaFncMode = (alpha_function)alphaFncMode; + break; + } + case B_PIC_SET_FONT_FAMILY: + { + //TODO: Implement +/* int32 len = GetInt32(); + char *string = new char[len + 1]; + GetData(string, len); + string[len] = '\0'; + ((fnc_Pc)callBackTable[37])(userData, string); + delete string; +*/ break; + } + case B_PIC_SET_FONT_STYLE: + { + //TODO: Implement +/* int32 len = GetInt32(); + char *string = new char[len + 1]; + GetData(string, len); + string[len] = '\0'; + ((fnc_Pc)callBackTable[38])(userData, string); + delete string; +*/ break; + } + case B_PIC_SET_FONT_SPACING: + { + fldata.font.SetSpacing(GetInt32()); + break; + } + case B_PIC_SET_FONT_ENCODING: + { + fldata.font.SetEncoding(GetInt32()); + break; + } + case B_PIC_SET_FONT_FLAGS: + { + fldata.font.SetFlags(GetInt32()); + break; + } + case B_PIC_SET_FONT_SIZE: + { + fldata.font.SetSize(GetFloat()); + break; + } + case B_PIC_SET_FONT_ROTATE: + { + fldata.font.SetRotation(GetFloat()); + break; + } + case B_PIC_SET_FONT_SHEAR: + { + fldata.font.SetShear(GetFloat()); + break; + } + case B_PIC_SET_FONT_FACE: + { + fldata.font.SetFace(GetInt32()); + break; + } + default: + break; + } + + // If we didn't read enough bytes, skip them. This is not a error + // since the instructions can change over time. + if (fData.Position() - pos < size) + fData.Seek(size - (fData.Position() - pos), SEEK_CUR); + } + + return B_OK; +} + +void PicturePlayer::SetClippingRegion(BRect *rects, int32 numrects) +{ + // Sets the player's clipping region to the union of the rectangles passed to it. + // Passing NULL or 0 rectangles to the function empties the clipping region. The clipping + // region is also emptied if there is no union of all rectangles passed to the function. + + if(!rects || numrects) + { + delete clipreg; + clipreg=NULL; + return; + } + + if(!clipreg) + clipreg=new BRegion(); + else + clipreg->MakeEmpty(); + + *clipreg=rects[0]; + BRegion temp; + + for(int32 i=1; iIntersectWith(&temp); + } + + if(clipreg->CountRects()==0) + { + delete clipreg; + clipreg=NULL; + } +} diff --git a/src/servers/app/server/PicturePlayer.h b/src/servers/app/server/PicturePlayer.h index 0676cea303..0a0ed08faf 100644 --- a/src/servers/app/server/PicturePlayer.h +++ b/src/servers/app/server/PicturePlayer.h @@ -1,98 +1,98 @@ -//------------------------------------------------------------------------------ -// Copyright (c) 2001-2002, OpenBeOS -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. -// -// File Name: PicturePlayer.cpp -// Author: Marc Flerackers (mflerackers@androme.be) -// DarkWyrm -// Description: Server class to interpret and play BPicture data. Based on -// Marc Flerackers' TPicture class -//------------------------------------------------------------------------------ -#ifndef _PICTUREPLAYER_H -#define _PICTUREPLAYER_H - -#include -#include -#include -#include -#include "LayerData.h" -#include "PatternHandler.h" // for pattern_union - -class DisplayDriver; - -class PicturePlayer -{ -public: - PicturePlayer(DisplayDriver *driver,void *data, int32 size); - virtual ~PicturePlayer(); - - int16 GetOp(); - bool GetBool(); - int16 GetInt8(); - int16 GetInt16(); - int32 GetInt32(); - int64 GetInt64(); - float GetFloat(); - BPoint GetCoord(); - BRect GetRect(); - rgb_color GetColor(); - //void GetString(char *); - - void *GetData(int32); - void GetData(void *data, int32 size); - - void AddInt8(int8); - void AddInt16(int16); - void AddInt32(int32); - void AddInt64(int64); - void AddFloat(float); - void AddCoord(BPoint); - void AddRect(BRect); - void AddColor(rgb_color); - void AddString(char *); - - void AddData(void *data, int32 size); - - void BeginOp(int32); - void EndOp(); - - void EnterStateChange(); - void ExitStateChange(); - - void EnterFontChange(); - void ExitFontChange(); - - void SetClippingRegion(BRect *rects, int32 numrects); - - status_t Play(int32 tableEntries,void *userData, LayerData *d); - status_t Rewind(); - -private: - BMemoryIO fData; - int32 fSize; - DisplayDriver *fdriver; - LayerData fldata; - BPoint forigin; - Pattern stipplepat; - BRegion *clipreg; -}; - -#endif - +//------------------------------------------------------------------------------ +// Copyright (c) 2001-2002, OpenBeOS +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +// +// File Name: PicturePlayer.cpp +// Author: Marc Flerackers (mflerackers@androme.be) +// DarkWyrm +// Description: Server class to interpret and play BPicture data. Based on +// Marc Flerackers' TPicture class +//------------------------------------------------------------------------------ +#ifndef _PICTUREPLAYER_H +#define _PICTUREPLAYER_H + +#include +#include +#include +#include +#include "LayerData.h" +#include "PatternHandler.h" // for pattern_union + +class DisplayDriver; + +class PicturePlayer +{ +public: + PicturePlayer(DisplayDriver *driver,void *data, int32 size); + virtual ~PicturePlayer(); + + int16 GetOp(); + bool GetBool(); + int16 GetInt8(); + int16 GetInt16(); + int32 GetInt32(); + int64 GetInt64(); + float GetFloat(); + BPoint GetCoord(); + BRect GetRect(); + rgb_color GetColor(); + //void GetString(char *); + + void *GetData(int32); + void GetData(void *data, int32 size); + + void AddInt8(int8); + void AddInt16(int16); + void AddInt32(int32); + void AddInt64(int64); + void AddFloat(float); + void AddCoord(BPoint); + void AddRect(BRect); + void AddColor(rgb_color); + void AddString(char *); + + void AddData(void *data, int32 size); + + void BeginOp(int32); + void EndOp(); + + void EnterStateChange(); + void ExitStateChange(); + + void EnterFontChange(); + void ExitFontChange(); + + void SetClippingRegion(BRect *rects, int32 numrects); + + status_t Play(int32 tableEntries,void *userData, LayerData *d); + status_t Rewind(); + +private: + BMemoryIO fData; + int32 fSize; + DisplayDriver *fdriver; + LayerData fldata; + BPoint forigin; + Pattern stipplepat; + BRegion *clipreg; +}; + +#endif + diff --git a/src/servers/app/server/RootLayer.cpp b/src/servers/app/server/RootLayer.cpp index c9088554fc..3f5fa2a6e0 100644 --- a/src/servers/app/server/RootLayer.cpp +++ b/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 diff --git a/src/servers/app/server/RootLayer.h b/src/servers/app/server/RootLayer.h index f563324319..f209d81f60 100644 --- a/src/servers/app/server/RootLayer.h +++ b/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); diff --git a/src/servers/app/server/ServerWindow.cpp b/src/servers/app/server/ServerWindow.cpp index c6759fe1ef..d78fb05e00 100644 --- a/src/servers/app/server/ServerWindow.cpp +++ b/src/servers/app/server/ServerWindow.cpp @@ -1528,9 +1528,9 @@ void ServerWindow::DispatchGraphicsMessage(int32 msgsize, int8 *msgbuffer) angle = read_from_buffer(&msgbuffer); span = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->StrokeArc(rect,angle,span,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); } pattern = read_pattern_from_buffer(&msgbuffer); - if ( layerdata ) - _app->_driver->StrokeBezier(pts,layerdata,pattern); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->StrokeEllipse(rect,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); y2 = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BPoint p1(x1,y1); - BPoint p2(x2,y2); - if ( layerdata ) - _app->_driver->StrokeLine(p1,p2,layerdata,pattern); + //BPoint p1(x1,y1); + //BPoint p2(x2,y2); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->StrokeRect(rect,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); yrad = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->StrokeRoundRect(rect,xrad,yrad,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->StrokeTriangle(pts,rect,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); span = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->FillArc(rect,angle,span,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); } pattern = read_pattern_from_buffer(&msgbuffer); - if ( layerdata ) - _app->_driver->FillBezier(pts,layerdata,pattern); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->FillEllipse(rect,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&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_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(&msgbuffer); yrad = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->FillRoundRect(rect,xrad,yrad,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_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(&msgbuffer); bottom = read_from_buffer(&msgbuffer); pattern = read_pattern_from_buffer(&msgbuffer); - BRect rect(left,top,right,bottom); - if ( layerdata ) - _app->_driver->FillTriangle(pts,rect,layerdata,pattern); + //BRect rect(left,top,right,bottom); + //if ( layerdata ) + //_app->_driver->FillTriangle(pts,rect,layerdata,pattern); delete[] pts; sizeRemaining -= AS_FILL_TRIANGLE_MSG_SIZE; } diff --git a/src/servers/app/server/ViewDriver.cpp b/src/servers/app/server/ViewDriver.cpp index 4e72433a51..9a21fdbbe0 100644 --- a/src/servers/app/server/ViewDriver.cpp +++ b/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) - return; + Lock(); screenwin->Lock(); framebuffer->Lock(); - SetLayerData(d); - drawview->FillArc(r,angle,span,*((pattern*)pat.GetInt8())); + + drawview->SetDrawingMode(B_OP_COPY); + drawview->SetHighColor(color.GetColor32()); + drawview->SetLowColor(color.GetColor32()); + + drawview->FillArc(r,angle,span,B_SOLID_HIGH); drawview->Sync(); screenwin->view->Invalidate(r); framebuffer->Unlock(); screenwin->Unlock(); + Unlock(); } -void ViewDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat) +void ViewDriver::FillArc(const BRect r, float angle, float span, const Pattern& pat, RGBColor& high_color, RGBColor& low_color) +{ + Lock(); + screenwin->Lock(); + framebuffer->Lock(); + + drawview->SetDrawingMode(B_OP_COPY); + drawview->SetHighColor(high_color.GetColor32()); + drawview->SetLowColor(low_color.GetColor32()); + + drawview->FillArc(r,angle,span,*((pattern*)pat.GetInt8()) ); + drawview->Sync(); + screenwin->view->Invalidate(r); + framebuffer->Unlock(); + screenwin->Unlock(); + Unlock(); +} + +void ViewDriver::FillBezier(BPoint *pts, RGBColor& color) { if(!pts) return; + Lock(); screenwin->Lock(); framebuffer->Lock(); - SetLayerData(d); + drawview->SetDrawingMode(B_OP_COPY); + drawview->SetHighColor(color.GetColor32()); + drawview->SetLowColor(color.GetColor32()); + drawview->FillBezier(pts,B_SOLID_HIGH); + drawview->Sync(); + + // Invalidate the whole view until I get around to adding in the invalid rect calc code + screenwin->view->Invalidate(); + framebuffer->Unlock(); + screenwin->Unlock(); + + Unlock(); +} + +void ViewDriver::FillBezier(BPoint *pts, const Pattern& pat, RGBColor& high_color, RGBColor& low_color) +{ + if(!pts) + return; + Lock(); + screenwin->Lock(); + framebuffer->Lock(); + drawview->SetDrawingMode(B_OP_COPY); + drawview->SetHighColor(high_color.GetColor32()); + drawview->SetLowColor(low_color.GetColor32()); drawview->FillBezier(pts,*((pattern*)pat.GetInt8())); drawview->Sync(); @@ -837,81 +886,498 @@ void ViewDriver::FillBezier(BPoint *pts, LayerData *d, const Pattern &pat) screenwin->view->Invalidate(); framebuffer->Unlock(); screenwin->Unlock(); + + Unlock(); } -void ViewDriver::FillEllipse(BRect r, LayerData *d, const Pattern &pat) +void ViewDriver::FillEllipse(BRect r, RGBColor& color) { - if(!d) - return; + Lock(); 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) - return; + Lock(); screenwin->Lock(); framebuffer->Lock(); - SetLayerData(d); - drawview->FillPolygon(ptlist,numpts,rect,*((pattern*)pat.GetInt8())); + drawview->SetDrawingMode(B_OP_COPY); + 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) - return; + Lock(); 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) - return; + Lock(); 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) - return; + Lock(); screenwin->Lock(); framebuffer->Lock(); - BPoint first=pts[0],second=pts[1],third=pts[2]; - SetLayerData(d); - drawview->FillTriangle(first,second,third,r,*((pattern*)pat.GetInt8())); + drawview->SetDrawingMode(B_OP_COPY); + drawview->SetHighColor(color.GetColor32()); + 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;iAddLine(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; iAddLine(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; iSetHighColor(col); - drawview->StrokeLine(pt1,pt2,B_SOLID_HIGH); - - } -*/ - - int32 ptindex=0; - - drawview->BeginLineArray(numlines); - for(int32 i=0; iAddLine(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;iAddLine(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) diff --git a/src/servers/app/server/ViewDriver.h b/src/servers/app/server/ViewDriver.h index 2dcdefb1fc..fe737c4cfa 100644 --- a/src/servers/app/server/ViewDriver.h +++ b/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); - void StrokeBezier(BPoint *pts, LayerData *d, const Pattern &pat); - void StrokeEllipse(BRect r, LayerData *d, const Pattern &pat); - void StrokeLine(BPoint start, BPoint end, LayerData *d, const Pattern &pat); - void StrokeLineArray(BPoint *pts, int32 numlines, RGBColor *colors, LayerData *d); - void StrokePolygon(BPoint *ptlist, int32 numpts, BRect rect, LayerData *d, const Pattern &pat, bool is_closed=true); - void StrokeRect(BRect r, LayerData *d, const Pattern &pat); - void StrokeRoundRect(BRect r, float xrad, float yrad, LayerData *d, const Pattern &pat); -// void StrokeShape(SShape *sh, LayerData *d, const Pattern &pat); - void StrokeTriangle(BPoint *pts, 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); + void SetMode(int32 mode); float StringWidth(const char *string, int32 length, LayerData *d); float StringHeight(const char *string, int32 length, LayerData *d);