C++ BWindow类代码示例

void ColumnListView::AddSortKey(int32 ColumnIndex)
{
	CLVColumn* Column;
	if(ColumnIndex >= 0)
	{
		Column = (CLVColumn*)fColumnList.ItemAt(ColumnIndex);
		if(!(Column->Flags()&CLV_SORT_KEYABLE))
			return;
	}
	else
		Column = NULL;
	if(Column && !fSortKeyList.HasItem(Column))
	{
		BWindow* ParentWindow = Window();
		if(ParentWindow)
			ParentWindow->Lock();
		BRect LabelBounds = fColumnLabelView->Bounds();
		fSortKeyList.AddItem(Column);
		if(Column->fSortMode == NoSort)
			SetSortMode(ColumnIndex,Ascending);
		SortItems();
		//Need to draw new underline
		fColumnLabelView->Invalidate(BRect(Column->fColumnBegin,LabelBounds.top,Column->fColumnEnd,
			LabelBounds.bottom));
		if(ParentWindow)
			ParentWindow->Unlock();
	}
}

void
TTracker::CloseAllWindows()
{
	// this is a response to the DeskBar sending us a B_QUIT, when it really
	// means to say close all your windows. It might be better to have it
	// send a kCloseAllWindows message and have windowless apps stay running,
	// which is what we will do for the Tracker
	AutoLock<WindowList> lock(&fWindowList);

	int32 count = CountWindows();
	for (int32 index = 0; index < count; index++) {
		BWindow *window = WindowAt(index);
		// avoid the desktop
		if (!dynamic_cast<BDeskWindow *>(window)
			&& !dynamic_cast<BStatusWindow *>(window))
			window->PostMessage(B_CLOSE_REQUESTED);
	}
	// count from end to beginning so we can remove items safely
	for (int32 index = fWindowList.CountItems() - 1; index >= 0; index--) {
		BWindow *window = fWindowList.ItemAt(index);
		if (!dynamic_cast<BDeskWindow *>(window)
			&& !dynamic_cast<BStatusWindow *>(window))
				// ToDo:
				// get rid of the Remove here, BContainerWindow::Quit does it
			fWindowList.RemoveItemAt(index);
	}	
}

void
BToolTipManager::ShowTip(BToolTip* tip, BPoint where, void* owner)
{
	BToolTip* current = NULL;
	void* currentOwner = NULL;
	BMessage reply;
	if (fWindow.SendMessage(kMsgCurrentToolTip, &reply) == B_OK) {
		reply.FindPointer("current", (void**)&current);
		reply.FindPointer("owner", &currentOwner);
	}

	// Release reference from the message
	if (current != NULL)
		current->ReleaseReference();

	if (current == tip || currentOwner == owner) {
		fWindow.SendMessage(kMsgShowToolTip);
		return;
	}

	fWindow.SendMessage(kMsgHideToolTip);

	if (tip != NULL) {
		BWindow* window = new BPrivate::ToolTipWindow(tip, where, owner);
		window->Show();

		fWindow = BMessenger(window);
	}
}

// ---------------------------------------------------------------------
//! Minimizes UI
// ---------------------------------------------------------------------
void BeSkinView::Minimize()
{
	BWindow* window = Window();
	BAutolock locker(window);
	
	window->Minimize(true);
}

int
main(int argc, char** argv)
{
	BApplication app("application/x-vnd.Antares-DrawAfterChildren");

	BRect frame(100, 100, 700, 400);
	BWindow* window = new BWindow(frame, "Window",
		B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE);

	frame.OffsetTo(B_ORIGIN);
	TestView* view = new TestView(frame);
	window->AddChild(view);

	frame.InsetBy(20, 20);
	frame.right = frame.left + frame.Width() / 2 - 10;
	BView* child = new ChildView(frame, "child 1",
		(rgb_color){ 200, 200, 200, 255 });
	view->AddChild(child);

	frame.OffsetBy(frame.Width() + 20, 0);
	child = new ChildView(frame, "child 2", B_TRANSPARENT_COLOR);
	view->AddChild(child);

	window->Show();

	app.Run();
	return 0;
}

