haiku/src/servers/app/ServerCursor.h
Stephan Aßmus 19e179ca4f * Moved the implementation of SetViewCursor from the thread of the
window of the view into the application thread. This solves the
  race condition with asynchronous SetViewCursor and deleting the
  cursor immediately afterwards for real.
* The ServerApp now requires a reference to the current cursor,
  just in case...
* Added TODOs for caching the BView token, it's currently resolved
  for every single BView call that talks to the server... not good!


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31133 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-06-20 12:11:49 +00:00

122 lines
2.6 KiB
C++

/*
* Copyright 2001-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* DarkWyrm <bpmagic@columbus.rr.com>
* Stephan Aßmus <superstippi@gmx.de>
* Axel Dörfler, axeld@pinc-software.de
*/
#ifndef SERVER_CURSOR_H
#define SERVER_CURSOR_H
#include "ServerBitmap.h"
#include <Point.h>
#include <String.h>
class ServerApp;
class CursorManager;
class ServerCursor : public ServerBitmap {
public:
ServerCursor(BRect r, color_space space,
int32 flags, BPoint hotspot,
int32 bytesperrow = -1,
screen_id screen = B_MAIN_SCREEN_ID);
ServerCursor(const uint8* cursorDataFromR5);
ServerCursor(const uint8* alreadyPaddedData,
uint32 width, uint32 height,
color_space format);
ServerCursor(const ServerCursor* cursor);
virtual ~ServerCursor();
//! Returns the cursor's hot spot
void SetHotSpot(BPoint pt);
BPoint GetHotSpot() const
{ return fHotSpot; }
void SetOwningTeam(team_id tid)
{ fOwningTeam = tid; }
team_id OwningTeam() const
{ return fOwningTeam; }
int32 Token() const
{ return fToken; }
void Acquire()
{ atomic_add(&fReferenceCount, 1); }
bool Release();
int32 ReferenceCount() { return fReferenceCount; }
void AttachedToManager(CursorManager* manager);
const uint8* CursorData() const
{ return fCursorData; }
private:
friend class CursorManager;
BPoint fHotSpot;
team_id fOwningTeam;
vint32 fReferenceCount;
uint8* fCursorData;
CursorManager* fManager;
};
class ServerCursorReference {
public:
ServerCursorReference()
: fCursor(NULL)
{
}
ServerCursorReference(ServerCursor* cursor)
: fCursor(cursor)
{
if (fCursor)
fCursor->Acquire();
}
ServerCursorReference(const ServerCursorReference& other)
: fCursor(other.fCursor)
{
if (fCursor)
fCursor->Acquire();
}
virtual ~ServerCursorReference()
{
if (fCursor)
fCursor->Release();
}
ServerCursorReference& operator=(const ServerCursorReference& other)
{
SetCursor(other.fCursor);
return *this;
}
void SetCursor(ServerCursor* cursor)
{
if (fCursor == cursor)
return;
if (cursor)
cursor->Acquire();
ServerCursor* oldCursor = fCursor;
fCursor = cursor;
if (oldCursor)
oldCursor->Release();
}
ServerCursor* Cursor() const
{
return fCursor;
}
private:
ServerCursor* fCursor;
};
#endif // SERVER_CURSOR_H