/**
@pre CWsSpriteBase::CalcRedrawRegion(TRegion&,TRegion&) should have been called.
@param aRegion Is the region that will definitely be redrawn if dirty. This param should
be calculated by calling CalcRedrawRegion(TRegion&,TRegion&)
*/
void CWsSpriteBase::Redraw(MWsGraphicsContext * aGc, const TRegion& aRegion)
{
TFlashState currentState=EFlashOn;
if(IsFlashingEnabled())
{
currentState=Screen()->SpriteManager()->CurrentSpriteFlashState(this);
AnnotateSpriteFlash(*this, currentState==EFlashOn);
}
if(currentState==EFlashOn && (IsDirty() || HasAnimation()) )
{
const TRegion * pr = &aRegion;
if (pr->CheckError())
{
if(iWin)
{
if (Screen()->ChangeTracking())
pr = &iWin->WindowArea();
else
pr = &iWin->VisibleRegion();
}
else
pr = &RootWindow()->WindowArea();
}
if (!pr->IsEmpty())
{
CWsSpriteMember *member=(*iMembers)[iCurIndex];
if (member->iBitmap)
{
aGc->SetClippingRegion(*pr);
// Calculate which piece (rect) of the bitmap needs to be drawn
const TRect redrawRect = pr->BoundingRect();
TRect bitmapRect(Pos(), iSize); // sprite rect relative to screen
bitmapRect.Intersection(redrawRect);
bitmapRect.Move(-Pos()); // adjust relative to bitmap origin
if (member->iMaskBitmap)
aGc->BitBltMasked(Pos() + bitmapRect.iTl, *member->iBitmap, bitmapRect, *member->iMaskBitmap, member->iInvertMask);
else
{
aGc->SetDrawMode(BitGdiToMWsGraphicsContextMappings::LossyConvert(member->iDrawMode));
aGc->BitBlt(Pos() + bitmapRect.iTl, *member->iBitmap, bitmapRect);
aGc->SetDrawMode(MWsGraphicsContext::EDrawModePEN);
}
aGc->ResetClippingRegion();
}
}
if (Screen()->ChangeTracking())
SetDirty(EFalse);
}
//Flashing sprites need to reschedule themselves after drawing (unless they have
//an animation, because for animating sprites the rescheduling is done in CWsAnim).
if(IsFlashingEnabled() && !HasAnimation())
Screen()->SpriteManager()->Schedule(this);
}
void DIBPixelData::setRGBABitmapAlpha(HDC hdc, const IntRect& dstRect, unsigned char level)
{
HBITMAP bitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
DIBPixelData pixelData(bitmap);
ASSERT(pixelData.bitsPerPixel() == 32);
IntRect drawRect(dstRect);
XFORM trans;
GetWorldTransform(hdc, &trans);
IntSize transformedPosition(trans.eDx, trans.eDy);
drawRect.move(transformedPosition);
int pixelDataWidth = pixelData.size().width();
int pixelDataHeight = pixelData.size().height();
IntRect bitmapRect(0, 0, pixelDataWidth, pixelDataHeight);
drawRect.intersect(bitmapRect);
if (drawRect.isEmpty())
return;
RGBQUAD* bytes = reinterpret_cast<RGBQUAD*>(pixelData.buffer());
bytes += drawRect.y() * pixelDataWidth;
size_t width = drawRect.width();
size_t height = drawRect.height();
int x = drawRect.x();
for (size_t i = 0; i < height; i++) {
RGBQUAD* p = bytes + x;
for (size_t j = 0; j < width; j++) {
p->rgbReserved = level;
p++;
}
bytes += pixelDataWidth;
}
}
reg_t GfxText32::createFontBitmap(const CelInfo32 &celInfo, const Common::Rect &rect, const Common::String &text, const int16 foreColor, const int16 backColor, const GuiResourceId fontId, const int16 skipColor, const int16 borderColor, const bool dimmed, const bool gc) {
_borderColor = borderColor;
_text = text;
_textRect = rect;
_foreColor = foreColor;
_dimmed = dimmed;
setFont(fontId);
int16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
int16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
mulinc(_textRect, Ratio(_xResolution, scriptWidth), Ratio(_yResolution, scriptHeight));
CelObjView view(celInfo.resourceId, celInfo.loopNo, celInfo.celNo);
_skipColor = view._skipColor;
_width = view._width * _xResolution / view._xResolution;
_height = view._height * _yResolution / view._yResolution;
Common::Rect bitmapRect(_width, _height);
if (_textRect.intersects(bitmapRect)) {
_textRect.clip(bitmapRect);
} else {
_textRect = Common::Rect();
}
SciBitmap &bitmap = *_segMan->allocateBitmap(&_bitmap, _width, _height, _skipColor, 0, 0, _xResolution, _yResolution, 0, false, gc);
// NOTE: The engine filled the bitmap pixels with 11 here, which is silly
// because then it just erased the bitmap using the skip color. So we don't
// fill the bitmap redundantly here.
_backColor = _skipColor;
erase(bitmapRect, false);
_backColor = backColor;
view.draw(bitmap.getBuffer(), bitmapRect, Common::Point(0, 0), false, Ratio(_xResolution, view._xResolution), Ratio(_yResolution, view._yResolution));
if (_backColor != skipColor && _foreColor != skipColor) {
erase(_textRect, false);
}
if (text.size() > 0) {
if (_foreColor == skipColor) {
error("TODO: Implement transparent text");
} else {
if (borderColor != -1) {
drawFrame(bitmapRect, 1, _borderColor, false);
}
drawTextBox();
}
}
return _bitmap;
}
reg_t GfxText32::createFontBitmap(int16 width, int16 height, const Common::Rect &rect, const Common::String &text, const uint8 foreColor, const uint8 backColor, const uint8 skipColor, const GuiResourceId fontId, const TextAlign alignment, const int16 borderColor, const bool dimmed, const bool doScaling, reg_t *outBitmapObject) {
_field_22 = 0;
_borderColor = borderColor;
_text = text;
_textRect = rect;
_width = width;
_height = height;
_foreColor = foreColor;
_backColor = backColor;
_skipColor = skipColor;
_alignment = alignment;
_dimmed = dimmed;
setFont(fontId);
if (doScaling) {
int16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
int16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
Ratio scaleX(_scaledWidth, scriptWidth);
Ratio scaleY(_scaledHeight, scriptHeight);
_width = (_width * scaleX).toInt();
_height = (_height * scaleY).toInt();
mulinc(_textRect, scaleX, scaleY);
}
// _textRect represents where text is drawn inside the
// bitmap; clipRect is the entire bitmap
Common::Rect bitmapRect(_width, _height);
if (_textRect.intersects(bitmapRect)) {
_textRect.clip(bitmapRect);
} else {
_textRect = Common::Rect();
}
_bitmap = _segMan->allocateHunkEntry("FontBitmap()", _width * _height + BITMAP_HEADER_SIZE);
byte *bitmap = _segMan->getHunkPointer(_bitmap);
buildBitmapHeader(bitmap, _width, _height, _skipColor, 0, 0, _scaledWidth, _scaledHeight, 0, false);
erase(bitmapRect, false);
if (_borderColor > -1) {
drawFrame(bitmapRect, 1, _borderColor, false);
}
drawTextBox();
*outBitmapObject = _bitmap;
return _bitmap;
}
CamStatusView::CamStatusView(Controller* controller)
:
BView("CamStatusView", B_WILL_DRAW|B_PULSE_NEEDED),
fController(controller),
fStringView(NULL),
fBitmapView(NULL),
fEncodingStringView(NULL),
fStatusBar(NULL),
fNumFrames(0),
fRecording(false),
fPaused(false),
fRecordingBitmap(NULL),
fPauseBitmap(NULL)
{
BCardLayout* cardLayout = new BCardLayout();
SetLayout(cardLayout);
BRect bitmapRect(0, 0, kBitmapSize, kBitmapSize);
fRecordingBitmap = new BBitmap(bitmapRect, B_RGBA32);
fPauseBitmap = new BBitmap(bitmapRect, B_RGBA32);
BView* statusView = BLayoutBuilder::Group<>()
.SetInsets(0)
.Add(fEncodingStringView = new BStringView("stringview", kEncodingString))
.Add(fStatusBar = new BStatusBar("", ""))
.View();
fStatusBar->SetExplicitMinSize(BSize(100, 20));
BView* layoutView = BLayoutBuilder::Group<>()
.SetInsets(0)
.Add(fBitmapView = new SquareBitmapView("bitmap view"))
.Add(fStringView = new BStringView("cam string view", ""))
.View();
cardLayout->AddView(layoutView);
cardLayout->AddView(statusView);
fBitmapView->SetBitmap(NULL);
BFont font;
GetFont(&font);
float scaledSize = kBitmapSize * (capped_size(font.Size()) / 12);
fBitmapView->SetExplicitMinSize(BSize(scaledSize, scaledSize));
fBitmapView->SetExplicitMaxSize(BSize(scaledSize, scaledSize));
fBitmapView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP));
fStringView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_MIDDLE));
cardLayout->SetVisibleItem(int32(0));
}
reg_t GfxText32::createFontBitmap(int16 width, int16 height, const Common::Rect &rect, const Common::String &text, const uint8 foreColor, const uint8 backColor, const uint8 skipColor, const GuiResourceId fontId, const TextAlign alignment, const int16 borderColor, const bool dimmed, const bool doScaling, const bool gc) {
_borderColor = borderColor;
_text = text;
_textRect = rect;
_width = width;
_height = height;
_foreColor = foreColor;
_backColor = backColor;
_skipColor = skipColor;
_alignment = alignment;
_dimmed = dimmed;
setFont(fontId);
if (doScaling) {
int16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
int16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
Ratio scaleX(_xResolution, scriptWidth);
Ratio scaleY(_yResolution, scriptHeight);
_width = (_width * scaleX).toInt();
_height = (_height * scaleY).toInt();
mulinc(_textRect, scaleX, scaleY);
}
// _textRect represents where text is drawn inside the
// bitmap; clipRect is the entire bitmap
Common::Rect bitmapRect(_width, _height);
if (_textRect.intersects(bitmapRect)) {
_textRect.clip(bitmapRect);
} else {
_textRect = Common::Rect();
}
_segMan->allocateBitmap(&_bitmap, _width, _height, _skipColor, 0, 0, _xResolution, _yResolution, 0, false, gc);
erase(bitmapRect, false);
if (_borderColor > -1) {
drawFrame(bitmapRect, 1, _borderColor, false);
}
drawTextBox();
return _bitmap;
}
ScrollWindow::ScrollWindow(SegManager *segMan, const Common::Rect &gameRect, const Common::Point &position, const reg_t plane, const uint8 defaultForeColor, const uint8 defaultBackColor, const GuiResourceId defaultFontId, const TextAlign defaultAlignment, const int16 defaultBorderColor, const uint16 maxNumEntries) :
_segMan(segMan),
_gfxText32(segMan, g_sci->_gfxCache),
_maxNumEntries(maxNumEntries),
_firstVisibleChar(0),
_topVisibleLine(0),
_lastVisibleChar(0),
_bottomVisibleLine(0),
_numLines(0),
_numVisibleLines(0),
_plane(plane),
_foreColor(defaultForeColor),
_backColor(defaultBackColor),
_borderColor(defaultBorderColor),
_fontId(defaultFontId),
_alignment(defaultAlignment),
_visible(false),
_position(position),
_screenItem(nullptr),
_nextEntryId(1) {
_entries.reserve(maxNumEntries);
_gfxText32.setFont(_fontId);
_pointSize = _gfxText32._font->getHeight();
const uint16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
const uint16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
Common::Rect bitmapRect(gameRect);
mulinc(bitmapRect, Ratio(_gfxText32._scaledWidth, scriptWidth), Ratio(_gfxText32._scaledHeight, scriptHeight));
_textRect.left = 2;
_textRect.top = 2;
_textRect.right = bitmapRect.width() - 2;
_textRect.bottom = bitmapRect.height() - 2;
uint8 skipColor = 0;
while (skipColor == _foreColor || skipColor == _backColor) {
skipColor++;
}
assert(bitmapRect.width() > 0 && bitmapRect.height() > 0);
_bitmap = _gfxText32.createFontBitmap(bitmapRect.width(), bitmapRect.height(), _textRect, "", _foreColor, _backColor, skipColor, _fontId, _alignment, _borderColor, false, false, false);
debugC(1, kDebugLevelGraphics, "New ScrollWindow: textRect size: %d x %d, bitmap: %04x:%04x", _textRect.width(), _textRect.height(), PRINT_REG(_bitmap));
}
/********************************************************************************************
> BOOL TipsDlg::DrawBitmap(ResourceID BitmapID, DocRect& RedrawRect)
Author: Colin_Barfoot (Xara Group Ltd) <*****@*****.**>
Created: 08/08/96
Inputs: BitmapID : the resource id of the bitmap to draw
RedrawRect : the rectangle in which to draw it
Returns: TRUE if drawn OK
FALSE otherwise
Purpose: Renders the given bitmap in the given rectangle
********************************************************************************************/
BOOL TipsDlg::DrawBitmap(ResourceID BitmapID, DocRect& RedrawRect)
{
OILBitmap *pOILBitmap = OILBitmap::Create();
if (pOILBitmap == NULL)
{
return FALSE;
}
if (!pOILBitmap->LoadBitmap(BitmapID))
{
return FALSE;
}
// Centre the bitmap within the RedrawRect
UINT32 bitmapWidth = pOILBitmap->GetRecommendedWidth();
UINT32 bitmapHeight = pOILBitmap->GetRecommendedHeight();
UINT32 xOffset = RedrawRect.lo.x + (RedrawRect.Width() - bitmapWidth) / 2;
UINT32 yOffset = RedrawRect.lo.y + (RedrawRect.Height() - bitmapHeight) / 2;
DocCoord lowCorner(xOffset, yOffset);
DocRect bitmapRect(lowCorner, bitmapWidth, bitmapHeight);
KernelBitmap bitmap(pOILBitmap, TRUE);
// Now we need to create a temporary NodeBitmap, which we will
// use to render the bitmap preview.
NodeBitmap* dummyNode = new NodeBitmap();
if (dummyNode == NULL)
{
return FALSE;
}
// Set the NodeBitmap path to be our RedrawRect and attach the Bitmap to it.
dummyNode->SetUpPath();
dummyNode->CreateShape(bitmapRect);
dummyNode->GetBitmapRef()->SetBitmap(&bitmap);
// Now render the bitmap preview
dummyNode->Render(m_pRenderer);
delete dummyNode;
// All OK
return TRUE;
}
reg_t GfxText32::createFontBitmap(const CelInfo32 &celInfo, const Common::Rect &rect, const Common::String &text, const int16 foreColor, const int16 backColor, const GuiResourceId fontId, const int16 skipColor, const int16 borderColor, const bool dimmed, reg_t *outBitmapObject) {
_field_22 = 0;
_borderColor = borderColor;
_text = text;
_textRect = rect;
_foreColor = foreColor;
_dimmed = dimmed;
setFont(fontId);
int16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
int16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
int borderSize = 1;
mulinc(_textRect, Ratio(_scaledWidth, scriptWidth), Ratio(_scaledHeight, scriptHeight));
CelObjView view(celInfo.resourceId, celInfo.loopNo, celInfo.celNo);
_skipColor = view._transparentColor;
_width = view._width * _scaledWidth / view._scaledWidth;
_height = view._height * _scaledHeight / view._scaledHeight;
Common::Rect bitmapRect(_width, _height);
if (_textRect.intersects(bitmapRect)) {
_textRect.clip(bitmapRect);
} else {
_textRect = Common::Rect();
}
_bitmap = _segMan->allocateHunkEntry("FontBitmap()", _width * _height + CelObjMem::getBitmapHeaderSize());
byte *bitmap = _segMan->getHunkPointer(_bitmap);
CelObjMem::buildBitmapHeader(bitmap, _width, _height, _skipColor, 0, 0, _scaledWidth, _scaledHeight, 0, false);
Buffer buffer(_width, _height, bitmap + READ_SCI11ENDIAN_UINT32(bitmap + 28));
// NOTE: The engine filled the bitmap pixels with 11 here, which is silly
// because then it just erased the bitmap using the skip color. So we don't
// fill the bitmap redundantly here.
_backColor = _skipColor;
erase(bitmapRect, false);
_backColor = backColor;
view.draw(buffer, bitmapRect, Common::Point(0, 0), false, Ratio(_scaledWidth, view._scaledWidth), Ratio(_scaledHeight, view._scaledHeight));
if (_backColor != skipColor && _foreColor != skipColor) {
erase(_textRect, false);
}
if (text.size() > 0) {
if (_foreColor == skipColor) {
error("TODO: Implement transparent text");
} else {
if (borderColor != -1) {
drawFrame(bitmapRect, borderSize, _borderColor, false);
}
drawTextBox();
}
}
*outBitmapObject = _bitmap;
return _bitmap;
}