// show_window
void
show_window(BRect frame, const char* name)
{
	BWindow* window = new BWindow(frame, name,
								  B_TITLED_WINDOW,
								  B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE);

	BView* view = new TestView(window->Bounds(), "test", B_FOLLOW_ALL,
							   B_WILL_DRAW/* | B_FULL_UPDATE_ON_RESIZE*/);

	window->AddChild(view);
	BRect b(0.0, 0.0, 50.0, 15.0);
	b.OffsetTo(5.0, view->Bounds().bottom - (b.Height() + 15.0));
	BButton* control = new BButton(b, "button", "Copy", new BMessage(MSG_COPY_BITS));
	view->AddChild(control);
	control->SetTarget(view);

	// test CopyBits() on top of children
	b = BRect(80, 130, 130, 160);
	BView* child = new BView(b, "some child", B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, 0);
	child->SetViewColor(255, 0, 0);
	view->AddChild(child);

	b = BRect(136, 127, 158, 140);
	child = new BView(b, "some other child", B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, 0);
	child->SetViewColor(255, 255, 0);
	view->AddChild(child);

	window->Show();
}

void
SButton::KeyDown(const char *bytes, int32 numBytes)
{
	if(numBytes == 1)
	{
		if(bytes[0] == B_ENTER || bytes[0] == B_RETURN || bytes[0] == B_SPACE)
		{
			BWindow *window = Window();

			BMessage *msg = window->CurrentMessage();

			if(msg)
			{
				if(msg->what == B_KEY_DOWN)
				{
					int32 key_repeat = 0;
					if(msg->FindInt32("be:key_repeat", &key_repeat) == B_OK)
					{
						if(key_repeat > 0) return;
					}
				}
			}

			waitting = true;
			waitting_is_keyboard = true;

			Draw(Bounds());
			window->UpdateIfNeeded();

			return;
		}
	}

	BView::KeyDown(bytes, numBytes);
}

int main(int argc, char ** argv)
{
	BApplication app("application/x-vnd.misza-SystemInfoReplicant");
	
	BRect temp,r;
	
	BPath path;
  	find_directory(B_USER_SETTINGS_DIRECTORY,&path);
  	path.Append("SystemInfoReplicant",true);
  	
  	BFile file(path.Path(),B_READ_ONLY);
  	if(file.InitCheck() == B_OK)
  	{
		BMessage msg;
  		msg.Unflatten(&file);
		if(msg.FindRect("frame",&temp) == B_OK)
			r = temp;
	
	}
	else
		r = BRect(250,250,424,385);
	
	
	BWindow* window = new SIReplicant(r);
	window->Show();
	app.Run();
	return 0;
}

int targatobpic(
	const unsigned char* targa, int targasize,
	BPicture* picture)
{
	BRect frame(0,0,100,100);	// arbitraire
	BBitmap *bitmap;
	BView *view;
	BWindow *window;
	
	bitmap=targatobbitmap(targa,targasize);
	if(!bitmap) return -1;
	
	window=new BWindow(frame,NULL,B_MODAL_WINDOW,0);
	view=new BView(frame,NULL,B_FOLLOW_NONE,0);
	window->AddChild(view);
	
	view->BeginPicture(picture);
	view->DrawBitmap(bitmap);
	view->EndPicture();
	
	delete bitmap;
	delete window;
	
	return 0;
}

bool
ProjectWindow::QuitRequested()
{
	if (fShowingLibs)
	{
		BString title("Libraries: ");
		title << fProject->GetName();
		for (int32 i = 0; i < be_app->CountWindows(); i++)
		{
			BWindow *win = be_app->WindowAt(i);
			if (title.Compare(win->Title()) == 0)
			{
				win->PostMessage(B_QUIT_REQUESTED);
				break;
			}
		}
	}
	
	fProject->Save();
	
	if (fErrorWindow)
	{
		fErrorWindow->Quit();
		fErrorWindow = NULL;
	}
	
	DeregisterWindow();
	return true;
}

