/**
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;
}
