/**
Quit()
@case Looper is unlocked
@result Prints message "ERROR - you must Lock a looper before calling
Quit(), team=%ld, looper=%s\n"
*/
void
TQuitTest::QuitTest1()
{
BLooper* looper = new BLooper;
looper->Unlock();
looper->Quit();
}
void TTimeTextView::MakeFocus(bool focusState)
{
BTextView::MakeFocus(focusState);
// Inform target
if ( focusState == false)
{
if (m_Target)
{
BLooper *looper = m_Target->Looper();
if ( looper->Lock() )
{
CheckLastEdit();
for (int16 index = 1; index < 5; index++)
ConvertToTime(index);
if (m_MessageID)
{
BMessage *message = new BMessage(m_MessageID);
message->AddInt32("TheTime", m_Time);
m_Target->MessageReceived( message);
looper->Unlock();
delete message;
}
}
}
}
}
/**
RemoveHandler(BHandler* handler)
@case handler doesn't belong to this looper, looper is unlocked
@param handler Valid BHandler pointer, not assigned to looper
@results
*/
void TRemoveHandlerTest::RemoveHandler4()
{
DEBUGGER_ESCAPE;
BLooper Looper;
BHandler Handler;
Looper.Unlock();
CPPUNIT_ASSERT(!Looper.RemoveHandler(&Handler));
}
void gui_window_destroy(struct gui_window *g)
{
if (!g)
return;
if (g->prev)
g->prev->next = g->next;
else
window_list = g->next;
if (g->next)
g->next->prev = g->prev;
LOG(("Destroying gui_window %p", g));
assert(g != NULL);
assert(g->bw != NULL);
LOG((" Scaffolding: %p", g->scaffold));
LOG((" Window name: %s", g->bw->name));
if (g->view == NULL)
return;
if (!g->view->LockLooper())
return;
BLooper *looper = g->view->Looper();
/* If we're a top-level gui_window, destroy our scaffold */
if (g->toplevel) {
g->view->RemoveSelf();
delete g->view;
nsbeos_scaffolding_destroy(g->scaffold);
} else {
g->view->RemoveSelf();
delete g->view;
looper->Unlock();
}
//XXX
//looper->Unlock();
#warning FIXME
#if 0 /* GTK */
/* If we're a top-level gui_window, destroy our scaffold */
if (g->scrolledwindow == NULL) {
gtk_widget_destroy(GTK_WIDGET(g->viewport));
nsgtk_scaffolding_destroy(g->scaffold);
} else {
gtk_widget_destroy(GTK_WIDGET(g->scrolledwindow));
}
#endif
free(g);
}
void Unlock()
{
if (fHasLock)
{
BLooper *looper;
fMessenger->Target(&looper);
if (looper)
looper->Unlock();
fHasLock = false;
}
}
int32 MouseWatcher(void* data)
{
BMessenger* TheMessenger = (BMessenger*)data;
BPoint PreviousPos;
uint32 PreviousButtons;
bool FirstCheck = true;
BMessage MessageToSend;
MessageToSend.AddPoint("where",BPoint(0,0));
MessageToSend.AddInt32("buttons",0);
MessageToSend.AddInt32("modifiers",0);
while(true)
{
if (!TheMessenger->LockTarget())
{
delete TheMessenger;
return 0; // window is dead so exit
}
BLooper *TheLooper;
BView* TheView = (BView*)TheMessenger->Target(&TheLooper);
BPoint Where;
uint32 Buttons;
TheView->GetMouse(&Where,&Buttons,false);
if(FirstCheck)
{
PreviousPos = Where;
PreviousButtons = Buttons;
FirstCheck = false;
}
bool Send = false;
if(Buttons != PreviousButtons || Buttons == 0 || Where != PreviousPos)
{
if(Buttons == 0)
MessageToSend.what = MW_MOUSE_UP;
else if(Buttons != PreviousButtons)
MessageToSend.what = MW_MOUSE_DOWN;
else
MessageToSend.what = MW_MOUSE_MOVED;
MessageToSend.ReplacePoint("where",Where);
MessageToSend.ReplaceInt32("buttons",Buttons);
MessageToSend.ReplaceInt32("modifiers",modifiers());
Send = true;
}
TheLooper->Unlock();
if(Send)
TheMessenger->SendMessage(&MessageToSend);
if(Buttons == 0)
{
//Button was released
delete TheMessenger;
return 0;
}
snooze(50000);
}
}
/**
SetNextHandler(BHandler* handler);
NextHandler();
@case Handler1 belongs to a unlocked BLooper, Handler2 does not
@param handler Valid BHandler pointer
@results NextHandler() returns BLooper
debug message "The handler's looper must be locked before
setting NextHandler"
*/
void TSetNextHandlerTest::SetNextHandler2()
{
DEBUGGER_ESCAPE;
BHandler Handler1;
BHandler Handler2;
BLooper Looper;
Looper.AddHandler(&Handler1);
Looper.Unlock();
Handler1.SetNextHandler(&Handler2);
CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper);
}
static BRect CallerFrame(BMessenger& caller)
{
BRect rect;
if (caller.LockTarget())
{
BLooper* looper;
caller.Target(&looper);
BWindow* window = dynamic_cast<BWindow*>(looper);
if (window)
rect = window->Frame();
looper->Unlock();
}
return rect;
}
void
TDeskbarMenu::DetachedFromWindow()
{
if (fBarView != NULL) {
BLooper* looper = fBarView->Looper();
if (looper != NULL && looper->Lock()) {
fBarView->DragStop();
looper->Unlock();
}
}
// don't call BNavMenu::DetachedFromWindow
// it sets the TypesList to NULL
BMenu::DetachedFromWindow();
}
status_t
TBarMenuTitle::Invoke(BMessage* message)
{
TBarView* barview = dynamic_cast<TBarApp*>(be_app)->BarView();
if (barview) {
BLooper* looper = barview->Looper();
if (looper->Lock()) {
// tell barview to add the refs to the deskbar menu
barview->HandleDeskbarMenu(NULL);
looper->Unlock();
}
}
return BMenuItem::Invoke(message);
}
bool
BMessenger::LockTarget() const
{
BLooper* looper = NULL;
Target(&looper);
if (looper != NULL && looper->Lock()) {
if (looper->fMsgPort == fPort)
return true;
looper->Unlock();
return false;
}
return false;
}
/*
bool IsTargetLocal() const
@case 3 this is initialized to local target with specific handler
@results should return true.
*/
void TargetTester::IsTargetLocalTest3()
{
// create looper and handler
status_t result = B_OK;
BLooper *looper = new BLooper;
looper->Run();
LooperQuitter quitter(looper);
BHandler *handler = new BHandler;
HandlerDeleter deleter(handler);
CHK(looper->Lock());
looper->AddHandler(handler);
looper->Unlock();
// create the messenger and do the checks
BMessenger messenger(handler, NULL, &result);
CHK(messenger.IsTargetLocal() == true);
}
void
TTeamMenu::DetachedFromWindow()
{
TBarView* barView = (dynamic_cast<TBarApp*>(be_app))->BarView();
if (barView != NULL) {
BLooper* looper = barView->Looper();
if (looper != NULL && looper->Lock()) {
barView->DragStop();
looper->Unlock();
}
}
BMenu::DetachedFromWindow();
BMessenger self(this);
TBarApp::Unsubscribe(self);
}
status_t
BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
{
BLooper* looper = NULL;
Target(&looper);
if (looper == NULL)
return B_BAD_VALUE;
status_t result = looper->LockWithTimeout(timeout);
if (result == B_OK && looper->fMsgPort != fPort) {
looper->Unlock();
return B_BAD_PORT_ID;
}
return result;
}
bool
BHandler::LockLooper()
{
BLooper* looper = fLooper;
// Locking the looper also makes sure that the looper is valid
if (looper != NULL && looper->Lock()) {
// Have we locked the right looper? That's as far as the
// "pseudo-atomic" operation mentioned in the BeBook.
if (fLooper == looper)
return true;
// we locked the wrong looper, bail out
looper->Unlock();
}
return false;
}
void
TWindowMenu::DetachedFromWindow()
{
// in expando mode the teammenu will not call DragStop,
// thus, it needs to be called from here
TBarView *barview = (dynamic_cast<TBarApp*>(be_app))->BarView();
if (barview && barview->Expando()) {
BLooper *looper = barview->Looper();
if (looper->Lock()) {
Window()->Show(); // We changed the show level in AttachedToWindow(). Undo it.
barview->DragStop();
looper->Unlock();
}
}
BMenu::DetachedFromWindow();
}
status_t
BHandler::LockLooperWithTimeout(bigtime_t timeout)
{
BLooper* looper = fLooper;
if (looper == NULL)
return B_BAD_VALUE;
status_t status = looper->LockWithTimeout(timeout);
if (status != B_OK)
return status;
if (fLooper != looper) {
// we locked the wrong looper, bail out
looper->Unlock();
return B_MISMATCHED_VALUES;
}
return B_OK;
}
void ArpNotificationType::NotifyDependents(BMessage *msg, bool deliverAsynchronously)
{
BHandler *h;
BLooper *looper;
for (long i=0; (h = (BHandler*)dependents.ItemAt(i)) != 0; i++) {
if (((looper = h->Looper()) != 0)
&& (looper->Lock())) {
// FIX: need to send out the message, and let the views
// invalidate themselves! So be aware that the Update
// implementation will ALWAYS be called from within this
// loop, meaning within a lock/unlock
#if 0 // Uncomment this to debug where messages are going
printf("SENDING MESSAGE TO %s\n", h->Name()); fflush(stdout);
#endif
h->MessageReceived(msg);
looper->Unlock();
}
}
}
BHandler::~BHandler()
{
if (LockLooper()) {
BLooper* looper = Looper();
looper->RemoveHandler(this);
looper->Unlock();
}
// remove all filters
if (fFilters) {
int32 count = fFilters->CountItems();
for (int32 i = 0; i < count; i++)
delete (BMessageFilter*)fFilters->ItemAtFast(i);
delete fFilters;
}
// remove all observers (the observer list manages itself)
delete fObserverList;
// free rest
free(fName);
gDefaultTokens.RemoveToken(fToken);
}
BTranslatorRoster::Private::~Private()
{
stop_watching(this);
if (Looper() && LockLooper()) {
BLooper* looper = Looper();
Looper()->RemoveHandler(this);
looper->Unlock();
}
// Release all translators, so that they can delete themselves
TranslatorMap::iterator iterator = fTranslators.begin();
std::set<image_id> images;
while (iterator != fTranslators.end()) {
BTranslator* translator = iterator->second.translator;
translator->fOwningRoster = NULL;
// we don't want to be notified about this anymore
images.insert(iterator->second.image);
translator->Release();
iterator++;
}
// Unload all images
std::set<image_id>::const_iterator imageIterator = images.begin();
while (imageIterator != images.end()) {
unload_add_on(*imageIterator);
imageIterator++;
}
}
int32
ColorField::_UpdateThread(void *data)
{
// initialization
ColorField *colorField = (ColorField *)data;
BLooper *looper = colorField->Looper();
if (looper)
looper->Lock();
BBitmap* bitmap = colorField->fBgBitmap[0];
BView* view = colorField->fBgView[0];
port_id port = colorField->fUpdatePort;
if (looper)
looper->Unlock();
// draw
float h, s, v, r, g, b;
int R, G, B;
int32 msg_code;
char msg_buffer;
while (true) {
port_info info;
do {
read_port(port, &msg_code, &msg_buffer, sizeof(msg_buffer));
get_port_info(port, &info);
} while (info.queue_count);
if (looper)
looper->Lock();
uint colormode = colorField->fColorMode;
float fixedvalue = colorField->fFixedValue;
if (looper)
looper->Unlock();
bitmap->Lock();
view->BeginLineArray(256 * 256);
switch (colormode)
{
case R_SELECTED:
{
R = round(fixedvalue * 255);
for (int G = 0; G < 256; ++G)
for (int B = 0; B < 256; ++B)
DrawColorPoint(BPoint(G, 255.0 - B), R, G, B);
break;
}
case G_SELECTED:
{
G = round(fixedvalue * 255);
for (int R = 0; R < 256; ++R)
for (int B = 0; B < 256; ++B)
DrawColorPoint(BPoint(R, 255.0 - B), R, G, B);
break;
}
case B_SELECTED:
{
B = round(fixedvalue * 255);
for (int R = 0; R < 256; ++R)
for (int G = 0; G < 256; ++G)
DrawColorPoint(BPoint(R, 255.0 - G), R, G, B);
break;
}
case H_SELECTED:
{
h = fixedvalue;
for (int x = 0; x < 256; ++x) {
s = (float)x / 255.0;
for (int y = 0; y < 256; ++y) {
v = (float)y / 255.0;
HSV_to_RGB(h, s, v, r, g, b);
DrawColorPoint(BPoint(x, 255.0 - y), round(r * 255.0),
round(g * 255.0), round(b * 255.0));
}
}
break;
}
case S_SELECTED:
{
s = fixedvalue;
for (int x = 0; x < 256; ++x) {
h = 6.0 / 255 * x;
for (int y = 0; y<256; ++y) {
v = (float)y / 255.0;
HSV_to_RGB(h, s, v, r, g, b);
DrawColorPoint(BPoint(x, 255.0 - y), round(r * 255.0),
round(g * 255.0), round(b * 255.0));
}
}
break;
}
case V_SELECTED:
{
v = fixedvalue;
for (int x = 0; x < 256; ++x) {
h = 6.0 / 255 * x;
for (int y = 0; y < 256; ++y) {
s = (float)y / 255.0;
HSV_to_RGB(h, s, v, r, g, b);
DrawColorPoint(BPoint(x, 255.0 - y), round(r * 255.0),
round(g * 255.0), round(b * 255.0));
}
}
break;
}
}
view->EndLineArray();
view->Sync();
bitmap->Unlock();
looper = colorField->Looper();
if (looper && looper->Lock()) {
colorField->Update(2);
looper->Unlock();
}
}
return 0;
}
int32 MouseDragOrPopupWatcher(void* data)
{
BMessenger* TheMessenger = (BMessenger*)data;
BPoint StartPos;
uint32 StartButtons = 0;
bigtime_t StartTime = 0;
bool FirstCheck = true;
BMessage MessageToSend;
MessageToSend.AddPoint("where",BPoint(0,0));
MessageToSend.AddInt32("buttons",0);
MessageToSend.AddInt32("modifiers",0);
bigtime_t PopupTime;
if(get_click_speed(&PopupTime) != B_OK)
return 0;
PopupTime *= 2;
while(true)
{
if (!TheMessenger->LockTarget())
{
delete TheMessenger;
return 0; // window is dead so exit
}
BLooper *TheLooper;
BView* TheView = (BView*)TheMessenger->Target(&TheLooper);
BPoint Where;
uint32 Buttons;
bigtime_t Time = system_time();
TheView->GetMouse(&Where,&Buttons,false);
if(FirstCheck)
{
StartPos = Where;
StartButtons = Buttons;
StartTime = Time;
FirstCheck = false;
}
bool Send = false;
if(Buttons == 0 || Buttons != StartButtons)
{
//Changed or released
MessageToSend.what = MW_MOUSE_CLICK;
Send = true;
}
else if(Where.x < StartPos.x-1.0 || Where.x > StartPos.x+1.0 ||
Where.y < StartPos.y-1.0 || Where.y > StartPos.y+1.0)
{
MessageToSend.what = MW_MOUSE_DRAG;
Send = true;
}
else if(Time >= StartTime + PopupTime)
{
MessageToSend.what = MW_MOUSE_POPUP;
Send = true;
}
TheLooper->Unlock();
if(Send)
{
MessageToSend.ReplacePoint("where",StartPos);
MessageToSend.ReplaceInt32("buttons",Buttons);
MessageToSend.ReplaceInt32("modifiers",modifiers());
TheMessenger->SendMessage(&MessageToSend);
delete TheMessenger;
return 0;
}
snooze(50000);
}
}
