void
BFont::GetEscapements(const char charArray[], int32 numChars,
escapement_delta* delta, BPoint escapementArray[],
BPoint offsetArray[]) const
{
if (charArray == NULL || numChars < 1 || escapementArray == NULL)
return;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_ESCAPEMENTS);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
link.Attach<uint8>(fSpacing);
link.Attach<float>(fRotation);
link.Attach<uint32>(fFlags);
link.Attach<float>(delta ? delta->nonspace : 0.0);
link.Attach<float>(delta ? delta->space : 0.0);
link.Attach<bool>(offsetArray != NULL);
link.Attach<int32>(numChars);
// TODO: Should we not worry about the port capacity here?!?
uint32 bytesInBuffer = UTF8CountBytes(charArray, numChars);
link.Attach<int32>(bytesInBuffer);
link.Attach(charArray, bytesInBuffer);
int32 code;
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
link.Read(escapementArray, sizeof(BPoint) * numChars);
if (offsetArray)
link.Read(offsetArray, sizeof(BPoint) * numChars);
}
void
BFont::GetStringWidths(const char* stringArray[], const int32 lengthArray[],
int32 numStrings, float widthArray[]) const
{
if (stringArray == NULL || lengthArray == NULL || numStrings < 1
|| widthArray == NULL) {
return;
}
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_STRING_WIDTHS);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
link.Attach<uint8>(fSpacing);
link.Attach<int32>(numStrings);
// TODO: all strings into a single array???
// we do have a maximum message length, and it could be easily touched
// here...
for (int32 i = 0; i < numStrings; i++)
link.AttachString(stringArray[i], lengthArray[i]);
status_t status;
if (link.FlushWithReply(status) != B_OK || status != B_OK)
return;
link.Read(widthArray, sizeof(float) * numStrings);
}
status_t
get_window_order(int32 workspace, int32** _tokens, int32* _count)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_WINDOW_ORDER);
link.Attach<int32>(workspace);
int32 code;
status_t status = link.FlushWithReply(code);
if (status != B_OK)
return status;
if (code != B_OK)
return code;
int32 count;
link.Read<int32>(&count);
*_tokens = (int32*)malloc(count * sizeof(int32));
if (*_tokens == NULL)
return B_NO_MEMORY;
link.Read(*_tokens, count * sizeof(int32));
*_count = count;
return B_OK;
}
status_t
get_application_order(int32 workspace, team_id** _applications,
int32* _count)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_APPLICATION_ORDER);
link.Attach<int32>(workspace);
int32 code;
status_t status = link.FlushWithReply(code);
if (status != B_OK)
return status;
if (code != B_OK)
return code;
int32 count;
link.Read<int32>(&count);
*_applications = (team_id*)malloc(count * sizeof(team_id));
if (*_applications == NULL)
return B_NO_MEMORY;
link.Read(*_applications, count * sizeof(team_id));
*_count = count;
return B_OK;
}
/*! \brief Returns the overlay_restrictions structure for this bitmap
*/
status_t
BBitmap::GetOverlayRestrictions(overlay_restrictions* restrictions) const
{
if ((fFlags & B_BITMAP_WILL_OVERLAY) == 0)
return B_BAD_TYPE;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_BITMAP_OVERLAY_RESTRICTIONS);
link.Attach<int32>(fServerToken);
status_t status;
if (link.FlushWithReply(status) < B_OK)
return status;
link.Read(restrictions, sizeof(overlay_restrictions));
return B_OK;
}
void
BFont::GetBoundingBoxesForStrings(const char* stringArray[], int32 numStrings,
font_metric_mode mode, escapement_delta deltas[],
BRect boundingBoxArray[]) const
{
if (!stringArray || numStrings < 1 || !boundingBoxArray)
return;
int32 code;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_BOUNDINGBOXES_STRINGS);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
link.Attach<float>(fRotation);
link.Attach<float>(fShear);
link.Attach<float>(fFalseBoldWidth);
link.Attach<uint8>(fSpacing);
link.Attach<uint32>(fFlags);
link.Attach<font_metric_mode>(mode);
link.Attach<int32>(numStrings);
if (deltas) {
for (int32 i = 0; i < numStrings; i++) {
link.AttachString(stringArray[i]);
link.Attach<escapement_delta>(deltas[i]);
}
} else {
escapement_delta emptyDelta = {0, 0};
for (int32 i = 0; i < numStrings; i++) {
link.AttachString(stringArray[i]);
link.Attach<escapement_delta>(emptyDelta);
}
}
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
link.Read(boundingBoxArray, sizeof(BRect) * numStrings);
}
void
BFont::_GetBoundingBoxes(const char charArray[], int32 numChars,
font_metric_mode mode, bool string_escapement, escapement_delta* delta,
BRect boundingBoxArray[], bool asString) const
{
if (charArray == NULL || numChars < 1 || boundingBoxArray == NULL)
return;
int32 code;
BPrivate::AppServerLink link;
link.StartMessage(asString
? AS_GET_BOUNDINGBOXES_STRING : AS_GET_BOUNDINGBOXES_CHARS);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
link.Attach<float>(fRotation);
link.Attach<float>(fShear);
link.Attach<float>(fFalseBoldWidth);
link.Attach<uint8>(fSpacing);
link.Attach<uint32>(fFlags);
link.Attach<font_metric_mode>(mode);
link.Attach<bool>(string_escapement);
if (delta != NULL) {
link.Attach<escapement_delta>(*delta);
} else {
escapement_delta emptyDelta = {0, 0};
link.Attach<escapement_delta>(emptyDelta);
}
link.Attach<int32>(numChars);
uint32 bytesInBuffer = UTF8CountBytes(charArray, numChars);
link.Attach<int32>(bytesInBuffer);
link.Attach(charArray, bytesInBuffer);
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
link.Read(boundingBoxArray, sizeof(BRect) * numChars);
}
client_window_info*
get_window_info(int32 serverToken)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_WINDOW_INFO);
link.Attach<int32>(serverToken);
int32 code;
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return NULL;
int32 size;
link.Read<int32>(&size);
client_window_info* info = (client_window_info*)malloc(size);
if (info == NULL)
return NULL;
link.Read(info, size);
return info;
}
int32*
get_token_list(team_id team, int32* _count)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_WINDOW_LIST);
link.Attach<team_id>(team);
int32 code;
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return NULL;
int32 count;
link.Read<int32>(&count);
int32* tokens = (int32*)malloc(count * sizeof(int32));
if (tokens == NULL)
return NULL;
link.Read(tokens, count * sizeof(int32));
*_count = count;
return tokens;
}
void
BFont::GetHasGlyphs(const char charArray[], int32 numChars,
bool hasArray[]) const
{
if (!charArray || numChars < 1 || !hasArray)
return;
int32 code;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_HAS_GLYPHS);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<int32>(numChars);
uint32 bytesInBuffer = UTF8CountBytes(charArray, numChars);
link.Attach<int32>(bytesInBuffer);
link.Attach(charArray, bytesInBuffer);
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
link.Read(hasArray, sizeof(bool) * numChars);
}
void
BFont::GetEdges(const char charArray[], int32 numChars,
edge_info edgeArray[]) const
{
if (!charArray || numChars < 1 || !edgeArray)
return;
int32 code;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_EDGES);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<int32>(numChars);
uint32 bytesInBuffer = UTF8CountBytes(charArray, numChars);
link.Attach<int32>(bytesInBuffer);
link.Attach(charArray, bytesInBuffer);
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
link.Read(edgeArray, sizeof(edge_info) * numChars);
}
status_t
get_mouse_bitmap(BBitmap** bitmap, BPoint* hotspot)
{
if (bitmap == NULL && hotspot == NULL)
return B_BAD_VALUE;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_CURSOR_BITMAP);
int32 code;
status_t status = link.FlushWithReply(code);
if (status != B_OK)
return status;
if (code != B_OK)
return code;
uint32 size = 0;
uint32 cursorWidth = 0;
uint32 cursorHeight = 0;
// if link.Read() returns an error, the same error will be returned on
// subsequent calls, so we'll check only the return value of the last call
link.Read<uint32>(&size);
link.Read<uint32>(&cursorWidth);
link.Read<uint32>(&cursorHeight);
if (hotspot == NULL) {
BPoint dummy;
link.Read<BPoint>(&dummy);
} else
link.Read<BPoint>(hotspot);
void* data = NULL;
if (size > 0)
data = malloc(size);
if (data == NULL)
return B_NO_MEMORY;
status = link.Read(data, size);
if (status != B_OK) {
free(data);
return status;
}
BBitmap* cursorBitmap = new (std::nothrow) BBitmap(BRect(0, 0,
cursorWidth - 1, cursorHeight - 1), B_RGBA32);
if (cursorBitmap == NULL) {
free(data);
return B_NO_MEMORY;
}
status = cursorBitmap->InitCheck();
if (status == B_OK)
cursorBitmap->SetBits(data, size, 0, B_RGBA32);
free(data);
if (status == B_OK && bitmap != NULL)
*bitmap = cursorBitmap;
else
delete cursorBitmap;
return status;
}