Some
Microsystems OpenWindows is a network-based ex-development environment that includes the
OpenLock graphical user interface, the Desset end-user productivity tools, the robust ex-view
toolkit, the powerful ex-11 news windowing system, and open fonts technology. With OpenWindows,
some provides end-users and developers with a rich, robust, and cohesive environment.
Developing applications to the OpenWindows environment provides the ability to effectively
distribute applications and resources across a heterogeneous network. The OpenWindows Developers
Guide is just one example of how Sun addresses the needs of developers. Designing an effective
user interface for an application program can be a painstaking, time-consuming, and costly process,
but the OpenWindows Developers Guide has changed all that. This tool is a prototype that makes the
creation of an OpenLock user interface quick and easy. Hi, I'm Bob Watson. Today, I'm going to give
you an introduction to this remarkable new graphical and interactive layout tool. I'll be
spending some time talking to you about the features of the product, how it can help both
users and developers, and how it works in principle. Later on in the program, we'll actually be
demonstrating the components of the tool, going over the step-by-step process so that you can see
just exactly how the OpenWindows Developers Guide can assist you in the work you're planning. First,
let's see how the product works in general. As I demonstrate on the screen, I think you'll see
what an easy process layout becomes. With this type of development tool, time and cost to create,
test, and maintain applications are greatly reduced. The development process for layout
of any user interface can usually be divided into two stages, user interface design and
application code development. With this tool, developers can easily design and test a user
interface before writing any application code, and they can continue to make changes to the
interface as they develop their applications. The product's design features are easily mastered
as well. The program allows you to select OpenLock components off a palette and then
drag them off onto your desktop to layout the design. It also allows you to bring up
OpenLock property windows so you can change the attributes of the components. And as I mentioned,
test the interface before writing any code. When you are finished with the design, the
Developers Guide will generate the X-View C code that defines the interface. In addition,
applications built with the product support the drag-and-drop model of the desk set. For example,
icons representing ASCII files can be selected from the desk set file manager and dropped onto
application text panes to load the files. This integration with the desk set provides a cohesive
integrated environment to the end user. Now let's take a look at the Open Window Developers Guide
demo. That should give you a real idea of how this tool works. On the left, you see the two types of
window, base window and pop-up window. Then we have four different pane types that can reside
inside a window. Controls, graphics, text and terminal emulation. And on the right,
we have the control elements that can reside inside a control area. Buttons, settings,
sliders, messages, text and scrolling lists. Let's go ahead and design a simple interface
for a text application. First, we'll select the base window and drag it onto the desktop.
We'll then resize it. You can see the resize corners, the window menu button and the window
menu are automatically provided. All of the components have property windows. Property
windows enable you to assign or change certain attributes of the object. We'll bring up the
base window property editor so we can change the label. Now when we apply the change, the
base window header is updated. Next, we'll create a control area. The control area is a container
for the open look control types, buttons, menus and settings. Now we'll grab the handles and
resize the control area. The developers guide supports both constrained and unconstrained
resizing. Now we'll create three buttons and a setting. The controls are automatically aligned
on a grid or we select some or all of the objects and align them together horizontally or vertically.
To change the attributes of these buttons, we'll use the button property editor. This scrolling
list shows all the buttons that have been defined for this interface. The name parameter defines
the handle that will be generated in the final C source. The label is the name that will appear
in the button. Let's change this to file. You can specify whether you want a text label or an image
that has been created via the icon editor. For the label, you can specify normal or bold font. The X
and Y location is also specified here. You can make the button a menu button by specifying the
name of the menu to call. We will call the menu called file menu. The notify handler specifies
the callback procedure to be executed when the button is pushed. Since we are creating a menu
here, we have no need to specify notify handler as this work will be done in the menu handler.
The event handler specifies the routines to execute when certain events happen. You can
track keyboard as well as mouse events. This allows you to manipulate the object at a much
lower level than is normally possible. The color chooser allows you to color objects. When you
select the color button, the developer's guide brings up a color palette that displays the 75
standard colors provided by the X server. We'll select a color, press the apply button, and you
can see that the button has changed its color. The developer's guide enables you to also supply
help text for your interface. To provide help text for this button, we select the help text button.
This brings up the help text editor. The menu editor is where we can describe the menu behind
this button. We can specify the menu name and the title that will appear when the menu is pinned.
We have different types of menus. We'll go with the default of command menu. We can also
determine if the menu is a one or multiple column menu. We can specify whether the menu
is pinnable or not. By default, we'll create a pinnable menu so it will appear with a push
pin. Now we can add and edit the elements of the menu. We will have three items to our menu,
save, save as, and close. We can also create sub menus or pull rights by specifying the
menu to call when a button is selected. Now we can apply the changes and you can see that the menu
glyph now appears in our file button. We can quickly edit the other two buttons to change
their labels. Likewise, we can bring up the property editor for our setting. This setting
will be used to specify the type of font to be used. So we'll change its label to text and
change the choices to normal and bold. In this case, we want an exclusive setting. That is one
where only one of the choices can be chosen. Open Look also offers non-exclusive settings
where any number of the choices can be chosen. There are also two alternative display options,
the checkbox or the stack. Finally, we'll select and drop a text pane into our interface. Open
Look automatically provides you with a scroll bar on the right side of the text pane. We'll
bring up the property window for the text pane and add an event handler. This will cause the
developer's guide to automatically generate the correct code to support drag and drop. Another
important Open Look concept. We'll use the color chooser again to select a background color for
the text. The design is now complete. We'll put the developer's guide into test mode to test the
interface. No code has been generated yet, but we're still able to test the look and feel of
the interface. We can bring up the menu, select the buttons and make our choices. We can also
key in text to the text pane. Now that we've finished our design, we'll save the description
in a file. Now GXV, the X-View code generator, is run on the description file to create the
source code. GXV also creates a make file to ease the build process. While make does the component
link, let's detail what each of the files do. The UI.h file contains all the developer's guide
specific declarations for objects. The UI.c file contains all the X-View C code defining the
interface. The .info file contains all the help text in X-View format. And the stubs.c file contains
the main loop and all the empty callback procedures. Now we can bring up the interface and you can see
that the menus work. We can drop a text file into the text pane. This demonstrates how applications
built via the developer's guide can support drag and drop. I hope that demonstration gives you a
clear idea of just what the open window developer's guide can do for developers. You've seen how easy
it is to design an open look user interface using this tool. Greatly reducing time and money in the
applications development. You've also seen how applications built with open window developer's
guide can integrate into the desk set environment. And you've seen how you can graphically lay out
the design of the interface and rely on the tool to generate the X-View code defining the interface.
Open windows developers guide reflects Sun's commitment to provide the best X development
environment to its customers. The open look graphical user interface and desk set have brought
productivity and ease of use to the end user. Open windows developers guide brings productivity
and ease of development to the applications developer. Through open windows Sun has brought
ease of use to the Unix world. Thanks for watching.