Alias|Wavefront

OpenAlias Plug-in Documentation


This README file describes each plug-in example supplied with Alias.
These included plug-ins are divided into two sections, plug-ins whose
major purpose is to provide example code for OpenAlias, and plug-ins
that provide useful add-on features to the Alias product. User Notes
and Programmer Notes are provided for each plug-in.


Section 1: Plug-in quick start
==============================

The quickest way to get started with plug-ins is to open the Plug-in Manager
window from the Utilities menu. Then load a few plug-ins by clicking on the
"Load Unload" box of a listed item.

Section 2: Useful plug-ins that are in Alias
============================================
     
bakeAnimation.plugin (formerly bake.plugin)
-------------------------------------------

  Source Files:
        bake.cpp
        bake.i.scm
        bake.o.scm
        WalkTree.cpp

  Includes:
        AlUniverse.h
        AlPickList.h
        AlChannel.h
        AlParamAction.h
        AlLinkItem.h
        AlList.h
        AlIterator.h
        AlAnimatable.h
        AlPlayFrame.h
		AlConstraint.h
		AlIKHandle.h
		AlIKHandleNode.h
        WalkTree.h

  Installs Into:
        Menu -> Animation -> Bake  ("ap_animwinds")

  User Notes:
	This plug-in allows the user to create keyframed animations for objects
	that are animated through expressions or constraints.  The resulting
	keyframe curve is 'baked' into the channel of the object. When an
	expression is baked, a keyframed animation replaces the expression,
	and the old expression is deleted. When a point constraint is baked,
	the translation channels of the constrained DagNode are animated. When
	an orientation or aim constraint is baked, the rotation channels are
	animated.

	The option box allows the user to define which objects should be
	processed ('All' or 'Active'), whether to bake constraints and/or
	expressions, the hierarchy of the sampling and the time range and sampling
	rate. The user can also choose to delete constraints after the bake.
	If "Delete" is off, all baked constraints will be disabled.

	In the option box, if the Constraints item is selected, the user can
	choose to compensate the flipping which could happen during rendering
	with "motion blur" or "in field" set ON in Render Globals. The
	compensation can be applied to motion blur or field, or both. The user
	can also choose "Detect Only", to get the compensation message being
	printed on the prompt line, without executing the bake operation.

	Note: OpenAlias does not currently support prompt line entry from
	plugins, so the 'Prompt' option does nothing.

  Programmer Notes:
    This plug-in illustrates several useful capabilities: how to effectively
	use an AlPlayFrame object; how to use WalkTree to traverse an object
	hierarchicaly; and how to hold onto a list of AlParamActions which
	are latter applied to an object.

	This plug-in should also serve as encouragement for plug-in developers
	to create simple yet useful plug-ins to provide features that are not
	implemented within PowerAnimator.  There are several reasons for the
	'Bake' functionality NOT being provided within PowerAnimator (reasons 
	primarily dealing with user expectations of such functionality), but 
	through a plug-in we can provide a minimal set of capabilities which 
	will meet the majority of requirements for such a function.
        
