Uh-oh, it looks like your Internet Explorer is out of date.

For a better shopping experience, please upgrade now.

Programming the Be Operating System

Programming the Be Operating System

by Dan Parks Sydow, Andy Oram (Editor)

The Be operating system is a great platform just waiting for applications. Elegant, object-oriented to the core, and primed for great graphical interfaces, Be meets the needs of computer users at the turn of the century — but they call for equally elegant applications for displaying and manipulating content. This book gives C++ programmers their start to


The Be operating system is a great platform just waiting for applications. Elegant, object-oriented to the core, and primed for great graphical interfaces, Be meets the needs of computer users at the turn of the century — but they call for equally elegant applications for displaying and manipulating content. This book gives C++ programmers their start to developing those applications.Be will prove to be a pleasure for developers who have struggled with APIs on Microsoft Windows, the Macintosh, or the X Window System. It provides consistent and intuitive methods for creating interfaces and handling messages. But you'll still have a hard time if all you have to learn from is official reference documentation like the Be Developer's Guide (also published by O'Reilly & Associates). This book is a traditional guide to application development that starts with the most basic concepts and leaves you with a firm foundation for further research.The book begins with typical "Hello, world" programs and gradually adds elements of the graphical interface. It carefully describes drawing and message handling. While the focus is on the graphical interface, basic OS features like threads and file handling are also introduced.Be runs on both PowerPC and Intel platforms, offering the same API on both. The programs in this book will therefore compile and run on any platform. Be's own integrated development environment, BeIDE (originally Metrowerks CodeWarrior), is used to develop all examples.

Product Details

O'Reilly Media, Incorporated
Publication date:
Product dimensions:
7.04(w) x 9.18(h) x 0.81(d)

Related Subjects

Read an Excerpt

Chapter 8: Text

The BeOS makes it simple to display text in a view--you've seen several examples of calling the BView functions SetFont() and DrawString() to specify which font a view should use and then draw a line of text. This approach works fine for small amounts of plain text; your application, however, is more likely to be rich in both graphics and text--so you'll want to take advantage of the BFont, BStringView, BTextView, BScrollBar, and BScrollView classes.

The BFont class creates objects that define the characteristics of fonts. You create a BFont object based on an existing font, then alter any of several characteristics. The BeOS is quite adept at manipulating fonts. You can alter basic font features such as size and spacing, but you can also easily change other more esoteric font characteristics such as shear and angle of rotation. You can use this new font in subsequent calls to DrawString(), or as the font in which text is displayed in BStringView, BTextView, or BScrollView objects.

A BStringView object displays a line of text, as a call to the BView function DrawString() does. Because the text of a BStringView exists as an object, this text knows how to update itself--something that the text produced by a call to DrawString() doesn't know how to do.

More powerful than the BStringView class is the BTextView class. A BTextView object is used to display small or large amounts of editable text. The user can perform standard editing techniques (such as cut, copy, and paste) on the text of a BTextView object. And the user (or the program itself) can alter the font or font color of some or all of the text in such an object.

If the text of a BTextView object extends beyond the content area of the object, a scrollbar simplifies the user's viewing. The BScrollBar class lets you add a scrollbar to a BTextView. Before adding that scrollbar, though, you should consider creating a BScrollView object. As its name implies, such an object has built-in support for scrollbars. Create a BTextView object to hold the text, then create a BScrollView object that names the text view object as the scroll view's target. Or, if you'd like to scroll graphics rather than text, name a BView object as the target and then include a BPicture in that BView. While this chapter's focus is on text, it does close with an example adding scrollbars to a view that holds a picture.


In the BeOS API, the BFont class defines the characteristics of a font--its style, size, spacing, and so forth. While the BFont class has not been emphasized in prior chapters, it has been used throughout this book. Every BView object (and thus every BView-derived object) has a current font that affects text displayed in that view. In previous examples, the BView-derived MyDrawView class used its AttachedToWindow() function to call a couple of BView functions to adjust the view's font: SetFont() to set the font, and SetFontSize() to set the font's size:

void MyDrawView::AttachedToWindow()

A view's current font is used in the display of characters drawn using the BView function DrawString(). Setting a view's font characteristics in the above fashion affects text produced by calls to DrawString() in each MyDrawView object.

The above snippet illustrates that the examples to this point have done little to alter the look of a font. Making more elaborate modifications is an easy task. Later in this chapter, you'll use some of the following techniques on text displayed in text view objects--editable text objects based on the BTextView class.

System Fonts

When designing the interface for your application, you'll encounter instances where you want a consistent look in displayed text. For example, your application may have a number of windows that include instructional text. In such a case, you'll want the text to have the same look from window to window. To ensure that your application can easily do this, the BeOS defines three fonts guaranteed to exist and remain constant for the running of your application.

The three global system fonts

The three constant fonts, or global system fonts, are BFont objects. When an application launches, these BFont objects are created, and three global pointers are assigned to reference them. Table 8-1 shows these global BFont objects. Figure 8-1 shows a window running on my machine; the figure includes a line of text written in each of the three system fonts.

Contradictory as it sounds, the user can change the font that's used for any of the global system fonts. Figure 8-2 shows that the FontPanel preferences program lets the user pick a different plain, bold, or fixed font. This means that your application can't count on a global font pointer (such as be_plain_font) always representing the same font on all users' machines. You can, however, count on a global font pointer to always represent only a single font on any given user's machine--regardless of which font that is. So while you may not be able to anticipate what font the user will view when you make use of a global font pointer in your application, you are assured that the user will view the same font each time that global font pointer is used by your application.

Using a global system font

You've already seen how to specify one of the global fonts as the font to be used by a particular view: just call the BView function SetFont() within one of the view's member functions. The AttachedToWindow() snippet that appears above provides an example. That method initializes all of the objects of a particular class to use the same font. In the above example, all MyDrawView objects will initially display text in the font referenced by be_bold_font. For a particular view to have its current font set to a different system font, have that view call SetFont() after the view has been created:

MyDrawView *theDrawView;
theDrawView = new MyDrawView(frameRect, "MyDrawView");

While a BeOS machine may have more than the three system fonts installed, your application shouldn't make any font-related assumptions. You can't be sure every user has a non-system font your application uses; some users may experience unpredictable results when running your application. If you want your program to display text that looks different from the global fonts (such as a very large font like 48 points), you can still use a global font to do so, as the next section illustrates.

TIP: Your program shouldn't force the user to have a particular non- system font on his or her machine, but it can give the user the option of displaying text in a non-system font. Consider a word processor you're developing. The default font should be be_plain_font. But your application could have a Font menu that allows for the display of text in any font on the user's computer. Querying the user's machine for available fonts is a topic covered in the BFont section of the Interface Kit chapter of the Be Book.

Global fonts are not modifiable

A global font is an object defined to be constant, so it can't be altered by an application. If a program could alter a global font, the look of text in other applications would be affected. Instead, programs work with copies of global fonts. While calling a BView function such as SetFontSize() may seem to be changing the size of a font, it's not. A call to SetFontSize() simply specifies the point size at which to display characters. The font itself isn't changed -- the system simply calculates a new size for each character and displays text using these new sizes....

Meet the Author

Sydow is a graduate of the Milwaukee School of Engineering.

Customer Reviews

Average Review:

Post to your social network


Most Helpful Customer Reviews

See all customer reviews