When you create a scroll-bar widget, for example, you can place that scroll bar in a window in your application. The widget set and the Xt Intrinsics take care of the messy part of managing the scroll-bar widget. Your application only needs to worry about the data to scroll, if that. In other words, the act of creating a widget also launches that widget. The X toolkit handles the rest. (Well, most of it, anyway.)

In your programs, you normally don't have to worry about what is in the widget structure. You just pass a pointer to the structure around to all the widget-handling routines. In fact, it's a lot easier to simply ignore what is in the widget structures and treat widgets as opaque data types, at least until you're trying to extend the current widget set by adding your own widgets. That's definitely an advanced topic. One nice thing you'll notice about using X widget sets is that you write a lot less code. (What code you do write, though, is more convoluted.) Just compare the length of this month's sample program to last month's and you'll see what we mean.

#include <X11/Intrinsic.h>
Widget XtInitialize(
   String shell_name,
   String application_class,
   XrmOptionDescRec xrm_options [],
   Cardinal number_options,
   Cardinal *argc,/* note indirection */
   String argv[]);

#include <stdio.h>
#include <X11/Intrinsic.h>

main(int argc, char *argv[])
   { /* main */
   Widget parent;
   .....
   parent = XtInitialize(
      argv[0], /* shell or app name */
      "Xaw1",  /* application class */
      NULL,
      0,       /* No Xrm Options */
      &argc, argv);

Once you've initialized the Xt Intrinsics, you get back a top-level shell widget, which basically corresponds to your application's top-level window. This widget is the highest parent for all of the widgets you create — and every widget you create needs a parent. The next level of widgets you create will use this as the parent widget. You'll be creating plenty of widgets, or else your Athena widget programs will be pretty boring. We'll create three simple widgets in the sample program. The easiest is a Label widget.

Arg args[10];
int n;
Widget parent_widget;
Widget label;

n = 0;
XtSetArg(
   args [n],
   XtNlabel,
   "This is a label." ); n++;
label = XtCreateManagedWidget(
   "label",         /* name */
   labelWidgetClass,/* widget class */
   parent_widget,   /* parent widget */
   args,            /* changes */
   n );             /* number in args */

String name;
WidgetClass widgetclass;
Widget parent;
ArgList args;
Cardinal number_args;

Widget XtCreateManagedWidget(
name, widgetclass,
   parent, args, number_args );

XtSetArg takes three parameters, an Arg structure, a name for the resource we're setting, and a value. You normally don't worry about their types. Instead, just follow the conventions when calling XtSetArg, even though that makes for some strange-looking code:

Arg args [10];
int n;

n = 0;
XtSetArg( args[n], XtNlabel,
   "This is a label." ); n++;

We've set up a compile-time option to tell the C compiler where the Athena include files are. Since so many things depend on X11 Release 4, we use the symbol X11R4. If you have not upgraded to at least R4 yet, comment out the following line in the sample program:

#define X11R4    /* define this for
X11 Release 4+  */

But first, we create the Command widget with XtCreateManagedWidget, using a class of Command WidgetClass this time:

#include <X11/Xaw/Command.h>
.....
Arg args[10];
int n;
Widget quit, parent_widget;

n=0;
quit = XtCreateManagedWidget( "quit",
   commandWidgetClass, parent_widget, args, n );

Widget widget;
String callback_name;
XtCallbackProc callback_function;
XtPointer client_data;

XtAddCallback ( widget, callback_name,
   callback_function, client_data );

void quit_callback( widget,
   client_data, call_data )
   Widget widget;
   caddr_t client_data;/* your data */
   caddr_t call_data;  /* data passed
                    from Xt */
   { /* quit_callback */ }

To create a paned window container widget, we again use XtCreateManagedWidget, with a class of panedWidgetClass.

#include <X11/Xaw/Paned.h>
.....
   Widget  parent_widget, paned_widget;
   Arg  args[20];
   int  n;

   n = 0;
   paned_widget = XtCreateManagedWidget( "pane",
      panedWidgetClass, parent_widget, args, n );

Since we want the Label and Command widgets to be inside the panes of the Paned widget, we need to create the Paned widget first and make the other two widgets children of the Paned widget. The Paned widget is a child of the parent widget returned by XtInitialize, above. The Command and Label widgets must be children of the Paned widget; that is, the Paned widget is the parent widget passed to XtCreateManagedWidget.

Widget parent;

XtRealizeWidget( parent );

If you have Release 4, you'll probably want to use the newer XtAppMainLoop, instead of XtMainLoop.