From 4157339be2db6cf82b7fb37304db96e137252427 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stephan=20A=C3=9Fmus?= Date: Sat, 26 Mar 2005 22:09:02 +0000 Subject: [PATCH] started to implement stuff, it can actually be used and renders my test app almost like the old implementation, plus clipping git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@12050 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../app/drawing/DisplayDriverPainter.cpp | 459 ++++++++++++++---- .../app/drawing/DisplayDriverPainter.h | 14 +- 2 files changed, 366 insertions(+), 107 deletions(-) diff --git a/src/servers/app/drawing/DisplayDriverPainter.cpp b/src/servers/app/drawing/DisplayDriverPainter.cpp index 1e5372cc9c..33ebfc1f0d 100644 --- a/src/servers/app/drawing/DisplayDriverPainter.cpp +++ b/src/servers/app/drawing/DisplayDriverPainter.cpp @@ -26,17 +26,24 @@ //------------------------------------------------------------------------------ #include +#include "Painter.h" +#include "RenderingBuffer.h" +#include "ViewHWInterface.h" + #include "DisplayDriverPainter.h" // constructor DisplayDriverPainter::DisplayDriverPainter() - : DisplayDriver() + : DisplayDriver(), + fPainter(new Painter()), + fGraphicsCard(new ViewHWInterface()) { } // destructor DisplayDriverPainter::~DisplayDriverPainter() { + delete fGraphicsCard; } // Initialize @@ -82,7 +89,8 @@ DisplayDriverPainter::InvertRect(const BRect &r) { if (Lock()) { - fPainter.InvertRect(r); + fPainter->InvertRect(r); + fGraphicsCard->Invalidate(r); Unlock(); } @@ -94,22 +102,147 @@ DisplayDriverPainter::DrawBitmap(BRegion *region, ServerBitmap *bitmap, const BRect &source, const BRect &dest, const DrawData *d) { - if (region && Lock()) { + // catch PicturePlayer giving us a NULL region + if (!region) + return; - fPainter.ConstrainClipping(*region); - fPainter.SetDrawData(d); - fPainter.DrawBitmap(bitmap, source, dest); + if (Lock()) { + + fPainter->ConstrainClipping(*region); + fPainter->SetDrawData(d); + fPainter->DrawBitmap(bitmap, source, dest); + + fGraphicsCard->Invalidate(dest); Unlock(); } } +// used to move windows arround on screen +// // CopyRegionList void DisplayDriverPainter::CopyRegionList(BList* list, BList* pList, int32 rCount, BRegion* clipReg) { - fprintf(stdout, "DisplayDriverPainter::CopyRegionList()\b"); + if (!clipReg || !Lock()) + return; + +// This is the same implementation as in DisplayDriverImpl for now + +// since we're not using painter.... this won't do much good, will it? +// fPainter->ConstrainClipping(*clipReg); + + RenderingBuffer* bmp = fGraphicsCard->BackBuffer(); + + uint32 bytesPerPixel = bmp->BytesPerRow() / bmp->Width(); + BList rectList; + int32 i, k; + uint8 *bitmapBits = (uint8*)bmp->Bits(); + int32 Bwidth = bmp->Width(); + int32 Bheight = bmp->Height(); + + BRect updateRect; + + for (k = 0; k < rCount; k++) { + BRegion* reg = (BRegion*)list->ItemAt(k); + + int32 rectCount = reg->CountRects(); + for(i=0; i < rectCount; i++) { + BRect r = reg->RectAt(i); + uint8 *rectCopy; + uint8 *srcAddress; + uint8 *destAddress; + int32 firstRow, lastRow; + int32 firstCol, lastCol; + int32 copyLength; + int32 copyRows; + + firstRow = (int32)(r.top < 0? 0: r.top); + lastRow = (int32)(r.bottom > (Bheight-1)? (Bheight-1): r.bottom); + firstCol = (int32)(r.left < 0? 0: r.left); + lastCol = (int32)(r.right > (Bwidth-1)? (Bwidth-1): r.right); + copyLength = (lastCol - firstCol + 1) < 0? 0: (lastCol - firstCol + 1); + copyRows = (lastRow - firstRow + 1) < 0? 0: (lastRow - firstRow + 1); + + rectCopy = (uint8*)malloc(copyLength * copyRows * bytesPerPixel); + + srcAddress = bitmapBits + (((firstRow) * Bwidth + firstCol) * bytesPerPixel); + destAddress = rectCopy; + + for (int32 j = 0; j < copyRows; j++) { + uint8 *destRowAddress = destAddress + (j * copyLength * bytesPerPixel); + uint8 *srcRowAddress = srcAddress + (j * Bwidth * bytesPerPixel); + memcpy(destRowAddress, srcRowAddress, copyLength * bytesPerPixel ); + } + + rectList.AddItem(rectCopy); + } + } + + int32 item = 0; + for(k = 0; k < rCount; k++) { + BRegion* reg = (BRegion*)list->ItemAt(k); + + int32 rectCount = reg->CountRects(); + for(i=0; i < rectCount; i++) + { + BRect r = reg->RectAt(i); + uint8 *rectCopy; + uint8 *srcAddress; + uint8 *destAddress; + int32 firstRow, lastRow; + int32 firstCol, lastCol; + int32 copyLength, copyLength2; + int32 copyRows, copyRows2; + + firstRow = (int32)(r.top < 0? 0: r.top); + lastRow = (int32)(r.bottom > (Bheight-1)? (Bheight-1): r.bottom); + firstCol = (int32)(r.left < 0? 0: r.left); + lastCol = (int32)(r.right > (Bwidth-1)? (Bwidth-1): r.right); + copyLength = (lastCol - firstCol + 1) < 0? 0: (lastCol - firstCol + 1); + copyRows = (lastRow - firstRow + 1) < 0? 0: (lastRow - firstRow + 1); + + rectCopy = (uint8*)rectList.ItemAt(item++); + + srcAddress = rectCopy; + + r.Set(firstCol, firstRow, lastCol, lastRow); + r.OffsetBy( *((BPoint*)pList->ItemAt(k%rCount)) ); + + // keep track of invalid area + updateRect = updateRect.IsValid() ? updateRect | r : r; + + firstRow = (int32)(r.top < 0? 0: r.top); + lastRow = (int32)(r.bottom > (Bheight-1)? (Bheight-1): r.bottom); + firstCol = (int32)(r.left < 0? 0: r.left); + lastCol = (int32)(r.right > (Bwidth-1)? (Bwidth-1): r.right); + copyLength2 = (lastCol - firstCol + 1) < 0? 0: (lastCol - firstCol + 1); + copyRows2 = (lastRow - firstRow + 1) < 0? 0: (lastRow - firstRow + 1); + + destAddress = bitmapBits + (((firstRow) * Bwidth + firstCol) * bytesPerPixel); + + int32 minLength = copyLength < copyLength2? copyLength: copyLength2; + int32 minRows = copyRows < copyRows2? copyRows: copyRows2; + + for (int32 j = 0; j < minRows; j++) + { + uint8 *destRowAddress = destAddress + (j * Bwidth * bytesPerPixel); + uint8 *srcRowAddress = srcAddress + (j * copyLength * bytesPerPixel); + memcpy(destRowAddress, srcRowAddress, minLength * bytesPerPixel ); + } + } + } + + int32 count = rectList.CountItems(); + for (i = 0; i < count; i++) { + if (void* rectCopy = rectList.ItemAt(i)) + free(rectCopy); + } + + fGraphicsCard->Invalidate(updateRect); + + Unlock(); } // FillArc @@ -117,10 +250,18 @@ void DisplayDriverPainter::FillArc(const BRect &r, const float &angle, const float &span, const DrawData *d) { - if (region && Lock()) { + if (Lock()) { - fPainter.SetDrawData(d); - fPainter.DrawBitmap(bitmap, source, dest); + fPainter->SetDrawData(d); + + float xRadius = r.Width() / 2.0; + float yRadius = r.Width() / 2.0; + BPoint center(r.left + xRadius, + r.top + yRadius); + + fPainter->FillArc(center, xRadius, yRadius, angle, span); + + fGraphicsCard->Invalidate(r); Unlock(); } @@ -130,12 +271,37 @@ DisplayDriverPainter::FillArc(const BRect &r, const float &angle, void DisplayDriverPainter::FillBezier(BPoint *pts, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + + fPainter->FillBezier(pts); + + // TODO: Invalidate + + Unlock(); + } } // FillEllipse void DisplayDriverPainter::FillEllipse(const BRect &r, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + + float xRadius = r.Width() / 2.0; + float yRadius = r.Width() / 2.0; + BPoint center(r.left + xRadius, + r.top + yRadius); + + fPainter->FillEllipse(center, xRadius, yRadius); + + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // FillPolygon @@ -143,24 +309,68 @@ void DisplayDriverPainter::FillPolygon(BPoint *ptlist, int32 numpts, const BRect &bounds, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + fPainter->FillPolygon(ptlist, numpts); + + fGraphicsCard->Invalidate(bounds); + + Unlock(); + } } // FillRect void DisplayDriverPainter::FillRect(const BRect &r, const RGBColor &color) { + if (Lock()) { + + fPainter->SetHighColor(color); + fPainter->FillRect(r); + + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // FillRect void DisplayDriverPainter::FillRect(const BRect &r, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + fPainter->FillRect(r); + + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // FillRegion void DisplayDriverPainter::FillRegion(BRegion& r, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + + BRect invalid = r.RectAt(0); + fPainter->FillRect(invalid); + + int32 count = r.CountRects(); + for (int32 i = 1; i < count; i++) { + fPainter->FillRect(r.RectAt(i)); + invalid = invalid | r.RectAt(i); + } + + fGraphicsCard->Invalidate(invalid); + + Unlock(); + } } // FillRoundRect @@ -208,12 +418,32 @@ DisplayDriverPainter::StrokeEllipse(const BRect &r, const DrawData *d) void DisplayDriverPainter::StrokeLine(const BPoint &start, const BPoint &end, const RGBColor &color) { + if (Lock()) { + + fPainter->SetHighColor(color); + fPainter->StrokeLine(start, end); + + BRect r(start, end); + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // StrokeLine void DisplayDriverPainter::StrokeLine(const BPoint &start, const BPoint &end, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + fPainter->StrokeLine(start, end); + + BRect r(start, end); + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // used by decorator @@ -222,12 +452,14 @@ DisplayDriverPainter::StrokeLine(const BPoint &start, const BPoint &end, const D void DisplayDriverPainter::StrokePoint(const BPoint& pt, const RGBColor &color) { + StrokeLine(pt, pt, color); } // StrokePoint void DisplayDriverPainter::StrokePoint(const BPoint& pt, const DrawData *d) { + StrokeLine(pt, pt, d); } // StrokePolygon @@ -242,18 +474,53 @@ DisplayDriverPainter::StrokePolygon(BPoint *ptlist, int32 numpts, void DisplayDriverPainter::StrokeRect(const BRect &r, const RGBColor &color) { + if (Lock()) { + + fPainter->SetHighColor(color); + fPainter->StrokeRect(r); + + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // StrokeRect void DisplayDriverPainter::StrokeRect(const BRect &r, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + fPainter->StrokeRect(r); + + fGraphicsCard->Invalidate(r); + + Unlock(); + } } // StrokeRegion void DisplayDriverPainter::StrokeRegion(BRegion& r, const DrawData *d) { + if (Lock()) { + + fPainter->SetDrawData(d); + + BRect invalid = r.RectAt(0); + fPainter->StrokeRect(invalid); + + int32 count = r.CountRects(); + for (int32 i = 1; i < count; i++) { + fPainter->StrokeRect(r.RectAt(i)); + invalid = invalid | r.RectAt(i); + } + + fGraphicsCard->Invalidate(invalid); + + Unlock(); + } } // StrokeRoundRect @@ -284,6 +551,7 @@ DisplayDriverPainter::DrawString(const char *string, const int32 &length, const BPoint &pt, const RGBColor &color, escapement_delta *delta) { + // what - without any clipping?!? DrawData d; d.highcolor=color; @@ -297,6 +565,17 @@ void DisplayDriverPainter::DrawString(const char *string, const int32 &length, const BPoint &pt, DrawData *d) { + if (Lock()) { + fPainter->SetDrawData(d); + + BRect boundingBox = fPainter->BoundingBox(string, length, pt); + + fPainter->DrawString(string, length, pt); + + fGraphicsCard->Invalidate(boundingBox); + + Unlock(); + } } // StringWidth @@ -304,7 +583,14 @@ float DisplayDriverPainter::StringWidth(const char *string, int32 length, const DrawData *d) { - + float width = 0.0; + if (Lock()) { + fPainter->SetDrawData(d); + BPoint dummy(0.0, 0.0); + width = fPainter->BoundingBox(string, length, dummy).Width(); + Unlock(); + } + return width; } // StringHeight @@ -312,6 +598,14 @@ float DisplayDriverPainter::StringHeight(const char *string, int32 length, const DrawData *d) { + float height = 0.0; + if (Lock()) { + fPainter->SetDrawData(d); + BPoint dummy(0.0, 0.0); + height = fPainter->BoundingBox(string, length, dummy).Height(); + Unlock(); + } + return height; } // GetBoundingBoxes @@ -321,6 +615,8 @@ DisplayDriverPainter::GetBoundingBoxes(const char *string, int32 count, escapement_delta *delta, BRect *rectarray, const DrawData *d) { + // ?!? each glyph or what? + printf("DisplayDriverPainter::GetBoundingBoxes()\n"); } // GetEscapements @@ -331,6 +627,7 @@ DisplayDriverPainter::GetEscapements(const char *string, int32 charcount, escapement_delta *offsets, const DrawData *d) { + printf("DisplayDriverPainter::GetEscapements()\n"); } // GetEdges @@ -338,12 +635,14 @@ void DisplayDriverPainter::GetEdges(const char *string, int32 charcount, edge_info *edgearray, const DrawData *d) { + printf("DisplayDriverPainter::GetEdges()\n"); } // GetHasGlyphs void DisplayDriverPainter::GetHasGlyphs(const char *string, int32 charcount, bool *hasarray) { + printf("DisplayDriverPainter::GetHasGlyphs()\n"); } // GetTruncatedStrings @@ -354,6 +653,18 @@ DisplayDriverPainter::GetTruncatedStrings(const char **instrings, const float &maxwidth, char **outstrings) { + printf("DisplayDriverPainter::GetTruncatedStrings()\n"); +} + +// SetMode +void +DisplayDriverPainter::SetMode(const display_mode &mode) +{ + if (Lock() && fGraphicsCard->SetMode(mode) >= B_OK) { + fPainter->AttachToBuffer(fGraphicsCard->BackBuffer()); + DisplayDriver::SetMode(mode); + Unlock(); + } } // DumpToFile @@ -376,20 +687,43 @@ DisplayDriverPainter::StrokeLineArray(const int32 &numlines, const LineArrayData *linedata, const DrawData *d) { + // I'm suspecting this is not used + printf("DisplayDriverPainter::StrokeLineArray()\n"); +} + +// SetDPMSMode +status_t +DisplayDriverPainter::SetDPMSMode(const uint32 &state) +{ + return B_ERROR; +} + +// DPMSMode +uint32 +DisplayDriverPainter::DPMSMode() const +{ + return 0; +} + +// DPMSCapabilities +uint32 +DisplayDriverPainter::DPMSCapabilities() const +{ + return 0; } // GetDeviceInfo status_t DisplayDriverPainter::GetDeviceInfo(accelerant_device_info *info) { - return B_ERROR; + return fGraphicsCard->GetDeviceInfo(info); } // GetModeList status_t DisplayDriverPainter::GetModeList(display_mode **mode_list, uint32 *count) { - return B_UNSUPPORTED; + return fGraphicsCard->GetModeList(mode_list, count); } // GetPixelClockLimits @@ -397,14 +731,14 @@ status_t DisplayDriverPainter::GetPixelClockLimits(display_mode *mode, uint32 *low, uint32 *high) { - return B_UNSUPPORTED; + return fGraphicsCard->GetPixelClockLimits(mode, low, high); } // GetTimingConstraints status_t DisplayDriverPainter::GetTimingConstraints(display_timing_constraints *dtc) { - return B_UNSUPPORTED; + return fGraphicsCard->GetTimingConstraints(dtc); } // ProposeMode @@ -413,94 +747,14 @@ DisplayDriverPainter::ProposeMode(display_mode *candidate, const display_mode *low, const display_mode *high) { - return B_UNSUPPORTED; + return fGraphicsCard->ProposeMode(candidate, low, high); } // WaitForRetrace status_t DisplayDriverPainter::WaitForRetrace(bigtime_t timeout) { - return B_UNSUPPORTED; -} - -// _GetCursor -ServerCursor* -DisplayDriverPainter::_GetCursor() -{ - Lock(); - ServerCursor *c = fCursorHandler.GetCursor(); - Unlock(); - - return c; -} - -// HLinePatternThick -void -DisplayDriverPainter::HLinePatternThick(int32 x1, int32 x2, int32 y) -{ -} - -// VLinePatternThick -void -DisplayDriverPainter::VLinePatternThick(int32 x1, int32 x2, int32 y) -{ -} - -// SetThickPatternPixel -void -DisplayDriverPainter::SetThickPatternPixel(int x, int y) -{ -} - -// AcquireBuffer -bool -DisplayDriverPainter::AcquireBuffer(FBBitmap *bmp) -{ - return false; -} - -// ReleaseBuffer -void -DisplayDriverPainter::ReleaseBuffer() -{ -} - -// Blit -void -DisplayDriverPainter::Blit(const BRect &src, const BRect &dest, - const DrawData *d) -{ -} - -// FillSolidRect -void -DisplayDriverPainter::FillSolidRect(const BRect &rect, const RGBColor &color) -{ -} - -// FillPatternRect -void -DisplayDriverPainter::FillPatternRect(const BRect &rect, const DrawData *d) -{ -} - -// StrokeSolidLine -void -DisplayDriverPainter::StrokeSolidLine(int32 x1, int32 y1, - int32 x2, int32 y2, const RGBColor &color) -{ -} - -// StrokePatternLine -void -DisplayDriverPainter::StrokePatternLine(int32 x1, int32 y1, int32 x2, int32 y2, const DrawData *d) -{ -} - -// StrokeSolidRect -void -DisplayDriverPainter::StrokeSolidRect(const BRect &rect, const RGBColor &color) -{ + return fGraphicsCard->WaitForRetrace(timeout); } // CopyBitmap @@ -520,9 +774,18 @@ void DisplayDriverPainter::CopyToBitmap(ServerBitmap *target, // Invalidate void DisplayDriverPainter::Invalidate(const BRect &r) { + if (Lock()) { +// ?!? Does this implementation need this? + fGraphicsCard->Invalidate(r); + Unlock(); + } } // ConstrainClippingRegion -void DisplayDriverPainter::ConstrainClippingRegion(BRegion *reg) +void DisplayDriverPainter::ConstrainClippingRegion(BRegion *region) { + if (region && Lock()) { + fPainter->ConstrainClipping(*region); + Unlock(); + } } diff --git a/src/servers/app/drawing/DisplayDriverPainter.h b/src/servers/app/drawing/DisplayDriverPainter.h index fe7ca506d7..cd6f542beb 100644 --- a/src/servers/app/drawing/DisplayDriverPainter.h +++ b/src/servers/app/drawing/DisplayDriverPainter.h @@ -33,6 +33,9 @@ #include "DisplayDriver.h" +class HWInterface; +class Painter; + class DisplayDriverPainter : public DisplayDriver { public: DisplayDriverPainter(); @@ -225,16 +228,8 @@ class DisplayDriverPainter : public DisplayDriver { virtual bool IsCursorObscured(bool state);*/ - // These two will rarely be implemented by subclasses, - // but it still needs to be possible - virtual bool Lock(bigtime_t timeout = B_INFINITE_TIMEOUT); - virtual void Unlock(); - // display mode access virtual void SetMode(const display_mode &mode); - void GetMode(display_mode *mode); - inline const display_mode* DisplayMode() const - { return &fDisplayMode; } virtual bool DumpToFile(const char *path); virtual ServerBitmap* DumpToBitmap(); @@ -282,7 +277,8 @@ class DisplayDriverPainter : public DisplayDriver { virtual void ConstrainClippingRegion(BRegion *reg); private: - Painter fPainter; + Painter* fPainter; + HWInterface* fGraphicsCard; }; #endif // _DISPLAY_DRIVER_PAINTER_H_