sunShine.plugin
---------------

  Source Files:
        sunShine.cpp
        sunShine.i.scm
        sunShine.o.scm
        TSun.cpp
        TSun.h

  Includes:
        AlPickList.h
        AlChannel.h
        AlParamAction.h
        AlViewFrame.h
        AlLinkItem.h
        AlList.h
        AlIterator.h
        AlAnimatable.h
        AlDirectionLight.h
        AlLightNode.h
        AlGroupNode.h

  Installs Into:
        Menu -> Animation -> Sun Shine  ("ap_animwinds")

  User Notes:
    This plug-in will use information given to in to determine the location of
    the sun and generate a directional light to simulate it.  By activating the
    option box, the settings can be changed in two ways.  If the Time/Location
    option is chosen, the sun's position will be calculated based on the month,
    day, hour, minute, and the latitude specified.  In the Altitude/Azimuth
    selection, the altitude of the sun (in degrees from the ground), and the
    azimuth (the altitude of the sun at its maximum point during the day).

  Programmer Notes:
    One of the nicer features of this plug-in is the ability two use two
    different methods for specifying the sun's position.  This is accomplished
    in the sunShine.o.scm file.  Note that the widgets are preceded by a
    (list 'enabled ()) line.  This is the method whereby this is accomplished.
    Only those widgets whose 'enabled expressions evaluate to true are actually
    shown.


createSurface.plugin
--------------------

  Source Files:
        createSurface.cpp
        createSurface.scm
        createSurface_init.scm
        AlVector.cpp
        AlVector.h

  Includes:
        AlIterator.h
        AlPolygon.h
        AlPolyset.h
        AlPolysetNode.h
        AlPolysetVertex.h
        AlShader.h
        AlTexture.h
        AlTM.h
        
  Installs Into:
        Palette -> Object Edit -> Fractal Surface  ("mp_objtools")

  User Notes:
    This plug-in generates a fractal-based mountain.  Numerous parameters can
    be set to modify the final result.  In the order presented in the option
    box, they are:
        Subdivisions:    The number of times each edge of the mesh will be cut
                         in half.  Thus, setting subdivisions to 2 will result
                         in a 4x4 grid, while setting it to 6 results in a 32
                         by 32 surface.  In other words, this is the complexity
                         and resolution of the fractal surface.
        Seed:            The pseudo-random number used to generate the surface.
                         A given seed will always result in the same fractal
                         surface, if the other parameters are kept constant.
                         Changing the seed will give varying surfaces.  It is
                         best to experiment with a few values to find the best
                         surface for your application.
        Taper %:         This parameter defines the smoothness of the resulting
                         surface.  Low values yield jagged, erratic surfaces,
                         while high values result in smooth, gently sloping
                         landscapes.
        Size X/Y:        Sets the length of the sides of the surface.  One
                         corner of the generated surface is always at (0,0),
                         while the opposite corner is defined by these two
                         parameters.
        Variance X/Y/Z:    The maximum amount of change that a particular vertex
                         may go through.  It is recommended that the Z variance
                         be significantly larger than the X and Y variances.
        Level 1:         The Z-value below which the surface is shaded a rocky
                         brown colour (sand).
        Level 2:         The Z-value below which the surface is shaded a bright
                         green colour (grass).
        Level 3:         The Z-value below which the surface is shaded grey 
                         (rock).
                         Above this value, the surface is snow-coloured.
        Level Jitter:    Sets how precisely the above colour settings are
                         adhered to.  This gives a more "natural" look to the
                         surface.

  Programmer Notes:
    The surf.plugin makes extensive use of the AlVector class, which is a
    generic vector class useful in many applications.

    The actual creation of the surface mesh is in the generateSurface()
    function.  Here, vectors are converted into vertices for a polyset.  The
    process for doing this is straightforward and readable from the code.

    The interface with the AlTexture class is used in the make*() functions
    (makeSnow(), makeRock(), makeSand(), makeGrass(), makeShader() and
    createShaders()).  See the source code for the specific examples of using
    AlTexture.


createTree.plugin
-----------------

  Source Files:
        createTree.cpp
        createTree.scm
		createTreee_init.scm
        AlVector.h
        AlVector.cpp

  Includes:
        AlIterator.h
        AlPolygon.h
        AlPolyset.h
        AlPolysetNode.h
        AlPolysetVertex.h
        AlTM.h

  Installs Into:
        Palette -> Object Edit -> Fractal Tree  ("mp_objtools")

  User Notes:
    The fractal tree plug-in generates a pseudo-random realistic-looking tree
    using a polygon mesh.  The tree is generated centred at the origin, and
    a variety of parameters affect its final shape.  The option box controls
    are:
        Seed:            The random number seed used in generating pseudo-
                         random numbers.  Different values will result in
                         different trees.
        Max Branch Limit:    The number of times a tree limb can branch.
        Bend:            The maximum amount of curve along a branch.
        Fork Angle:      The angle with which a branch will split.
        Branch Frequency:    The probability that a branch will split at a
                         given point.
        Gravity:         A negative value will tend to make the tree point
                         upwards, while a positive value will "pull" the tree
                         downwards.
        Grow Length:     The final length of branches.
        Trunk Taper:     The percentage of the size of the bottom end of the
                         branch segment that the other end of the segment is
                         (how quickly the branches go from trunk to twig).
        Minimum Branch Size:    If a branch gets smaller than this, it ends.
        Twist Angle:     Maximum twisting that a branch segment will go
                         through.
        Type of Leaves:  Not implemented.

    As always, the best way to determine the effects of these setting is to    
    try them out yourself.

    NOTE: Be careful setting high recursion depths. Too great a depth will
    result in Alias quitting or core dumping from lack of memory.

  Programmer Notes:
    From a plug-in programming perspective, there is nothing complicated about
    this plug-in.  However, it provides a solid example of polygon construction
    through recursion.  The extendtrunk() and branch() functions do the actual
    construction in this case.


createTree2.plugin
------------------

  Source Files:
        createTree2.cpp
        createTree.scm
        createTreee_init.scm
        AlVector.h
        AlVector.cpp

  Includes:
        AlCurve.h
        AlCurveNode.h
        AlIterator.h
        AlPolygon.h
        AlPolyset.h
        AlPolysetNode.h
        AlPolysetVertex.h
        AlSurface.h
        AlSurfaceNode.h
        AlTM.h

  Installs Into:
        Palette -> Object Edit -> Fractal Tree  ("mp_objtools")

  User Notes:
    The fractal tree plug-in generates a pseudo-random realistic-looking tree
    using cylindrical surfaces.  The tree is generated at the origin, and
    a variety of parameters affect its final shape.  The option box controls
    are:
        Seed:           The random number seed used in generating pseudo-
                        random numbers.  Different values will result in
                        different trees.
        Max Branch Limit:    The number of times a tree limb can branch.
        Bend:           The maximum amount of curve along a branch.
        Fork Angle:     The angle with which a branch will split.
        Branch Frequency:    The probability that a branch will split at a
                        given point.
        Gravity:        A negative value will tend to make the tree point
                        upwards, while a positive value will "pull" the tree
                        downwards.
        Grow Length:    The final length of branches.
        Trunk Taper:    The percentage of the size of the bottom end of the
                        branch segment that the other end of the segment is
                        (how quickly the branches go from trunk to twig).
        Minimum Branch Size:    If a branch gets smaller than this, it ends.
        Twist Angle:    Maximum twisting that a branch segment will go
                        through.
        Type of Leaves: Not implemented.

    As always, the best way to determine the effects of these setting is to    
    try them out yourself.  Note also that the parameters have the same effect
    as the do in tree.plugin.

    NOTE: Be careful setting high recursion depths. Too great a depth will
    result in Alias quitting or core dumping from lack of memory.

  Programmer Notes:
    The only difference between this plug-in and tree.plugin is the method for
    the physical construction of the tree.  While tree.plugin uses polygons,
    tree2.plugin uses cylinders.  A look at makeCylinder() shows that the
    cylinders are made by rotating a line.

    Works on either selecting the vertices in a polyset,
    or just select the polyset and all vertices will be
    beveled.

Section 3: Useful plug-ins that are in Alias and Surface Studio
==============================================================


launchPaint.plugin
------------------

  Source Files:
        launchPaint.cpp

  Includes:
    AlUniverse.h
    AlLiveData.h
    AlFunction.h
    AlFunctionHandle.h

  Installs Into:
        Utilities -> Launch Paint

  User Notes:

    The launchXpaint plug-in launches the Xpaint palette based paint package
    from a menu item on Unix. It allows the user to specify an Alias Quantizer
    format palette file and an image, both of which will be loaded into
    Xpaint.

	On Windows NT, this plug-in launches MS Paint.  The format palette file and
	image functionality is not available on this platform.


resetTransforms.plugin
----------------------

  Source Files:
        resetTransforms.cpp
        resetTransforms.i.scm
        resetTransforms.o.scm
        WalkTree.h

  Includes:
        AlChannel.h
        AlDagNode.h
        AlIterator.h
        AlLinkItem.h
        AlList.h
        AlParamAction.h
        AlPickList.h

  Installs Into:
        Palette -> Object Edit -> Reset Transforms  ("mp_objtools")

  User Notes:
    This plug-in provides a quick methodology to reset an object's
    transformations.  Translations and Rotations are set to 0 and Scale
    transforms are set to 1.0.  From the option box, it is possible to turn
    on or off any or all of the three basic transformation types (Translate,
    Rotate, Scale).  Also, resetTransforms can be told to only ascend or
    descend the Dag node hierarchy by way of the option box.

  Programmer Notes:
    Useful coding examples found in this plug-in include the use of the WalkTree
    object, useful for ascending and descending the dagnode hierarchy.  The
    TresetPickIterator::func() shows the implementation of this concept.

    Related to this is the examples of the AlIterator functionality, which
    allows a function to be applied to a list of AlObjects (such as the
    AlPickList).  The TresetHierIterator is a class derived from AlIterator,
    and as such has this functionality.  The AlIterator method is the most
    efficient manner of traversing an object list.




Section 4: Coding Example Plug-ins that are in Alias and Surface Studio
======================================================================



applyFunctionExample.plugin
---------------------------

  Source Files: 
        applyFunctionExample.cpp
        applyFunctionExample.i.scm
        applyFunctionExample.o.scm

  Includes:
        AlAnimatable.h
        AlChannel.h
        AlDagNode.h
        AlIterator.h
        AlLinkItem.h
        AlList.h
        AlParamAction.h
        AlPickList.h
        AlViewFrame.h

  Installs Into:
        Menu -> Animation -> Apply Function  ("ap_animwinds")

  User Notes:
    This plug-in provides a quick way to apply a noise or sine-wave animation
    to one of the nine basic dag-node parameters (X/Y/Z Translation/Rotation/
    Scale).  It is applied over a specified range of frames, and either to
    the active dagnodes or to a newly generated node.

  Programmer Notes:
    The use of channels in this plug-in shows how simple it is for a plug-in
    to generate animation.  Any function can be designed and used in this
    manner.  The method TapplyFunction::createFunction() is the workhorse of
    this plug-in, and is where the animation is developed.


continuousFuncExample.plugin
----------------------------

  Source files:
        continuousFuncExample.cpp

  Includes:
        AlWindow.h

  Installs Into:
        Palette -> Object Edit -> Cont Test  ("mp_objtools")

  User Notes:
    Not applicable (see Programmer Notes).

  Programmer Notes:
    This plug-in is meant as an example as to how to approach developing
    continuous plug-ins (ie: plug-ins with user interaction).  The basic concept
    is to develop a collection of functions that are called on different
    events (mouse up, mouse down, mouse movement, plug-in start-up, etc.).  By
    coordinating tasks between these functions, complex plug-in behaviours
    can be created.

    Note that all message reports are outputted to the stdout.


controlExample.plugin
---------------------

  Source Files:
        controlExample.cpp
        controlExample.scm
        controlExample_init.scm

  Includes:
        AlDagNode.h
        AlPickList.h
        AlMessage.h

  Installs Into:
        Palette -> Object Edit -> Control  ("mp_objtools")

  User Notes:
    This simple plug-in allows you to modify the X,Y,Z translation parameters
    of an object.  When selected, an option box appears with three sliders
    for the three directions.  The object's position in the work windows is
    updated as the sliders are moved.  This allows for a more visually
    intuitive method for placing objects.

	NOTE: Do not 'automatic' load this plug-in. Doing so corrupts memory
    causing Alias to develop a segmentation fault.

  Programmer Notes:
    The major feature of this plug-in is the ability to modify Alias from
    within an option box.  This is accomplished through a function called
    during idle time which reads the values from the option box and redraws
    the Alias Universe with them.  This, in turn, is accomplished through
    message passing.

    The code itself is the best explanation as to how to accomplish this.
    This method is extendible to any aspect of Alias, leading to any number
    of uses.


deleteDagExample.plugin
-----------------------

  Source Files:
        deleteDagExample.cpp

  Includes:
        AlDagNode.h
        AlPickList.h
        AlPickable.h

  Installs Into:
        Palette -> Object Edit -> Delete Dagnode ("mp_objtools")

  User Notes:
    This allows a "point-and-click" method for deleting objects.  After
    selecting this tool, simply click on any object in any window view and
    it will be deleted.     Objects can also be deleted by typing in their
    name.

  Programmer Notes:
    This code demonstrates two important tasks: modifying the DAG (through
    deletion), and picking items during a function.  Sample code is given for
    doing selections both by mouse-click and by name.  Deletion from the DAG
    graph and the use of the picklist from inside a continuous function is
    shown.
    
calcDistanceExample.plugin
--------------------------
  Source Files:
        calcDistanceExample.cpp
 
  Includes:
        AlPickList.h
        AlMeasure.h
        AlCurve.h
        AlSurface.h
        AlSurfaceNode.h

  Installs Into:
        Menu -> Utilities -> Closest Distance  ("al_goto")

  User Notes:
    This plug-in's sole purpose is to determine the minimum distance between
    two objects.  It is limited to points, surfaces, and curves.  To use it,
    first select either one or two surfaces or curves.  If two objects are
    selected, it will determine the minimum distance between them.  If only
    one object is chosen, the minimum distance from that object to the origin
    will be calculated.

    The response from the plug-in is shown on the Prompt line.  It consists
    of all relevant information about the points of minimum distance.  The
    first value is always the calculated distance.  After this is varying
    information depending on the type of objects selected.  For both curves
    and surfaces, the (x,y,z) coordinates of the closest point are given.
    On any curve, the (t) coordinate is also given, and a point on a surface
    is also returned in terms of its (u,v) coordinate space.

    Note that selected objects after the first two are ignored.

  Programmer Notes:
    The main purpose of this plug-in is to demonstrate the AlMinDist()
    function defined in AlMeasure.h.  The first section of code (the five
    boolean functions) determine which of the five following cases exists
    in the picklist: one curve; one surface; two curves; two surfaces; one
    of each.  They return pointers to these objects to the main section of
    the plug-in.

    Knowing the type of objects that have been chosen, the desired MinDist
    function is called.  All of the important information regarding the
    points identified as being the closest are returned by the MinDist
    function, along with the minimum distance.  A simple AlPrintf statement
    is used to output the data.

    Note that the use of the origin as the point to determine closeness to
    is coded in the plug-in and is not a restriction of the AlMinDist function.

    Lastly, it is important to remember that the minimum distance measurement
    is performed in the world-space.  If the object being measured is under-
    going non-affine transformations, the u/v/t parameter values that are
    returned may not be accurate.  In the vast majority of cases, however,
    this minor point may be ignored.  Also, the points returned by the
    function are in the world-space as well.


createMeshExample.plugin
------------------------

  Source Files:
        createMeshExample.cpp
        createMeshExample.scm
        createMeshExample_init.scm

  Includes:
        AlPolyset.h
        AlPolysetNode.h
        AlPolygon.h
        AlPolysetVertex.h
        AlPickList.h
        AlWindow.h

  Installs Into:
        Palette -> Object Edit -> Planar Mesh ("mp_objtools")

  User Notes:
    This plug-in is a quick way to generate flat meshes.  The option box allows
    you to set the mesh density (the number of node points per dimension),
    whether or not to keep the perturbation information (the data on the
    locations of individual vertices), and whether or not to use the mesh
    geometry inline (to draw the full mesh while you are dragging it to its
    final size).  The only one of these three options that would be important
    to the user is the density setting.  Once the mesh has been generated, its
    individual nodes may be transformed individually.

  Programmer Notes:
    One of the key features of this plug-in is the use of "helper" geometry
    during the construction phase.  In order to save processor time, while
    the user is sizing their mesh the program will only draw the outline of
    the mesh.  It is important to remember, as constructions get more and more
    complicated, that unnecessary processor-intensive functions are just that,
    unnecessary.  For instance, if the mesh density is placed at 100 (that's
    10,000 vertices), Alias is unable to update the mesh in real-time.  This
    is the advantage of "helper" geometries; rough approximations are often
    better in complicated cases.

    The plug-in also demonstrates drag-sizing in any of the three standard
    windows, and the generation of polygon geometry.


viewFrameExample.plugin
-----------------------

  Source Files:
        viewFrameExample.cpp
        viewFrameExample.scm
        viewFrameExample_init.scm

  Includes:
        AlPickList.h
        AlObject.h
        AlIterator.h
        AlViewFrame.h

  Installs Into:
        Palette -> Object Edit -> View Frame  ("mp_objtools")

  User Notes:
    This plug-in will set each selected object to a certain frame number.  The
    frame number is set inside the option box.  Using frame.plugin does not
    change any keyframes or any other object in the Universe.

  Programmer Notes:
    The purpose of this plug-in is to demonstrate the AlViewFrame library.  The
    plug-in defines an AlIterator which runs through the currently selected
    objects and, if the are Animatable, applies AlViewFrame::viewFrame() to
    them.


createHelix.plugin
------------------

  Source Files:
         createHelix.cpp

  Includes:
        AlPolygon.h
        AlPolyset.h
        AlPolysetVertex.h
        AlTM.h

  Installs Into:
        Palette -> Object Edit -> Helix  ("mp_objtools")

  User Notes:
    This plug-in does not have any useful options at all. It simply creates a
    double helix from polygons of radius two and height eight, centred at the
    origin.

  Programmer Notes:
    Other than the fairly simple math to create the helix, the most interesting
    portion of the code is the AlPromptBox calls found in do_double_helix().
    This shows how simple it is to have user interaction with even just a 
    momentary plug-in.

    Note that kOK_Cancel and kYes_No_Cancel are the only types of prompt boxes
    that are available.


intersectionExample.plugin
--------------------------

  Source Files:
        intersectionExample.cpp

  Includes:
        AlCurveNode.h
        AlIntersect.h
        AlLinkItem.h
        AlList.h
        AlObject.h
        AlPickList.h
        AlSurface.h
        AlSurfaceNode.h

  Installs Into:
        Palette -> Surface Edit -> Intersect Objects  ("mp_srftools")

  User Notes:
    The intersection.plugin will determine common points between two curves,
    two surfaces, and a curve and a surface.  First, select two objects (curves
    and/or surfaces).  Then, activate the intersection plug-in.  If one of the
    objects is a curve, the prompt line will respond with how many
    intersections there are, where in world space they are, and any relevant
    (t) or (u,v) data.  If both objects are surfaces, it will respond with
    the number of points and curves of intersection, and will also create any
    intersection curves that it finds.

  Programmer Notes:
    Once the plug-in determines what type of objects have been chosen (in
    do_intersect()), it calls the specific code for that type of intersection.
    This code shows the usage of AlIntersect.  The do_intersect_crv_crv() and
    do_intersect_crv_srf() simply report data back out from their respective
    AlLists.  do_intersect_srf_srf() goes a step farther and actually creates
    objects for the intersection curves.


simpleEditorExample.plugin
--------------------------

  Source Files:
        simpleEditorExample.cpp
        simpleEditorExample.scm
        simpleEditorExample_init.scm

  Includes:
        <none>

  Installs Into:
        Palette -> Object Edit -> SimpleEditor  ("mp_objtools")

  User Notes:
    Not Applicable (see Programmer Notes)

  Programmer Notes:
    This plug-in does not actually do anything.  It exists solely as a template
    for developing momentary functions.  It implements a simple option box and
    contains an empty 'action' function (do_stuff_here()).  Use this to
    familiarize yourself with techniques for implementing new plug-ins.


printPickCountExample.plugin
----------------------------

  Source Files:
        printPickCountExample.cpp
 
  Includes:
        AlPickList.h
        AlObject.h

  Installs Into:
        Palette -> Object Edit -> Count Picked Items  ("mp_objtools")

  User Notes:
    One of the simplest plug-ins possible, pickcount.plugin will tell you how
    many objects are currently active (on the pick list).  It does not count
    shaders, textures, or environments.

  Programmer Notes:
    pickcount.plugin uses an AlIterator to count through the items on the pick
    list, ignoring shaders, textures, and environments.  The simple function
    countPick::func() accomplishes this.


createSphereExample.plugin
--------------------------

  Source Files:
        createSphereExample.cpp
        AlVector.h
        AlVector.cpp

  Includes:
        AlCurve.h
        AlCurveNode.h
        AlDagNode.h
        AlSurface,h
        AlSurfaceNode.h
        AlTM.h
        AlWindow.h

  Installs Into:
        Palette -> Object Edit -> Contin Sphere  ("mp_objtools")

  User Notes:
    This plug-in is simply a quick way to draw solid spheres.  Once the plug-in
    is selected, click and drag in the Front, Right, or Top window to create
    spheres of varying radius.

  Programmer Notes:
    The main use of this plug-in is as an example of interactive editing in a
    continuous function.  Code in the down_func() and move_func() shows how to
    read points from mouse-clicks and use these values to change the object's
    parameters (eg: scale).

    sphere.plugin is also important in its example of rotating a half-circle
    to create a sphere (in makeHalfCircle() and makeSphere()).

motifExample.plugin -- UNIX only
--------------------------------

  Source Files:
        motifExample.cpp

  Includes:
		AlUniverse.h
		AlLiveData.h
		AlXevents.h
		AlObserver.h
		AlXevents.h

  Installs Into:
        Palette -> Object Edit -> Motif Plug-in  ("mp_objtools")

  User Notes:
	This plug-in creates a X window instead of a scheme editor
	when invoked.  It serves as an example on how to mix 
	X windows with OpenAlias plug-ins.

  Programmer Notes:
    The main use of this plug-in is to demonstrate
	how to use the AlObserver class and AlXevents class to
	catch and respond to the minimizing, maximizing, lowering
	and raising of the Alias window.

winMsgBoxExample.plugin -- Windows NT(TM) only
----------------------------------------------

  Source Files:
        winMsgBoxExample.cpp

  Includes:
		AlUniverse.h
		AlLiveData.h
		AlFunctionhandle.h
		AlFunction.h
		windows.h

  Installs Into:
        Palette -> Object Edit -> WinMsg Plug-in  ("mp_objtools")

  User Notes:
	This plug-in is a simple example that creates a message box when invoked. 
	It illustrates how to combine an OpenAlias plug-in and Windows(TM)
	message boxes.

winDialogBoxExample.plugin -- Windows NT(TM) only
-------------------------------------------------

  Source Files:
        winDialogBoxExample.cpp
        winDialogBoxExampleRC.rc
        winDialogBoxExample.h

  Includes:
		AlUniverse.h
		AlLiveData.h
		AlFunctionhandle.h
		AlFunction.h
		windows.h

  Installs Into:
        Palette -> Object Edit -> WinDialog Plug-in  ("mp_objtools")

  User Notes:
	This plug-in creates a window and a menu when invoked.  The menu
	item can be selected to create a dialog box.

  Programmer Notes:
    The main use of this plug-in is to demonstrate
	how to mix OpenAlias and Windows(TM) UI code. In addition,
	a resource file is used to define a dialog box for the plug-in.
	The example Makefile contains instructions for building the 
	resource file and linking it to the plug-in.

dynamicEditorExample.plugin
---------------------------

	Source Files:
		dynamicEditorExample.cpp

	Includes:
		#include <AlUniverse.h>
		#include <AlLiveData.h>
		#include <AlFunction.h>
		#include <AlFunctionHandle.h>
		#include <AlEditor.h>

	Installs Into:
		Utilities -> DynamicEditor

	User Notes:
		This plug-in creates an example option editor.  Clicking
		on buttons or selecting menus will invoke handler functions.
		On Unix, printf() is used to display state information.
		As noted in the AlEditor class, a plug-in can either have
		pulldown menus or buttons.  Closing the option box and 
		re-opening it will toggle if pulldown menus or buttons
		are displayed.

	Programmer Notes:
		The main use of this plug-in is to illustrate how to use
		the AlEditor class to create dynamic option editors.  
		To create an Editor component, the ComponentDescriptor
		class must be used.  When a component is built, a
		dynamic id is returned in the descriptor. This plug-in
		already contains code for managing and searching a dynamic
		list of descriptors.
		
