void
BApplication::HideCursor()
{
BPrivate::AppServerLink link;
link.StartMessage(AS_HIDE_CURSOR);
link.Flush();
}
void
BApplication::ShowCursor()
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SHOW_CURSOR);
link.Flush();
}
BApplication::~BApplication()
{
Lock();
// tell all loopers(usually windows) to quit. Also, wait for them.
_QuitAllWindows(true);
// unregister from the roster
BRoster::Private().RemoveApp(Team());
#ifndef RUN_WITHOUT_APP_SERVER
// tell app_server we're quitting...
if (be_app) {
// be_app can be NULL here if the application fails to initialize
// correctly. For example, if it's already running and it's set to
// exclusive launch.
BPrivate::AppServerLink link;
link.StartMessage(B_QUIT_REQUESTED);
link.Flush();
}
delete_port(fServerLink->SenderPort());
delete_port(fServerLink->ReceiverPort());
delete fServerLink;
#endif // RUN_WITHOUT_APP_SERVER
delete fServerAllocator;
// uninitialize be_app, the be_app_messenger is invalidated automatically
be_app = NULL;
}
void
BApplication::EndRectTracking()
{
BPrivate::AppServerLink link;
link.StartMessage(AS_END_RECT_TRACKING);
link.Flush();
}
void
BApplication::ObscureCursor()
{
BPrivate::AppServerLink link;
link.StartMessage(AS_OBSCURE_CURSOR);
link.Flush();
}
/*! \brief Cleans up any memory allocated by the bitmap and
informs the server to do so as well (if needed).
*/
void
BBitmap::_CleanUp()
{
if (fWindow != NULL) {
if (fWindow->Lock())
delete fWindow;
fWindow = NULL;
// this will leak fWindow if it couldn't be locked
}
if (fBasePointer == NULL)
return;
if ((fFlags & B_BITMAP_NO_SERVER_LINK) != 0) {
free(fBasePointer);
} else if (fServerToken != -1) {
BPrivate::AppServerLink link;
// AS_DELETE_BITMAP:
// Attached Data:
// 1) int32 server token
link.StartMessage(AS_DELETE_BITMAP);
link.Attach<int32>(fServerToken);
link.Flush();
// The server areas are deleted via kMsgDeleteServerMemoryArea message
fArea = -1;
fServerToken = -1;
fAreaOffset = -1;
BAutolock _(sBitmapListLock);
sBitmapList.RemoveItem(this);
}
fBasePointer = NULL;
}
/*! \brief Cleans up any memory allocated by the bitmap and
informs the server to do so as well (if needed).
*/
void
BBitmap::_CleanUp()
{
if (fWindow != NULL) {
if (fWindow->Lock())
delete fWindow;
fWindow = NULL;
// this will leak fWindow if it couldn't be locked
}
if (fBasePointer == NULL)
return;
if ((fFlags & B_BITMAP_NO_SERVER_LINK) != 0) {
free(fBasePointer);
} else if (fServerToken != -1) {
BPrivate::AppServerLink link;
// AS_DELETE_BITMAP:
// Attached Data:
// 1) int32 server token
link.StartMessage(AS_DELETE_BITMAP);
link.Attach<int32>(fServerToken);
link.Flush();
// TODO: we may want to delete parts of the server memory areas here!
fArea = -1;
fServerToken = -1;
fAreaOffset = -1;
}
fBasePointer = NULL;
}
BCursor::BCursor(const void *cursorData)
:
fServerToken(-1),
fNeedToFree(false)
{
const uint8 *data = (const uint8 *)cursorData;
if (data == B_HAND_CURSOR || data == B_I_BEAM_CURSOR) {
// just use the default cursors from the app_server
fServerToken = data == B_HAND_CURSOR ?
B_CURSOR_DEFAULT : B_CURSOR_TEXT;
return;
}
// Create a new cursor in the app_server
if (data == NULL
|| data[0] != 16 // size
|| data[1] != 1 // depth
|| data[2] >= 16 || data[3] >= 16) // hot-spot
return;
// Send data directly to server
BPrivate::AppServerLink link;
link.StartMessage(AS_CREATE_CURSOR);
link.Attach(cursorData, 68);
status_t status;
if (link.FlushWithReply(status) == B_OK && status == B_OK) {
link.Read<int32>(&fServerToken);
fNeedToFree = true;
}
}
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);
}
void
BFont::GetHeight(font_height* _height) const
{
if (_height == NULL)
return;
if (fHeight.ascent == kUninitializedAscent) {
// we don't have the font height cached yet
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_FONT_HEIGHT);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
int32 code;
if (link.FlushWithReply(code) != B_OK || code != B_OK)
return;
// Who put that "const" to this method? :-)
// We made fHeight mutable for this, but we should drop the "const"
// when we can
link.Read<font_height>(&fHeight);
}
*_height = fHeight;
}
void
BFont::GetFamilyAndStyle(font_family* family, font_style* style) const
{
if (family == NULL && style == NULL)
return;
// it's okay to call this function with either family or style set to NULL
font_family familyBuffer;
font_style styleBuffer;
if (family == NULL)
family = &familyBuffer;
if (style == NULL)
style = &styleBuffer;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_FAMILY_AND_STYLE);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
int32 code;
if (link.FlushWithReply(code) != B_OK || code != B_OK) {
// the least we can do is to clear the buffers
memset(*family, 0, sizeof(font_family));
memset(*style, 0, sizeof(font_style));
return;
}
link.ReadString(*family, sizeof(font_family));
link.ReadString(*style, sizeof(font_style));
}
// Sets the font's family and style all at once
status_t
BFont::SetFamilyAndStyle(const font_family family, const font_style style)
{
if (family == NULL && style == NULL)
return B_BAD_VALUE;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_FAMILY_AND_STYLE_IDS);
link.AttachString(family, sizeof(font_family));
link.AttachString(style, sizeof(font_style));
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(0xffff);
link.Attach<uint16>(fFace);
int32 status = B_ERROR;
if (link.FlushWithReply(status) != B_OK || status != B_OK)
return status;
link.Read<uint16>(&fFamilyID);
link.Read<uint16>(&fStyleID);
link.Read<uint16>(&fFace);
fHeight.ascent = kUninitializedAscent;
fExtraFlags = kUninitializedExtraFlags;
return B_OK;
}
void
BFont::GetGlyphShapes(const char charArray[], int32 numChars,
BShape* glyphShapeArray[]) const
{
// TODO: implement code specifically for passing BShapes to and
// from the server
if (!charArray || numChars < 1 || !glyphShapeArray)
return;
int32 code;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_GLYPH_SHAPES);
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(fStyleID);
link.Attach<float>(fSize);
link.Attach<float>(fShear);
link.Attach<float>(fRotation);
link.Attach<float>(fFalseBoldWidth);
link.Attach<uint32>(fFlags);
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;
for (int32 i = 0; i < numChars; i++)
link.ReadShape(glyphShapeArray[i]);
}
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;
}
// Sets the font's family and style all at once
void
BFont::SetFamilyAndStyle(uint32 code)
{
// R5 has a bug here: the face is not updated even though the IDs are set.
// This is a problem because the face flag includes Regular/Bold/Italic
// information in addition to stuff like underlining and strikethrough.
// As a result, this will need a trip to the server and, thus, be slower
// than R5's in order to be correct
uint16 family, style;
style = code & 0xFFFF;
family = (code & 0xFFFF0000) >> 16;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_FAMILY_AND_STYLE_IDS);
link.AttachString(NULL); // no family and style name
link.AttachString(NULL);
link.Attach<uint16>(family);
link.Attach<uint16>(style);
link.Attach<uint16>(fFace);
int32 fontcode;
if (link.FlushWithReply(fontcode) != B_OK || fontcode != B_OK)
return;
link.Read<uint16>(&fFamilyID);
link.Read<uint16>(&fStyleID);
link.Read<uint16>(&fFace);
fHeight.ascent = kUninitializedAscent;
fExtraFlags = kUninitializedExtraFlags;
}
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;
}
status_t
get_mouse(BPoint* screenWhere, uint32* buttons)
{
if (screenWhere == NULL && buttons == NULL)
return B_BAD_VALUE;
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_CURSOR_POSITION);
int32 code;
status_t ret = link.FlushWithReply(code);
if (ret != B_OK)
return ret;
if (code != B_OK)
return code;
if (screenWhere != NULL)
ret = link.Read<BPoint>(screenWhere);
else {
BPoint dummy;
ret = link.Read<BPoint>(&dummy);
}
if (ret != B_OK)
return ret;
if (buttons != NULL)
ret = link.Read<uint32>(buttons);
else {
uint32 dummy;
ret = link.Read<uint32>(&dummy);
}
return ret;
}
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);
}
// Sets the font's family and face all at once
status_t
BFont::SetFamilyAndFace(const font_family family, uint16 face)
{
// To comply with the BeBook, this function will only set valid values
// i.e. passing a nonexistent family will cause only the face to be set.
// Additionally, if a particular face does not exist in a family, the
// closest match will be chosen.
BPrivate::AppServerLink link;
link.StartMessage(AS_GET_FAMILY_AND_STYLE_IDS);
link.AttachString(family, sizeof(font_family));
link.AttachString(NULL); // no style given
link.Attach<uint16>(fFamilyID);
link.Attach<uint16>(0xffff);
link.Attach<uint16>(face);
int32 status = B_ERROR;
if (link.FlushWithReply(status) != B_OK || status != B_OK)
return status;
link.Read<uint16>(&fFamilyID);
link.Read<uint16>(&fStyleID);
link.Read<uint16>(&fFace);
fHeight.ascent = kUninitializedAscent;
fExtraFlags = kUninitializedExtraFlags;
return B_OK;
}
void
set_accept_first_click(bool acceptFirstClick)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_ACCEPT_FIRST_CLICK);
link.Attach<bool>(acceptFirstClick);
link.Flush();
}
void
set_focus_follows_mouse_mode(mode_focus_follows_mouse mode)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_FOCUS_FOLLOWS_MOUSE_MODE);
link.Attach<mode_focus_follows_mouse>(mode);
link.Flush();
}
/*! \brief private function used by Deskbar to set window decor
Note, we don't have to be compatible here, and could just change
the Deskbar not to use this anymore
\param theme The theme to choose
- \c 0: BeOS
- \c 1: AmigaOS
- \c 2: Win95
- \c 3: MacOS
*/
void
__set_window_decor(int32 theme)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_R5_SET_DECORATOR);
link.Attach<int32>(theme);
link.Flush();
}
void
activate_workspace(int32 workspace)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_ACTIVATE_WORKSPACE);
link.Attach<int32>(workspace);
link.Flush();
}
void
set_mouse_mode(mode_mouse mode)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_MOUSE_MODE);
link.Attach<mode_mouse>(mode);
link.Flush();
}
void
set_subpixel_antialiasing(bool subpix)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_SUBPIXEL_ANTIALIASING);
link.Attach<bool>(subpix);
link.Flush();
}
void
BApplication::BeginRectTracking(BRect rect, bool trackWhole)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_BEGIN_RECT_TRACKING);
link.Attach<BRect>(rect);
link.Attach<int32>(trackWhole);
link.Flush();
}
void
set_hinting_mode(uint8 hinting)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_HINTING);
link.Attach<uint8>(hinting);
link.Flush();
}
void
set_is_subpixel_ordering_regular(bool subpixelOrdering)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_SUBPIXEL_ORDERING);
link.Attach<bool>(subpixelOrdering);
link.Flush();
}
void
set_average_weight(uint8 averageWeight)
{
BPrivate::AppServerLink link;
link.StartMessage(AS_SET_SUBPIXEL_AVERAGE_WEIGHT);
link.Attach<uint8>(averageWeight);
link.Flush();
}
bool
BApplication::IsCursorHidden() const
{
BPrivate::AppServerLink link;
int32 status = B_ERROR;
link.StartMessage(AS_QUERY_CURSOR_HIDDEN);
link.FlushWithReply(status);
return status == B_OK;
}