void AmControlChangeReport::ReadSong(const AmSong* song)
{
	_AmControlEntryCollection	entries;
	const AmTrack*				track;
	for (uint32 k = 0; (track = song->Track(k)); k++) {
		_AmControlEntry			entry(track);
		control_report(&(track->Phrases()), entry);
		if (entry.controls.size() > 0) entries.AddEntry(entry);
	}

	BRect		f(100, 100, 400, 400);
	BWindow*	window = new BWindow(	f, "Control Change Report", B_DOCUMENT_WINDOW_LOOK,
										B_NORMAL_WINDOW_FEEL, B_ASYNCHRONOUS_CONTROLS);
	if (window) {
		BOutlineListView*	lv = new BOutlineListView(	BRect(0, 0, f.Width() - 15, f.Height() - 15), "outline",
														B_SINGLE_SELECTION_LIST, B_FOLLOW_ALL);
		if (lv) {
			entries.AddTo(lv);
			BScrollView*	scroll = new BScrollView("scroll", lv, B_FOLLOW_ALL, 0, true, true);
			if (scroll) window->AddChild(scroll);
			else window->AddChild(lv);
		}
		window->Show();
	}
}

/**
 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 */
static _EGLSurface *
haiku_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
	_EGLConfig *conf, void *native_window, const EGLint *attrib_list)
{
	CALLED();

	struct haiku_egl_surface* surface;
	surface = (struct haiku_egl_surface*) calloc(1, sizeof (*surface));
	if (!surface) {
		_eglError(EGL_BAD_ALLOC, "haiku_create_window_surface");
		return NULL;
	}

	if (!_eglInitSurface(&surface->surf, disp, EGL_WINDOW_BIT,
		conf, attrib_list)) {
		free(surface);
		return NULL;
	}

	(&surface->surf)->SwapInterval = 1;

	TRACE("Creating window\n");
	BWindow* win = (BWindow*)native_window;

	TRACE("Creating GL view\n");
	surface->gl = new BGLView(win->Bounds(), "OpenGL", B_FOLLOW_ALL_SIDES, 0,
		BGL_RGB | BGL_DOUBLE | BGL_ALPHA);

	TRACE("Adding GL\n");
	win->AddChild(surface->gl);

	TRACE("Showing window\n");
	win->Show();
	return &surface->surf;
}

void
BepdfApplication::MessageReceived (BMessage * msg)
{
	if (msg == NULL) {
		fprintf (stderr, "xpdf: message NULL received\n");
		return;
	}

	switch (msg->what) {
	case NOTIFY_QUIT_MSG:
		if (mWindow) {
			BWindow* w = mWindow;
			w->Lock();
			w->PostMessage(B_QUIT_REQUESTED);
			w->Unlock();
		}
		break;
	case NOTIFY_CLOSE_MSG:
		if (mWindow) {
			mWindow->Lock();
			mWindow->UpdateWindowsMenu();
			mWindow->Unlock();
		}
		break;
	case B_CANCEL:
		if (!mWindow && mReadyToQuit) {
			PostMessage(B_QUIT_REQUESTED);
		}
		break;
	default:
		BApplication::MessageReceived(msg);
	}
}

// SetExportMode
void
SavePanel::SetExportMode(bool exportMode)
{
	BWindow* window = Window();
	if (!window || !window->Lock())
		return;

	// adjust window title and enable format menu
	BString helper("Icon-O-Matic: ");
	if (exportMode) {
		fFormatMF->SetEnabled(true);
		SetExportMode(fExportMode);
		_EnableSettings();
		helper << B_TRANSLATE_CONTEXT("Export Icon", "Dialog title");
	} else {
		fExportMode = ExportMode();
			// does not overwrite fExportMode in case we already were
			// in native save mode
		fNativeMI->SetMarked(true);

		fFormatMF->SetEnabled(false);
		fSettingsB->SetEnabled(false);
		helper << B_TRANSLATE_CONTEXT("Save Icon", "Dialog title");
	}

	window->Unlock();
}

void
ImageView::MouseUp(BPoint point)
{
	BWindow *parent = Window();
	if (parent)
		parent->PostMessage(P_MSG_CLOSE);
}