packages icon



 XPIP(1)                            V2.2                             XPIP(1)
                                12 APRIL 1999



 NAME
      xpip - XPIP X widget

 SYNOPSIS
      xpip

 DESCRIPTION
      The X Portable Interface Package (XPIP) is a development tool which
      allows application programmers to quickly construct graphical user
      interfaces (GUIs) in an X Windows environment. The interface takes the
      form of a series of user-definable "widgets" - buttons, sliders,
      dials, etc. - which applications employ for varying parameters,
      control flow, input/output, and other alterable processes. Although
      not nearly as comprehensive as several commercial and other freeware
      GUI packages such as xtoolkit and TKL/TK, XPIP provides a balance
      between ease of use and sophistication which make it appealing for the
      more casual programmer. A thorough reading of this brief manual should
      allow anyone with C experience and a basic knowledge of X Windows
      libraries to construct interactive graphics routines. Any color X
      Windows system should support XPIP.

      A predecessor to XPIP, the PIP system, was originally developed to aid
      in the development of stimuli for visual psychophysical experiments at
      Boston University's Department of Cognitive and Neural Systems. The
      vastly improved XPIP has since been used for interactive simulation of
      dynamic systems, control of multi-parameter simulations, animation of
      time-series data, and a variety of other applications. The source code
      and documentation to XPIP are freely distributed by Enkidu Research,
      Inc.

      The XPIP system consists of an unalterable library of routines,
      combined with a single user-modified "buffer" file which provides the
      system with access to application-specific routines. In addition, at
      run-time a number of additional files are loaded to specify the
      general structure of the interface as well as the specific layout and
      appearance of widgets on the screen. Unlike other interface packages,
      such as xtoolkit, XPIP widgets are not designed to be completely
      transparent to the application programmer. A variety of routines are
      provided to allow the user direct access to the internal data fields
      of each widget, while still maintaining some degree of information
      hiding. In addition, the experienced programmer may choose to directly
      manipulate widget data fields. An XPIP application is divided into a
      series of panels, each of which contains a set of widgets (or
      controls). Any number of panels may appear on the screen at one time.
      The widgets of each panel are defined in a .if file, with the
      particular filename(s) provided in the parameter definition file,
      xpip.cf. The xpip.cf file is not only used to specify where to look
      for widget definitions, but also for defining default widget
      parameters (\g, colors, fonts, and sizes) and initial position of the
      interface window - elements which we will discuss later on. Each .if
      file includes a list of widgets, including their types and locations,



                                    - 1 -         Formatted:  March 28, 2024






 XPIP(1)                            V2.2                             XPIP(1)
                                12 APRIL 1999



      other generic parameters shared by all widgets, such as colors, fonts,
      and sizes, and widget-specific parameters, such as whether or not to
      display tick marks on a slider widget. Note that each widget is
      supplied with a complete set of default values (redefinable via
      special xpip.cf and .if commands), so the user need not specify all
      parameters for all widgets. Since XPIP reads in xpip.cf and the .if
      files at run-time, modifying the look and feel of the widgets is a
      quick and simple process. The flexibility of the widgets provides a
      wide range of customization options to the application programmer.


      After loading all the default window and widget specifications, XPIP
      proceeds to call on user-defined routines to perform such functions as
      application initialization, panel initialization, panel execution (in
      response to widget events), and panel shutdown - as indicated by the
      large dotted box in the figure. XPIP must assume a certain set of
      procedure names for these specific functions. The buffer.c (examples
      of which appear in the demo and demo2 directories) file contains these
      default procedures, which the user modifies to call his or her own
      procedures to accomplish the appropriate functions. Although these
      user-defined routines typically follow a general procedural template,
      there are no strict constraints on what actions the application
      performs within these routines. Typically, the application returns
      control to XPIP when it has performed the necessary functions and
      updates. XPIP operates in a control loop, waiting for new widget
      events and/or events indicating that no widget has been selected
      within a timeout interval. Control is passed back to the application
      only when one of these events has occurred. The application handles
      the task of determining what event has occurred, although XPIP
      provides a number of tools for facilitating this process.

      Working with XPIP requires that the programmer understand six basic
      aspects of the system:

            widget definitions in .if files
            XPIP command line options
            default definitions in xpip.cf
            global XPIP widget and window structures
            XPIP/application interface procedures and protocol
            XPIP dialog panels

      The following sections detail each of these areas, with references
      where appropriate to the demonstration applications provided with the
      XPIP distribution. Quick reference summary sheets for some of these
      topics are also provided with this documentation packet. Before
      progressing onto these six topics, however, we discuss the classes of
      widgets available within XPIP and how the user interacts with widgets.

 OVERVIEW
      The SciPlot Widget is a widget capable of plotting cartesian or polar
      graphs, including logarithmic axes in cartesian plots.  The widget is



                                    - 2 -         Formatted:  March 28, 2024






 XPIP(1)                            V2.2                             XPIP(1)
                                12 APRIL 1999



      subclassed directly from the Core widget class, which means that it
      does not depend upon any other widget set.  It may be freely used with
      Athena, Motif, or the Open Look/Xview widget sets.  (There is optional
      Motif support that causes the widget to be subclassed from
      XmPrimitive.


 PROGRAM AUTHOR
      Gregory W. Lesher, lesher@cns.bu.edu


 MORE INFORMATION
      See "http://cns-web.bu.edu/pub/xpip/html/xpip_manual.html"


 MAN PAGE
      Mehdi Lavasani <lavasani@csc.liv.ac.uk>





































                                    - 3 -         Formatted:  March 28, 2024