/** 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 ColorPickerPanel::MessageReceived(BMessage* message) { switch (message->what) { case MSG_CANCEL: case MSG_DONE: { BMessage msg('PSTE'); BLooper* looper = fTarget ? fTarget->Looper() : be_app; if (fMessage) msg = *fMessage; if (message->what == MSG_DONE) store_color_in_message(&msg, fColorPickerView->Color()); msg.AddRect("panel frame", Frame()); msg.AddInt32("panel mode", fColorPickerView->Mode()); msg.AddBool("begin", true); looper->PostMessage(&msg, fTarget); PostMessage(B_QUIT_REQUESTED); break; } default: Panel::MessageReceived(message); break; } }
/** RemoveHandler(BHandler* handler) @case handler is NULL @param handler NULL @results RemoveHandler() returns false. R5 implementation seg faults; we've fixed that. */ void TRemoveHandlerTest::RemoveHandler1() { BLooper Looper; #ifndef TEST_R5 CPPUNIT_ASSERT(!Looper.RemoveHandler(NULL)); #endif }
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; } } } } }
void BHandler::SetFilterList(BList* filters) { BLooper* looper = fLooper; if (looper != NULL && !looper->IsLocked()) { debugger("Owning Looper must be locked before calling SetFilterList"); return; } /** @note I would like to use BObjectList internally, but this function is spec'd such that fFilters would get deleted and then assigned 'filters', which would obviously mess this up. Wondering if anyone ever assigns a list of filters and then checks against FilterList() to see if they are the same. */ // TODO: Explore issues with using BObjectList if (fFilters != NULL) { fFilters->DoForEach(FilterDeleter); delete fFilters; } fFilters = filters; if (fFilters) { for (int32 i = 0; i < fFilters->CountItems(); ++i) { BMessageFilter* filter = static_cast<BMessageFilter*>(fFilters->ItemAt(i)); if (filter != NULL) filter->SetLooper(looper); } } }
/* bool IsTargetLocal() const @case 2 this is initialized to local target with preferred handler @results should return true. */ void TargetTester::IsTargetLocalTest2() { status_t result = B_OK; BLooper *looper = new BLooper; looper->Run(); LooperQuitter quitter(looper); BMessenger messenger(NULL, looper, &result); CHK(messenger.IsTargetLocal() == true); }
/* BHandler *Target(BLooper **looper) const @case 2 this is initialized to local target with preferred handler, looper is NULL @results should return NULL. */ void TargetTester::TargetTest2() { status_t result = B_OK; BLooper *looper = new BLooper; looper->Run(); LooperQuitter quitter(looper); BMessenger messenger(NULL, looper, &result); CHK(messenger.Target(NULL) == NULL); }
// SelectionChanged void SimpleListView::SelectionChanged() { BLooper* looper = Looper(); if (fSelectionChangeMessage && looper) { BMessage message(*fSelectionChangeMessage); looper->PostMessage(&message); } }
void TQuitTest::QuitTest2() { BLooper* looper = new BLooper; looper->Run(); BMessage reply; BMessenger(looper).SendMessage(B_QUIT_REQUESTED, &reply); }
/** 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)); }
/** SetNextHandler(BHandler* handler); NextHandler(); @case Handler1 and Handler2 belong to the same locked BLooper @param handler Valid BHandler pointer @results Returns Handler2 */ void TSetNextHandlerTest::SetNextHandler11() { BLooper Looper; BHandler Handler1; BHandler Handler2; Looper.AddHandler(&Handler1); Looper.AddHandler(&Handler2); Handler1.SetNextHandler(&Handler2); CPPUNIT_ASSERT(Handler1.NextHandler() == &Handler2); }
status_t ObservableHandler::notify( BMessage* message) { #if DEBUG BLooper* l = Looper(); ASSERT(l); ASSERT(l->IsLocked()); #endif return Invoke(message); }
void Unlock() { if (fHasLock) { BLooper *looper; fMessenger->Target(&looper); if (looper) looper->Unlock(); fHasLock = false; } }
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); }
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); } }
/** RemoveHandler(BHandler* handler) @case Valid looper and handler; handler has filters @param handler Valid BHandler pointer @results RemoveHandler() returns true handler->FilterList() returns NULL after removal */ void TRemoveHandlerTest::RemoveHandler5() { BLooper Looper; BHandler Handler; BMessageFilter* MessageFilter = new BMessageFilter('1234'); Handler.AddFilter(MessageFilter); Looper.AddHandler(&Handler); CPPUNIT_ASSERT(Looper.RemoveHandler(&Handler)); CPPUNIT_ASSERT(Handler.FilterList()); }
/** SetNextHandler(BHandler* handler); NextHandler(); @case Handler1 belongs to a locked BLooper, Handler2 does not @param handler Valid BHandler pointer @results NextHandler() returns BLooper debug message "The handler and its NextHandler must have the same looper" */ void TSetNextHandlerTest::SetNextHandler3() { DEBUGGER_ESCAPE; BHandler Handler1; BHandler Handler2; BLooper Looper; Looper.AddHandler(&Handler1); Handler1.SetNextHandler(&Handler2); CPPUNIT_ASSERT(Handler1.NextHandler() == &Looper); }
/** SetNextHandler(BHandler* handler); NextHandler(); @case Handler2 belongs to a unlocked BLooper, Handler1 does not @param handler Valid BHandler pointer @results NextHandler() returns NULL debug message "handler must belong to looper before setting NextHandler" */ void TSetNextHandlerTest::SetNextHandler4() { DEBUGGER_ESCAPE; BHandler Handler1; BHandler Handler2; BLooper Looper; Looper.AddHandler(&Handler2); Looper.Unlock(); Handler1.SetNextHandler(&Handler2); CPPUNIT_ASSERT(Handler1.NextHandler() == NULL); }
SharedTimerHaiku* SharedTimerHaiku::instance() { BLooper* looper = BLooper::LooperForThread(find_thread(0)); static SharedTimerHaiku* timer; if (!timer) { BAutolock lock(looper); timer = new SharedTimerHaiku(); looper->AddCommonFilter(timer); } return timer; }
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; }
status_t ObservableHandler::Archive( BMessage* archive, bool deep) const { #if DEBUG BLooper* l = Looper(); ASSERT(l); ASSERT(l->IsLocked()); #endif if(m_released) return B_NOT_ALLOWED; // can't archive a dead object return _inherited::Archive(archive, deep); }
/* bool operator==(const BMessenger &other) const bool operator!=(const BMessenger &a, const BMessenger &b) @case 1 this (a) is initialized, other (b) is uninitialized, and vice versa @results should return false/true. */ void MessengerComparissonTester::ComparissonTest2() { // create looper BLooper *looper = new BLooper; looper->Run(); LooperQuitter quitter(looper); // create messenger BMessenger a(NULL, looper); BMessenger b; CHK(a != b); CHK(b != a); CHK(!(a == b)); CHK(!(b == a)); }
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; }
void ObservableHandler::_handleAddObserver( BMessage* message) { #if DEBUG BLooper* l = Looper(); ASSERT(l); ASSERT(l->IsLocked()); #endif BMessage reply; BMessenger observer; status_t err = message->FindMessenger( "observer", &observer); if(err < B_OK) { PRINT(( "* ObservableHandler::_handleAddObserver(): no observer specified!\n")); // send reply? +++++ return; } if(m_released) { // already quitting reply.what = M_BAD_TARGET; reply.AddMessenger("target", BMessenger(this)); reply.AddMessenger("observer", observer); message->SendReply(&reply); return; } else if(IndexOfTarget(observer.Target(0)) != -1) { // observer already added reply.what = M_BAD_OBSERVER; reply.AddMessenger("target", BMessenger(this)); reply.AddMessenger("observer", observer); message->SendReply(&reply); return; } // valid observer given // add it err = AddTarget(observer.Target(0)); ASSERT(err == B_OK); // call hook observerAdded(observer); }
/* 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); }
bool BHandler::RemoveFilter(BMessageFilter* filter) { BLooper* looper = fLooper; if (looper != NULL && !looper->IsLocked()) { debugger("Owning Looper must be locked before calling SetFilterList"); return false; } if (fFilters != NULL && fFilters->RemoveItem((void*)filter)) { filter->SetLooper(NULL); return true; } return false; }
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 BLooper::_task0_(void* arg) { BLooper* looper = (BLooper*)arg; PRINT(("LOOPER: _task0_()\n")); if (looper->Lock()) { PRINT(("LOOPER: looper locked\n")); looper->task_looper(); delete looper; } PRINT(("LOOPER: _task0_() done: thread %ld\n", find_thread(NULL))); return B_OK; }