status_t MesaDriver::CopyPixelsIn(BBitmap *bitmap, BPoint location)
{
color_space scs = bitmap->ColorSpace();
color_space dcs = m_bitmap->ColorSpace();
if (scs != dcs && (dcs != B_RGBA32 || scs != B_RGB32)) {
printf("CopyPixelsIn(): incompatible color space: %s != %s\n",
color_space_name(scs),
color_space_name(dcs));
return B_BAD_TYPE;
}
// debugger("CopyPixelsIn()");
BRect sr = bitmap->Bounds();
BRect dr = m_bitmap->Bounds();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8 *ps = (uint8 *) bitmap->Bits();
uint8 *pd = (uint8 *) m_bitmap->Bits();
uint32 *s, *d;
uint32 y;
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
s = (uint32 *) (ps + y * bitmap->BytesPerRow());
s += (uint32) sr.left;
d = (uint32 *) (pd + (y + (uint32) (dr.top - sr.top)) * m_bitmap->BytesPerRow());
d += (uint32) dr.left;
memcpy(d, s, dr.IntegerWidth() * 4);
}
return B_OK;
}
void BWebPage::scroll(int xOffset, int yOffset, const BRect& rectToScroll,
const BRect& clipRect)
{
if (!fWebView->LockLooper())
return;
BBitmap* bitmap = fWebView->OffscreenBitmap();
BView* offscreenView = fWebView->OffscreenView();
// Lock the offscreen bitmap while we still have the
// window locked. This cannot deadlock and makes sure
// the window is not deleting the offscreen view right
// after we unlock it and before locking the bitmap.
if (!bitmap->Lock()) {
fWebView->UnlockLooper();
return;
}
fWebView->UnlockLooper();
BRect clip = offscreenView->Bounds();
if (clipRect.IsValid())
clip = clip & clipRect;
BRect rectAtSrc = rectToScroll;
BRect rectAtDst = rectAtSrc.OffsetByCopy(xOffset, yOffset);
BRegion repaintRegion(rectAtSrc);
if (clip.Intersects(rectAtSrc) && clip.Intersects(rectAtDst)) {
// clip source rect
rectAtSrc = rectAtSrc & clip;
// clip dest rect
rectAtDst = rectAtDst & clip;
// move dest back over source and clip source to dest
rectAtDst.OffsetBy(-xOffset, -yOffset);
rectAtSrc = rectAtSrc & rectAtDst;
// remember the part that will be clean
rectAtDst.OffsetBy(xOffset, yOffset);
repaintRegion.Exclude(rectAtDst);
offscreenView->CopyBits(rectAtSrc, rectAtDst);
}
if (repaintRegion.Frame().IsValid()) {
WebCore::Frame* frame = fMainFrame->Frame();
WebCore::FrameView* view = frame->view();
// Make sure the view is layouted, since it will refuse to paint
// otherwise.
fLayoutingView = true;
view->layout(true);
fLayoutingView = false;
internalPaint(offscreenView, view, &repaintRegion);
}
bitmap->Unlock();
// Notify the view that it can now pull the bitmap in its own thread
fWebView->SetOffscreenViewClean(rectToScroll, false);
}
status_t
IntelRenderer::CopyPixelsIn(BBitmap *bitmap, BPoint location)
{
CALLED();
color_space sourceCS = bitmap->ColorSpace();
color_space destinationCS = fBitmap->ColorSpace();
if (sourceCS != destinationCS
&& (sourceCS != B_RGB32 || destinationCS != B_RGBA32)) {
ERROR("%s::CopyPixelsIn(): incompatible color space: %s != %s\n",
__PRETTY_FUNCTION__, color_space_name(sourceCS),
color_space_name(destinationCS));
return B_BAD_TYPE;
}
BRect sr = bitmap->Bounds();
BRect dr = fBitmap->Bounds();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8 *ps = (uint8 *) bitmap->Bits();
uint8 *pd = (uint8 *) fBitmap->Bits();
uint32 *s, *d;
uint32 y;
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
s = (uint32 *)(ps + y * bitmap->BytesPerRow());
s += (uint32) sr.left;
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
* fBitmap->BytesPerRow());
d += (uint32) dr.left;
memcpy(d, s, dr.IntegerWidth() * 4);
}
return B_OK;
}
status_t
SoftwareRenderer::CopyPixelsOut(BPoint location, BBitmap *bitmap)
{
CALLED();
color_space scs = fBitmap->ColorSpace();
color_space dcs = bitmap->ColorSpace();
if (scs != dcs && (scs != B_RGBA32 || dcs != B_RGB32)) {
ERROR("%s::CopyPixelsOut(): incompatible color space: %s != %s\n",
__PRETTY_FUNCTION__, color_space_name(scs), color_space_name(dcs));
return B_BAD_TYPE;
}
BRect sr = fBitmap->Bounds();
BRect dr = bitmap->Bounds();
// int32 w1 = sr.IntegerWidth();
// int32 h1 = sr.IntegerHeight();
// int32 w2 = dr.IntegerWidth();
// int32 h2 = dr.IntegerHeight();
sr = sr & dr.OffsetBySelf(location);
dr = sr.OffsetByCopy(-location.x, -location.y);
uint8 *ps = (uint8 *) fBitmap->Bits();
uint8 *pd = (uint8 *) bitmap->Bits();
uint32 *s, *d;
uint32 y;
for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
s = (uint32 *)(ps + y * fBitmap->BytesPerRow());
s += (uint32) sr.left;
d = (uint32 *)(pd + (y + (uint32)(dr.top - sr.top))
* bitmap->BytesPerRow());
d += (uint32) dr.left;
memcpy(d, s, dr.IntegerWidth() * 4);
}
return B_OK;
}
void
RemoteView::_DrawThread()
{
RemoteMessage reply(NULL, fSendBuffer);
RemoteMessage message(fReceiveBuffer, NULL);
// cursor
BPoint cursorHotSpot(0, 0);
while (!fStopThread) {
uint16 code;
status_t status = message.NextMessage(code);
if (status != B_OK) {
TRACE_ERROR("failed to read message from receiver\n");
break;
}
TRACE("code %u with %ld bytes data\n", code, message.DataLeft());
BAutolock locker(this->Looper());
if (!locker.IsLocked())
break;
// handle stuff that doesn't go to a specicifc engine
switch (code) {
case RP_INIT_CONNECTION:
{
uint16 port;
status_t result = message.Read(port);
if (result != B_OK) {
TRACE_ERROR("failed to read remote port\n");
continue;
}
BNetEndpoint *endpoint = fReceiver->Endpoint();
if (endpoint == NULL) {
TRACE_ERROR("receiver not connected anymore\n");
continue;
}
in_addr remoteHost;
char hostName[MAXHOSTNAMELEN + 1];
BNetAddress address(endpoint->RemoteAddr());
address.GetAddr(remoteHost);
address.GetAddr(hostName, NULL);
address.SetTo(remoteHost, port);
TRACE("connecting to host \"%s\" port %u\n", hostName, port);
result = fSendEndpoint->Connect(address);
if (result != B_OK) {
TRACE_ERROR("failed to connect to host \"%s\" port %u\n",
hostName, port);
continue;
}
BRect bounds = fOffscreenBitmap->Bounds();
reply.Start(RP_UPDATE_DISPLAY_MODE);
reply.Add(bounds.IntegerWidth() + 1);
reply.Add(bounds.IntegerHeight() + 1);
if (reply.Flush() == B_OK)
fIsConnected = true;
continue;
}
case RP_CLOSE_CONNECTION:
{
be_app->PostMessage(B_QUIT_REQUESTED);
continue;
}
case RP_CREATE_STATE:
case RP_DELETE_STATE:
{
uint32 token;
message.Read(token);
if (code == RP_CREATE_STATE)
_CreateState(token);
else
_DeleteState(token);
continue;
}
case RP_SET_CURSOR:
{
BBitmap *bitmap;
BPoint oldHotSpot = cursorHotSpot;
message.Read(cursorHotSpot);
if (message.ReadBitmap(&bitmap) != B_OK)
continue;
delete fCursorBitmap;
fCursorBitmap = bitmap;
Invalidate(fCursorFrame);
BRect bounds = fCursorBitmap->Bounds();
fCursorFrame.right = fCursorFrame.left
+ bounds.IntegerWidth() + 1;
fCursorFrame.bottom = fCursorFrame.bottom
+ bounds.IntegerHeight() + 1;
fCursorFrame.OffsetBy(oldHotSpot - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_SET_CURSOR_VISIBLE:
{
bool wasVisible = fCursorVisible;
message.Read(fCursorVisible);
if (wasVisible != fCursorVisible)
Invalidate(fCursorFrame);
continue;
}
case RP_MOVE_CURSOR_TO:
{
BPoint position;
message.Read(position);
if (fCursorVisible)
Invalidate(fCursorFrame);
fCursorFrame.OffsetTo(position - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_INVALIDATE_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
Invalidate(rect);
continue;
}
case RP_INVALIDATE_REGION:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
Invalidate(®ion);
continue;
}
case RP_FILL_REGION_COLOR_NO_CLIPPING:
{
BRegion region;
rgb_color color;
message.ReadRegion(region);
if (message.Read(color) != B_OK)
continue;
fOffscreen->LockLooper();
fOffscreen->SetHighColor(color);
fOffscreen->FillRegion(®ion);
fOffscreen->UnlockLooper();
Invalidate(®ion);
continue;
}
case RP_COPY_RECT_NO_CLIPPING:
{
int32 xOffset, yOffset;
BRect rect;
message.Read(xOffset);
message.Read(yOffset);
if (message.Read(rect) != B_OK)
continue;
BRect dest = rect.OffsetByCopy(xOffset, yOffset);
fOffscreen->LockLooper();
fOffscreen->CopyBits(rect, dest);
fOffscreen->UnlockLooper();
continue;
}
}
uint32 token;
message.Read(token);
engine_state *state = _FindState(token);
if (state == NULL) {
TRACE_ERROR("didn't find state for token %lu\n", token);
continue;
}
BView *offscreen = state->view;
::pattern &pattern = state->pattern;
BRegion &clippingRegion = state->clipping_region;
float &penSize = state->pen_size;
bool &syncDrawing = state->sync_drawing;
BRegion invalidRegion;
BAutolock offscreenLocker(offscreen->Looper());
if (!offscreenLocker.IsLocked())
break;
switch (code) {
case RP_ENABLE_SYNC_DRAWING:
syncDrawing = true;
continue;
case RP_DISABLE_SYNC_DRAWING:
syncDrawing = false;
continue;
case RP_SET_OFFSETS:
{
int32 xOffset, yOffset;
message.Read(xOffset);
if (message.Read(yOffset) != B_OK)
continue;
offscreen->MovePenTo(xOffset, yOffset);
break;
}
case RP_SET_HIGH_COLOR:
case RP_SET_LOW_COLOR:
{
rgb_color color;
if (message.Read(color) != B_OK)
continue;
if (code == RP_SET_HIGH_COLOR)
offscreen->SetHighColor(color);
else
offscreen->SetLowColor(color);
break;
}
case RP_SET_PEN_SIZE:
{
float newPenSize;
if (message.Read(newPenSize) != B_OK)
continue;
offscreen->SetPenSize(newPenSize);
penSize = newPenSize / 2;
break;
}
case RP_SET_STROKE_MODE:
{
cap_mode capMode;
join_mode joinMode;
float miterLimit;
message.Read(capMode);
message.Read(joinMode);
if (message.Read(miterLimit) != B_OK)
continue;
offscreen->SetLineMode(capMode, joinMode, miterLimit);
break;
}
case RP_SET_BLENDING_MODE:
{
source_alpha sourceAlpha;
alpha_function alphaFunction;
message.Read(sourceAlpha);
if (message.Read(alphaFunction) != B_OK)
continue;
offscreen->SetBlendingMode(sourceAlpha, alphaFunction);
break;
}
case RP_SET_PATTERN:
{
if (message.Read(pattern) != B_OK)
continue;
break;
}
case RP_SET_DRAWING_MODE:
{
drawing_mode drawingMode;
if (message.Read(drawingMode) != B_OK)
continue;
offscreen->SetDrawingMode(drawingMode);
break;
}
case RP_SET_FONT:
{
BFont font;
if (message.ReadFontState(font) != B_OK)
continue;
offscreen->SetFont(&font);
break;
}
case RP_CONSTRAIN_CLIPPING_REGION:
{
if (message.ReadRegion(clippingRegion) != B_OK)
continue;
offscreen->ConstrainClippingRegion(&clippingRegion);
break;
}
case RP_INVERT_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
offscreen->InvertRect(rect);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_BITMAP:
{
BBitmap *bitmap;
BRect bitmapRect, viewRect;
uint32 options;
message.Read(bitmapRect);
message.Read(viewRect);
message.Read(options);
if (message.ReadBitmap(&bitmap) != B_OK || bitmap == NULL)
continue;
offscreen->DrawBitmap(bitmap, bitmapRect, viewRect, options);
invalidRegion.Include(viewRect);
delete bitmap;
break;
}
case RP_DRAW_BITMAP_RECTS:
{
color_space colorSpace;
int32 rectCount;
uint32 flags, options;
message.Read(options);
message.Read(colorSpace);
message.Read(flags);
message.Read(rectCount);
for (int32 i = 0; i < rectCount; i++) {
BBitmap *bitmap;
BRect viewRect;
message.Read(viewRect);
if (message.ReadBitmap(&bitmap, true, colorSpace,
flags) != B_OK || bitmap == NULL) {
continue;
}
offscreen->DrawBitmap(bitmap, bitmap->Bounds(), viewRect,
options);
invalidRegion.Include(viewRect);
delete bitmap;
}
break;
}
case RP_STROKE_ARC:
case RP_FILL_ARC:
case RP_FILL_ARC_GRADIENT:
{
BRect rect;
float angle, span;
message.Read(rect);
message.Read(angle);
if (message.Read(span) != B_OK)
continue;
if (code == RP_STROKE_ARC) {
offscreen->StrokeArc(rect, angle, span, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ARC)
offscreen->FillArc(rect, angle, span, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillArc(rect, angle, span, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_BEZIER:
case RP_FILL_BEZIER:
case RP_FILL_BEZIER_GRADIENT:
{
BPoint points[4];
if (message.ReadList(points, 4) != B_OK)
continue;
BRect bounds = _BuildInvalidateRect(points, 4);
if (code == RP_STROKE_BEZIER) {
offscreen->StrokeBezier(points, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_BEZIER)
offscreen->FillBezier(points, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillBezier(points, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_ELLIPSE:
case RP_FILL_ELLIPSE:
case RP_FILL_ELLIPSE_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_ELLIPSE) {
offscreen->StrokeEllipse(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ELLIPSE)
offscreen->FillEllipse(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillEllipse(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_POLYGON:
case RP_FILL_POLYGON:
case RP_FILL_POLYGON_GRADIENT:
{
BRect bounds;
bool closed;
int32 numPoints;
message.Read(bounds);
message.Read(closed);
if (message.Read(numPoints) != B_OK)
continue;
BPoint points[numPoints];
for (int32 i = 0; i < numPoints; i++)
message.Read(points[i]);
if (code == RP_STROKE_POLYGON) {
offscreen->StrokePolygon(points, numPoints, bounds, closed,
pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_POLYGON)
offscreen->FillPolygon(points, numPoints, bounds, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillPolygon(points, numPoints, bounds,
*gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_RECT:
case RP_FILL_RECT:
case RP_FILL_RECT_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_RECT) {
offscreen->StrokeRect(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_RECT)
offscreen->FillRect(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRect(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_ROUND_RECT:
case RP_FILL_ROUND_RECT:
case RP_FILL_ROUND_RECT_GRADIENT:
{
BRect rect;
float xRadius, yRadius;
message.Read(rect);
message.Read(xRadius);
if (message.Read(yRadius) != B_OK)
continue;
if (code == RP_STROKE_ROUND_RECT) {
offscreen->StrokeRoundRect(rect, xRadius, yRadius,
pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ROUND_RECT)
offscreen->FillRoundRect(rect, xRadius, yRadius, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRoundRect(rect, xRadius, yRadius,
*gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_SHAPE:
case RP_FILL_SHAPE:
case RP_FILL_SHAPE_GRADIENT:
{
BRect bounds;
int32 opCount, pointCount;
message.Read(bounds);
if (message.Read(opCount) != B_OK)
continue;
BMessage archive;
for (int32 i = 0; i < opCount; i++) {
int32 op;
message.Read(op);
archive.AddInt32("ops", op);
}
if (message.Read(pointCount) != B_OK)
continue;
for (int32 i = 0; i < pointCount; i++) {
BPoint point;
message.Read(point);
archive.AddPoint("pts", point);
}
BPoint offset;
message.Read(offset);
float scale;
if (message.Read(scale) != B_OK)
continue;
offscreen->PushState();
offscreen->MovePenTo(offset);
offscreen->SetScale(scale);
BShape shape(&archive);
if (code == RP_STROKE_SHAPE) {
offscreen->StrokeShape(&shape, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_SHAPE)
offscreen->FillShape(&shape, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK) {
offscreen->PopState();
continue;
}
offscreen->FillShape(&shape, *gradient);
delete gradient;
}
offscreen->PopState();
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_TRIANGLE:
case RP_FILL_TRIANGLE:
case RP_FILL_TRIANGLE_GRADIENT:
{
BRect bounds;
BPoint points[3];
message.ReadList(points, 3);
if (message.Read(bounds) != B_OK)
continue;
if (code == RP_STROKE_TRIANGLE) {
offscreen->StrokeTriangle(points[0], points[1], points[2],
bounds, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_TRIANGLE) {
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, pattern);
} else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_LINE:
{
BPoint points[2];
if (message.ReadList(points, 2) != B_OK)
continue;
offscreen->StrokeLine(points[0], points[1], pattern);
BRect bounds = _BuildInvalidateRect(points, 2);
invalidRegion.Include(bounds.InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_ARRAY:
{
int32 numLines;
if (message.Read(numLines) != B_OK)
continue;
BRect bounds;
offscreen->BeginLineArray(numLines);
for (int32 i = 0; i < numLines; i++) {
rgb_color color;
BPoint start, end;
message.ReadArrayLine(start, end, color);
offscreen->AddLine(start, end, color);
bounds.left = min_c(bounds.left, min_c(start.x, end.x));
bounds.top = min_c(bounds.top, min_c(start.y, end.y));
bounds.right = max_c(bounds.right, max_c(start.x, end.x));
bounds.bottom = max_c(bounds.bottom, max_c(start.y, end.y));
}
offscreen->EndLineArray();
invalidRegion.Include(bounds);
break;
}
case RP_FILL_REGION:
case RP_FILL_REGION_GRADIENT:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
if (code == RP_FILL_REGION)
offscreen->FillRegion(®ion, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRegion(®ion, *gradient);
delete gradient;
}
invalidRegion.Include(®ion);
break;
}
case RP_STROKE_POINT_COLOR:
{
BPoint point;
rgb_color color;
message.Read(point);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
offscreen->StrokeLine(point, point);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(
BRect(point, point).InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_1PX_COLOR:
{
BPoint points[2];
rgb_color color;
message.ReadList(points, 2);
if (message.Read(color) != B_OK)
continue;
float oldSize = offscreen->PenSize();
rgb_color oldColor = offscreen->HighColor();
drawing_mode oldMode = offscreen->DrawingMode();
offscreen->SetPenSize(1);
offscreen->SetHighColor(color);
offscreen->SetDrawingMode(B_OP_OVER);
offscreen->StrokeLine(points[0], points[1]);
offscreen->SetDrawingMode(oldMode);
offscreen->SetHighColor(oldColor);
offscreen->SetPenSize(oldSize);
invalidRegion.Include(_BuildInvalidateRect(points, 2));
break;
}
case RP_STROKE_RECT_1PX_COLOR:
case RP_FILL_RECT_COLOR:
{
BRect rect;
rgb_color color;
message.Read(rect);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
if (code == RP_STROKE_RECT_1PX_COLOR) {
float oldSize = PenSize();
offscreen->SetPenSize(1);
offscreen->StrokeRect(rect);
offscreen->SetPenSize(oldSize);
} else
offscreen->FillRect(rect);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_STRING:
{
BPoint point;
size_t length;
char *string;
bool hasDelta;
message.Read(point);
message.ReadString(&string, length);
if (message.Read(hasDelta) != B_OK) {
free(string);
continue;
}
if (hasDelta) {
escapement_delta delta[length];
message.ReadList(delta, length);
offscreen->DrawString(string, point, delta);
} else
offscreen->DrawString(string, point);
free(string);
reply.Start(RP_DRAW_STRING_RESULT);
reply.Add(token);
reply.Add(offscreen->PenLocation());
reply.Flush();
font_height height;
offscreen->GetFontHeight(&height);
BRect bounds(point, offscreen->PenLocation());
bounds.top -= height.ascent;
bounds.bottom += height.descent;
invalidRegion.Include(bounds);
break;
}
case RP_DRAW_STRING_WITH_OFFSETS:
{
size_t length;
char *string;
message.ReadString(&string, length);
int32 count = UTF8CountChars(string, length);
BPoint offsets[count];
if (message.ReadList(offsets, count) != B_OK) {
free(string);
continue;
}
offscreen->DrawString(string, offsets, count);
free(string);
reply.Start(RP_DRAW_STRING_RESULT);
reply.Add(token);
reply.Add(offscreen->PenLocation());
reply.Flush();
BFont font;
offscreen->GetFont(&font);
BRect boxes[count];
font.GetBoundingBoxesAsGlyphs(string, count, B_SCREEN_METRIC,
boxes);
font_height height;
offscreen->GetFontHeight(&height);
for (int32 i = 0; i < count; i++) {
// TODO: validate
boxes[i].OffsetBy(offsets[i] + BPoint(0, -height.ascent));
invalidRegion.Include(boxes[i]);
}
break;
}
case RP_READ_BITMAP:
{
BRect bounds;
bool drawCursor;
message.Read(bounds);
if (message.Read(drawCursor) != B_OK)
continue;
// TODO: support the drawCursor flag
BBitmap bitmap(bounds, B_BITMAP_NO_SERVER_LINK, B_RGB32);
bitmap.ImportBits(fOffscreenBitmap, bounds.LeftTop(),
BPoint(0, 0), bounds.IntegerWidth() + 1,
bounds.IntegerHeight() + 1);
reply.Start(RP_READ_BITMAP_RESULT);
reply.Add(token);
reply.AddBitmap(&bitmap);
reply.Flush();
break;
}
default:
TRACE_ERROR("unknown protocol code: %u\n", code);
break;
}
if (syncDrawing) {
offscreen->Sync();
Invalidate(&invalidRegion);
}
}
}
void
DiskProbe::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgOpenOpenWindow:
if (fOpenWindow == NULL) {
fOpenWindow = new OpenWindow();
fOpenWindow->Show();
fWindowCount++;
} else
fOpenWindow->Activate(true);
break;
case kMsgOpenWindowClosed:
fOpenWindow = NULL;
// supposed to fall through
case kMsgWindowClosed:
if (--fWindowCount == 0 && !fFilePanel->IsShowing())
PostMessage(B_QUIT_REQUESTED);
break;
case kMsgSettingsChanged:
fSettings.UpdateFrom(message);
break;
case kMsgFindWindowClosed:
fFindWindow = NULL;
break;
case kMsgFindTarget:
{
BMessenger target;
if (message->FindMessenger("target", &target) != B_OK)
break;
if (fFindWindow != NULL && fFindWindow->Lock()) {
fFindWindow->SetTarget(target);
fFindWindow->Unlock();
}
break;
}
case kMsgOpenFindWindow:
{
BMessenger target;
if (message->FindMessenger("target", &target) != B_OK)
break;
if (fFindWindow == NULL) {
// open it!
fFindWindow = new FindWindow(fWindowFrame.OffsetByCopy(80, 80),
*message, target, &fSettings.Message());
fFindWindow->Show();
} else
fFindWindow->Activate();
break;
}
case kMsgOpenFilePanel:
fFilePanel->Show();
break;
case B_CANCEL:
if (fWindowCount == 0)
PostMessage(B_QUIT_REQUESTED);
break;
default:
BApplication::MessageReceived(message);
break;
}
}
ProjectSettingsWindow::ProjectSettingsWindow(BRect frame, Project *proj)
: DWindow(frame,TR("Project Settings"),B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE | B_NOT_H_RESIZABLE),
fProject(proj),
fDirty(false)
{
if (!fProject)
debugger("Bad project given to Project Settings window");
fRefFilter = new TypedRefFilter(NULL,B_DIRECTORY_NODE);
BMessenger msgr(this);
entry_ref projfolder_ref;
BEntry(fProject->GetPath().GetFolder()).GetRef(&projfolder_ref);
fFilePanel = new BFilePanel(B_OPEN_PANEL,&msgr,&projfolder_ref,B_DIRECTORY_NODE,
true, new BMessage(M_ADD_PATH),fRefFilter);
fAutolock = new BAutolock(fProject);
AddCommonFilter(new EscapeCancelFilter());
BView *top = GetBackgroundView();
BRect r(Bounds());
fTabView = new BTabView(r,"tabview");
top->AddChild(fTabView);
r.InsetBy(5,5);
r.bottom -= fTabView->TabHeight();
BRect bounds = r.OffsetToCopy(0,0);
fGeneralView = new BView(r,TR("General"),B_FOLLOW_ALL,B_WILL_DRAW);
fGeneralView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fTabView->AddTab(fGeneralView);
r.right -= 10.0;
fTargetText = new AutoTextControl(r,"targetname",TR("Target Name:"),
fProject->GetTargetName(),
new BMessage(M_TARGET_NAME_CHANGED),
B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
fGeneralView->AddChild(fTargetText);
float pwidth, pheight;
fTargetText->GetPreferredSize(&pwidth, &pheight);
fTargetText->ResizeTo(r.Width(),pheight);
r.bottom = r.top + pheight;
fTargetText->SetDivider(fTargetText->StringWidth(TR("Target Name:")) + 5.0);
r = fTargetText->Frame();
r.OffsetBy(0,r.Height() + 10.0);
BMenu *menu = new BMenu(TR("Target Type"));
menu->AddItem(new BMenuItem(TR("Application"),new BMessage(M_SET_TARGET_TYPE)));
menu->AddItem(new BMenuItem(TR("Shared Library"),new BMessage(M_SET_TARGET_TYPE)));
menu->AddItem(new BMenuItem(TR("Static Library"),new BMessage(M_SET_TARGET_TYPE)));
menu->AddItem(new BMenuItem(TR("Device Driver"),new BMessage(M_SET_TARGET_TYPE)));
r.right = (bounds.right - 5.0) / 2.0;
r.bottom = r.top + 25;
fTypeField = new BMenuField(r,"type",TR("Target Type:"),menu);
fGeneralView->AddChild(fTypeField);
fTypeField->SetDivider(fTypeField->StringWidth(TR("Target Type:")) + 5.0);
SetToolTip(fTypeField,TR("The kind of program you want to build"));
menu->SetTargetForItems(this);
menu->SetLabelFromMarked(true);
BMenuItem *item = menu->ItemAt(fProject->TargetType());
if (item)
item->SetMarked(true);
r.OffsetBy(0,r.Height() + 10.0);
BStringView *label = new BStringView(r,"label",TR("Include Paths:"));
label->ResizeToPreferred();
fGeneralView->AddChild(label);
r = label->Frame();
r.OffsetBy(0,r.Height() + 5.0);
// We create a button now so that the list expands to fill the entire window
// while leaving space for the two buttons at the bottom. Note that we do not
// actually add the button to the window until later to preserve proper
// keyboard navigation order
BButton *add = new BButton(BRect(0,0,1,1),"addbutton",TR("Add…"),
new BMessage(M_SHOW_ADD_PATH),
B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
add->ResizeToPreferred();
add->MoveTo(5,fGeneralView->Bounds().bottom - 10.0 - add->Frame().Height());
r.right = bounds.right - 10.0 - B_V_SCROLL_BAR_WIDTH;
r.bottom = add->Frame().top - 10.0 - B_H_SCROLL_BAR_HEIGHT;
fIncludeList = new IncludeList(r,fProject->GetPath().GetFolder());
BScrollView *scrollView = new BScrollView("scrollview",fIncludeList,
B_FOLLOW_ALL,0, true, true);
scrollView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fGeneralView->AddChild(scrollView);
float width = 0.0;
for (int32 i = 0; i < fProject->CountLocalIncludes(); i++)
{
BStringItem *item = new BStringItem(fProject->LocalIncludeAt(i).Relative().String());
float strwidth = fIncludeList->StringWidth(item->Text());
width = MAX(width, strwidth);
fIncludeList->AddItem(item);
}
if (width > fIncludeList->Bounds().Width())
{
BScrollBar *hbar = scrollView->ScrollBar(B_HORIZONTAL);
hbar->SetRange(0.0, width - fIncludeList->Bounds().Width());
}
SetToolTip(fIncludeList,TR("The folders you want Paladin to search for header files"));
fGeneralView->AddChild(add);
BButton *remove = new BButton(BRect(0,0,1,1),"removebutton",TR("Remove"),
new BMessage(M_REMOVE_PATH),
B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
remove->ResizeToPreferred();
remove->MoveTo(add->Frame().right + 10.0, add->Frame().top);
fGeneralView->AddChild(remove);
r = bounds;
fBuildView = new BView(bounds.OffsetByCopy(5,5),TR("Build"),B_FOLLOW_ALL,B_WILL_DRAW);
fBuildView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fTabView->AddTab(fBuildView);
menu = new BMenu(TR("Optimization"));
menu->AddItem(new BMenuItem(TR("None"),new BMessage(M_SET_OP_VALUE)));
menu->AddItem(new BMenuItem(TR("Some"),new BMessage(M_SET_OP_VALUE)));
menu->AddItem(new BMenuItem(TR("More"),new BMessage(M_SET_OP_VALUE)));
menu->AddItem(new BMenuItem(TR("Full"),new BMessage(M_SET_OP_VALUE)));
r.right = (bounds.right - 5.0) / 2.0;
r.bottom = r.top + 25;
fOpField = new BMenuField(r,"optimize",TR("Optimize"),menu);
fBuildView->AddChild(fOpField);
fOpField->SetDivider(fOpField->StringWidth(TR("Optimize")) + 5.0);
SetToolTip(fOpField,TR("Compiler optimization level. Disabled when debugging info is checked."));
menu->SetTargetForItems(this);
menu->SetLabelFromMarked(true);
item = menu->ItemAt(fProject->OpLevel());
if (item)
item->SetMarked(true);
r.right = bounds.right - 10.0;
r.OffsetTo(5, fOpField->Frame().bottom + 5);
fOpSizeBox = new BCheckBox(r,"opsizebox",TR("Optimize for size over speed"),
new BMessage(M_TOGGLE_OPSIZE));
fOpSizeBox->ResizeToPreferred();
fBuildView->AddChild(fOpSizeBox);
r = fOpSizeBox->Frame();
if (fProject->OpForSize())
fOpSizeBox->SetValue(B_CONTROL_ON);
if (fProject->Debug())
{
fOpField->SetEnabled(false);
fOpSizeBox->SetEnabled(false);
}
r.OffsetBy(0, r.Height() + 10);
fDebugBox = new BCheckBox(r,"debugbox",TR("Build debugging information"),
new BMessage(M_TOGGLE_DEBUG));
fDebugBox->ResizeToPreferred();
if (fProject->Debug())
fDebugBox->SetValue(B_CONTROL_ON);
fBuildView->AddChild(fDebugBox);
SetToolTip(fDebugBox,TR("Check this if you want to use your program in a debugger during development."
"You'll want to rebuild your project after change this."));
r.OffsetBy(0, r.Height());
fProfileBox = new BCheckBox(r,"profilebox",TR("Build profiling information"),
new BMessage(M_TOGGLE_PROFILE));
fProfileBox->ResizeToPreferred();
if (fProject->Profiling())
fProfileBox->SetValue(B_CONTROL_ON);
fBuildView->AddChild(fProfileBox);
SetToolTip(fProfileBox,TR("Check this if you want to use your program "
"with gprof or bprof for profiling."));
r.OffsetBy(0, r.Height() + 10.0);
r.right = bounds.right - 10.0;
fCompileText = new AutoTextControl(r,"extracc","Extra Compiler Options:",
fProject->ExtraCompilerOptions(),
new BMessage(M_CCOPTS_CHANGED),
B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
fBuildView->AddChild(fCompileText);
fCompileText->SetDivider(fCompileText->StringWidth(fCompileText->Label()) + 5.0);
SetToolTip(fCompileText,TR("Extra GCC flags you wish included when each file is compiled."));
r = fCompileText->Frame();
r.OffsetBy(0,r.Height() + 10);
fLinkText = new AutoTextControl(r,"extrald",TR("Extra Linker Options:"),
fProject->ExtraLinkerOptions(),
new BMessage(M_LDOPTS_CHANGED),
B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
fBuildView->AddChild(fLinkText);
fLinkText->SetDivider(fCompileText->Divider());
SetToolTip(fLinkText,TR("Extra GCC linker flags you wish included when your project is linked."));
fTabView->Select(0L);
fBuildView->ResizeTo(fGeneralView->Bounds().Width(),fGeneralView->Bounds().Height());
fTargetText->MakeFocus(true);
}
