1.2.1. The X Window System and Xlib

  XTextExtents( font_info, menu_item, strlen( menu_item ),
    &direction, &ascent, &descent, &overall );
  menu_width = overall.width + 4;
  menu_pane_height = overall.ascent + overall.descent + 4;
  menu_height = menu_pane_height * menu_pane_count;
  x = window_width - menu_width - ( 2 * menu_border_width );
  y = 0;

XCreateSimpleWindow draws the menu with the proper border and background colors, although nothing appears on the display because the window hasn't yet been mapped.

  theMenu = XCreateSimpleWindow( theDisplay, theWindow,
    x, y, menu_width, menu_height,
    menu_border_width, theBorderPixel,
    theBackgroundPixel );

But every menu item is itself a tiny window, so create them all, save the structure pointers for later use, and select the events they'll respond to. Notice that we haven't drawn the actual text of the menu items. To do that, we need to define font and graphic context items, then call XDrawImageString to paint the characters (that's all done in initialization and event handler code):

  for( i = 0; i < menu_pane_count; i++ ) {
    menu[i].menu_pane = XCreateSimpleWindow(
      theDisplay, theMenu, 0, menu_height/menu_pane_count*i,
      menu_width, menu_pane_height, menu_border_width = 1,
      theForegroundPixel, theBackgroundPixel );
    XSelectInput( theDisplay, menu[i].menu_pane, EVENT_MASK3 );
  }

  XMapSubWindows( theDisplay, theMenu );

The symbol EVENT_MASK3 enumerates the events applicable to the menu item windows:

#define EVENT_MASK3 ButtonPresMask | ButtonReleaseMask |
  ExposureMask | EnterWindowMask | LeaveWindowMask

Now we must write the event handlers, including an Expose handler that actually draws the windows, our own event loop, and even our own event dispatching code, and on and on and on .... Whew!

Programming with higher-level libraries such as Motif or Xt is somewhat more civilized, but it's no walk in the park either. A significant stumbling block was that no matter what library you used, X remained in the clutches of C programmers. C is a fine language, but it kept X in the hands of the professionals—no hobbyists or hackers need apply. If you needed to develop an in-house tool (e.g., for tracking bugs), many companies would balk at spending the time and resources required for developing a C application, so you'd end up with a clunky script with a command-line interface.

Something had to be done, and something was.

1.2.2. The Coming of Tcl/Tk

In early 1991, Ousterhout released Tk Version 1.0, the graphical extension to the Tcl scripting language. Tk's high-level widget set (which ultimately uses Xlib as its drawing package) was an immediate hit. In the years following, thousands of Tcl/Tk applications were written and Tk was ported to languages such as Eiffel, Modula-3, Prolog, Python, Scheme, and more.

1.2.3. The Evolution of Perl/Tk

Here's an early TkPerl "Hello World" program:

use Tk;
$mw = tkinit;
$b = Button::new($mw, -text => 'Hello World');
$b->configure(-method => sub {exit});
tkpack($b);
tkmainloop;

If this looks odd to you, remember it was the state of affairs nearly eight years ago, when TkPerl was alpha, and Perl's object-oriented features were still beta. Notice that pack hadn't yet been turned into a widget method and was renamed tkpack so it didn't conflict with Perl's built-in function by the same name. Yet it worked, and it let us use Tk from Perl, which, after all, was the goal.

Figure 1-1. Hello, Perl/Tk

This window was created with the following Perl one-liner:

perl -MTk -e 'MainWindow->new->Label(-text => "Hello, Perl/Tk")->pack; MainLoop'

This example highlights just how far we've come.

1.2.4. Perl/Tk Meets Win32

Simultaneously, Sarathy was heading the effort to combine the disparate Perl ports into a unified Unix and Win32 distribution, commonly called Oneperl. Finally, in the summer of 1998, we had one Perl, 5.005, for Unix and Win32. ActiveState Corporation distributes this unified Perl in binary form, used on most Win32 systems these days.

Around July 1998, Nick produced a unified Unix and Win32 Perl/Tk distribution, and placed a binary version of Perl/Tk 800.010 in ActiveState's PPM repository. The result is that Win32 users can simply download binary installation packages of Perl and Tk. For most Unix users, using a simple idiom, you compile Perl and Tk yourself. If you're really lucky, you can search the Web and find a binary distribution of Perl/Tk for your particular flavor of Unix.

Running Perl/Tk Programs on Win32 There are no differences between writing Perl/Tk applications on Unix or Windows machines. You can use any simple text editor on either system. However, there can be a small difference in the way you run them. The lowest common denominator is to manually invoke Perl and specify the Perl/Tk program filename on the command line, like this: perl myprog.pl A Unix user commonly gives his program execute permission and ensures that the first line of the program is a valid "bang" line. This allows the user to invoke Perl/Tk programs by name. When invoking a program by name, the Unix command processor, called the shell program, inspects the file's first line and, if it begins with the characters #!, treats the remainder of the line as the command to execute, possibly with arguments. The ! character is the bang. A line of this form invokes Perl with the -w switch: #!/usr/local/bin/perl -w Conceptually, Win32 users do the same thing by associating the extension .pl with the Perl interpreter, so they can use Explorer and double-click the script to execute it. See Appendix A, "Installing Perl/Tk" for more details.