home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / gfx / misc / imagefx_sdk / doc / ged.autodoc < prev    next >
Encoding:
Text File  |  1995-02-14  |  26.2 KB  |  826 lines
  1. TABLE OF CONTENTS
  2.  
  3. ged/--background--
  4. ged/--styles--
  5. ged/GedWin
  6. ged/GedWindow
  7. ged/Ged_Activate
  8. ged/Ged_Add
  9. ged/Ged_Create
  10. ged/Ged_Delete
  11. ged/Ged_Enable
  12. ged/Ged_Get
  13. ged/Ged_GetIMsg
  14. ged/Ged_Remove
  15. ged/Ged_Set
  16. ged/PrepareNW
  17. ged/zzz
  18.  
  19.  
  20.  
  21.  
  22. ged/--background--                                    ged/--background--
  23.  
  24.     What the heck *is* Ged, anyway?  Well, I'll tell you...
  25.  
  26.     At the conception of Scan, I realized very quickly that I was going
  27.     to need a way to shorten the time it took to create the gadgets and
  28.     windows and stuff needed for the program.  The idea was to come up
  29.     with a 2.0 look and feel, without actually requiring 2.0 to run
  30.     (grumble, grumble).  So I quickly hacked together a little gadget
  31.     editor program to make life a little easier.
  32.  
  33.     Well, originally this little gadget editor was just going to spit out
  34.     Gadget structures, but after playing around with it a while I thought
  35.     it would be better to come up with my own GadTools-like system.  Hence
  36.     the NewGad structure was born.  The idea was to pass an array of
  37.     NewGad structures to a single gadget creating function that would
  38.     return a pointer to a list of Gadget's, suitable for adding to a
  39.     window (sound familiar?).
  40.  
  41.     As these things often do, Ged kinda grew completely out of control.
  42.     In addition to gadgets, I added the ability to specify text, border,
  43.     and even imagery in the list of NewGad's.  It also became somewhat
  44.     object-oriented in that each NewGad can specify a function to call
  45.     when that gadget is "fiddled" with (one of the things I find sorely
  46.     lacking in GadTools).
  47.  
  48.     Anyway, the following is an attempt at documenting how the Ged system
  49.     works so that you can use it in creating your own modules for
  50.     Scan (it is required for Scanner, Render, Printer, and some aspects
  51.     of Preview modules).  These functions are contained in the scan.library
  52.     function library.
  53.  
  54.     BTW, if you're wondering about the Ged creator program, it's way
  55.     too hacked up and obsolete to be useful anymore.
  56.  
  57.     All of the functions described below are contained in the ImageFX function
  58.     library (scan*.library).
  59.  
  60.  
  61. ged/--styles--                                                 ged/--styles--
  62.  
  63.     A complete catalog of the types of GUI elements that can be created with
  64.     the Ged system:
  65.  
  66.         Button_ID:
  67.             A standard BOOLGADGET button, with a bevel box border.  The label
  68.             always appears inside the gadget.
  69.  
  70.         Toggle_ID:
  71.             Looks like a button, but really toggles between two states.  The
  72.             label always appears inside the gadget.  I wouldn't use this too
  73.             often, as it isn't really very AUISG compliant.
  74.  
  75.         String_ID:
  76.             A standard string gadget, with the 2.0 look border around it.  The
  77.             label always appears to the left of the gadget.
  78.  
  79.         Integer_ID:
  80.             A standard LONGINT string gadget, with the 2.0 look border
  81.             around it.  The label always appears to the left of the gadget.
  82.  
  83.         HSlider_ID:
  84.             Horizontal slider (PROPGADGET), with a bevel border.  The label
  85.             always appears to the left of the gadget.
  86.  
  87.         VSlider_ID:
  88.             Vertical slider (PROPGADGET), with a bevel border.  The label
  89.             always appears above the gadget.
  90.  
  91.         Cycle_ID:
  92.             2.0-style cycle gadget, for cycling through a list of choices.
  93.             Ged breaks away a little from the style guide here in the way it
  94.             handles these kinds of gadgets.  Clicking the right side of the
  95.             gadget cycles upwards, clicking the left side of the gadget cycles
  96.             downwards, and double-clicking in the middle of the gadget brings
  97.             up a list of all the choices in the gadget.  A tool type
  98.             (GTCOMPLIANT) in ImageFX will disable all this fancy stuff if
  99.             you're used to standard GadTools-type cycler gadgets.
  100.  
  101.             There is also no way to attach a label to a Ged cycle gadget; you
  102.             have to use a Text_ID item and place a text near it.
  103.  
  104.         Check_ID:
  105.             2.0-style checkbox gadget.  Gadget labels always appears on the
  106.             right side of the checkbox.
  107.  
  108.         MX_ID:
  109.             2.0-style mutual exclusion (radio) gadget.  Note that Ged does
  110.             *NOT* do any mutual exclusion - this gadget behaves just like a
  111.             checkbox gadget.  The only difference is the imagery.  You must
  112.             still do the mutual exclusion yourself.  The label always appears
  113.             on the right side of the gadget.
  114.  
  115.         Border_ID:
  116.             Draw a bevel-box border, raised or recessed.
  117.  
  118.         Text_ID:
  119.             Draw a string of text.
  120.  
  121.         Image_ID:
  122.             Display an Image structure.
  123.  
  124.         End_ID:
  125.             Used to end an array of NewGad structure.
  126.  
  127.         Up_ID:  (1.5)
  128.             An up arrow gadget, similar in all respects to a Button_ID.
  129.  
  130.         Down_ID:  (1.5)
  131.             A down arrow gadget, similar in all respects to a Button_ID.
  132.  
  133.         List_ID:  (2.0)
  134.             A gadtools-style listview gadget.  You must initialize an
  135.             EListView structure and place a pointer to it in NewGad->Data1.
  136.             See <scan/ged.h> for details about the EListView structure.
  137.  
  138.  
  139.     The following styles will not be used often, if ever:
  140.  
  141.         QButton_ID:
  142.             Same as Button_ID with no imagery.
  143.  
  144.         QToggle_ID:
  145.             Same as Toggle_ID with no imagery.
  146.  
  147.         QString_ID:
  148.             Same as String_ID with no imagery.
  149.  
  150.         QInteger_ID:
  151.             Same as Integer_ID with no imagery.
  152.  
  153.         QHSlider_ID:
  154.             Same as HSlider_ID with no imagery.
  155.  
  156.         QVSlider_ID:
  157.             Same as VSlider_ID with no imagery.
  158.  
  159.         QCycle_ID:
  160.             Same as Cycle_ID with no imagery.
  161.  
  162.         QCheck_ID:
  163.             Same as Check_ID with no imagery.
  164.  
  165.         QMX_ID:
  166.             Same as MX_ID with no imagery.
  167.  
  168.  
  169.     Special non-GUI styles:
  170.  
  171.         Ignore_ID:
  172.             Not implemented.
  173.  
  174.         Font_ID:
  175.             Not implemented.
  176.  
  177.         Offset_ID:
  178.             Internal use only.
  179.  
  180.         Scale_ID:
  181.             Specify this style as the first in your NewGad array, and layout
  182.             your gadgets based on an 8-point font.  The Ged system will
  183.             automatically scale the sizes and positions of your GUI elements
  184.             to fit the font that the user specified for ImageFX.  You should
  185.             use this only for opening windows on the ImageFX screen.  ImageFX
  186.             itself uses this for most of its displays.
  187.  
  188.  
  189. ged/GedWin                                                         ged/GedWin
  190.  
  191.     NAME
  192.         GedWin -- Somewhat higher-level version of GedWindow().
  193.  
  194.     SYNOPSIS
  195.         returnCode = GedWin ( newWindow, newGadArray, activateID,
  196.         D0.L                  A0         A1           D0.L
  197.                               initCode, cleanupCode, textArray )
  198.                               A2        A3           A4
  199.  
  200.         int GedWin ( struct NewWindow *newWindow,
  201.                      struct NewGad *newGadArray,
  202.                      int activateID,
  203.                      int (*initCode)(struct Window *, struct NewGad *),
  204.                      int (*cleanupCode)(struct Window *, struct Gadget *),
  205.                      char **textArray );
  206.  
  207.     FUNCTION
  208.         Open a new window, add gadgets to it, process the events of the
  209.         window, and return only when the window is closed.  This is a
  210.         convenient do-it-all function for opening requesters and such
  211.         containing Ged gadgets.
  212.  
  213.         This function is meant specifically for opening windows on the ImageFX
  214.         screen.  It will make sure the ImageFX screen is in front, roll the
  215.         screen up far enough to hold the window, and block all input to other
  216.         ImageFX windows before opening this new window.
  217.  
  218.         In all other respects, this function is identical to GedWindow().
  219.  
  220.     INPUTS
  221.         See GedWindow().
  222.  
  223.     RESULTS
  224.         See GedWindow().
  225.  
  226.     EXAMPLE
  227.         See GedWindow().
  228.  
  229.     NOTES
  230.  
  231.     BUGS
  232.  
  233.     SEE ALSO
  234.         ged/GedWindow,ged/PrepareNW
  235.  
  236.  
  237. ged/GedWindow                                                   ged/GedWindow
  238.  
  239.     NAME
  240.         GedWindow -- Open and handle a window with Ged gadgets.
  241.  
  242.     SYNOPSIS
  243.         returnCode = GedWindow ( newWindow, newGadArray, activateID,
  244.         D0.L                     A0         A1           D0.L
  245.                                  initCode, cleanupCode, textArray )
  246.                                  A2        A3           A4
  247.  
  248.         int GedWindow ( struct NewWindow *newWindow,
  249.                         struct NewGad *newGadArray,
  250.                         int activateID,
  251.                         int (*initCode)(struct Window *, struct NewGad *),
  252.                         int (*cleanupCode)(struct Window *, struct Gadget *),
  253.                         char **textArray );
  254.  
  255.     FUNCTION
  256.         Open a new window, add gadgets to it, process the events of the
  257.         window, and return only when the window is closed.  This is a
  258.         convenient do-it-all function for opening requesters and such
  259.         containing Ged gadgets.
  260.  
  261.         There are two ways to have the window closed.  One is to specify a
  262.         close gadget in the NewWindow structure, in which case this function
  263.         will return -1 when the close gadget is pressed.  The other way is to
  264.         make sure that one or more of your Ged gadgets have a code pointer
  265.         that returns a non-zero value.  You may also specify in the NewGad
  266.         structure of Button_ID gadgets that a non-zero value be returned
  267.         without the need for a user-supplied function.
  268.  
  269.         An alert will be presented if the window open fails, and a -2 will be
  270.         returned.
  271.  
  272.         If this window is opened on the ImageFX screen, pressing the right
  273.         mouse button any time while this window is open will toggle the
  274.         menu panel on or off.
  275.  
  276.         If you are opening this window on the ImageFX screen, you may want to
  277.         consider using the GedWin() function instead.
  278.  
  279.         If you need to do anything fancy (like menus, for example) you will
  280.         not be able to use this function.
  281.  
  282.     INPUTS
  283.         newWindow -- a pointer to a NewWindow structure used to open the
  284.                     window.  Note that you must make sure that you select the
  285.                     proper IDCMP flags for the gadget styles you have chosen
  286.                     for this window.  You should call PrepareNW() on this
  287.                     structure.
  288.  
  289.         newGadArray -- pointer to an array of NewGad structures, each
  290.                     element of which describes a UI feature (gadget,
  291.                     text, image, or bevel box).  The contents of each
  292.                     NewGad structure depends on the Style chosen
  293.                     (see scan/ged.h for details of the NewGad struct).
  294.  
  295.         activateID -- if non-zero, this should be a string or integer
  296.                     gadget ID number to automatically activate when the
  297.                     window opens.
  298.  
  299.         initCode -- User-supplied code to call to initialize certain things
  300.                     during the process of opening the window.  This function
  301.                     will actually be called twice during the initialization
  302.                     process.  The first time, the NewGad * argument will be
  303.                     valid.  The second time, the Window * argument will be
  304.                     valid.  The invalid argument will be NULL.  Most times you
  305.                     will not need to use these functions.
  306.  
  307.         cleanupCode -- User-supplied code to call during the cleanup process.
  308.  
  309.         textArray -- Array of text pointers to be supplied to Ged_Create().
  310.  
  311.  
  312.     RESULTS
  313.         Returns the result code of the gadget that terminated the window,
  314.         or -1 if the close gadget was pressed.  This function will not return
  315.         until the window is closed one way or another.
  316.  
  317.     EXAMPLE
  318.  
  319.         /*
  320.          * Simple window with nothing but an Okay and Cancel gadget.
  321.          *
  322.          */
  323.  
  324.         extern struct ScanBase *ScanBase;
  325.  
  326.         /* Text indexes */
  327.         enum {
  328.             G_Okay = 1,
  329.             G_Cancel
  330.         };
  331.  
  332.         /* Text string array */
  333.         char *textArray[] = {
  334.             NULL,
  335.             "_Okay",        /* note underscore to make keyboard shortcut */
  336.             "_Cancel"
  337.         };
  338.  
  339.         /* Gadget ID's */
  340.         enum {
  341.             ID_Okay = 100,
  342.             ID_Cancel
  343.         };
  344.  
  345.         /* GUI definition */
  346.         struct NewGad newGads[] = {
  347.             { Button_ID, ID_Okay, 8,18,90,12, G_Okay, NULL,0, NULL, ID_Okay,0,NULL,0 },
  348.             { Button_ID, ID_Cancel, 294,18,90,12, G_Cancel, NULL,0, NULL, ID_Cancel,0,NULL,0 },
  349.             { Border_ID, 0, 0,0,421,34, NULL,NULL,0,NULL, FALSE,TRUE,0,0 },
  350.             { End_ID }
  351.         };
  352.  
  353.         /* Window definition */
  354.         struct NewWindow newWindow = {
  355.             9,13,421,64,
  356.             0,1,
  357.             GADGETUP,
  358.             BORDERLESS|ACTIVATE|NOCAREREFRESH|SMART_REFRESH|RMBTRAP,
  359.             NULL,
  360.             NULL,
  361.             NULL,
  362.             NULL,
  363.             NULL,
  364.             40,20,-1,-1,
  365.             CUSTOMSCREEN
  366.         };
  367.  
  368.         void TestGedWindow (void)
  369.         {
  370.             int rc;
  371.  
  372.             rc = GedWindow(&newWindow, boolNewGads, 0, NULL, NULL, textArray);
  373.  
  374.             switch(rc) {
  375.                 case ID_Okay :
  376.                     printf("ok!\n");
  377.                     break;
  378.                 case ID_Cancel :
  379.                     printf("cancel!\n");
  380.                     break;
  381.                 default :
  382.                     printf("oops.\n");
  383.                     break;
  384.             }
  385.         }
  386.  
  387.     NOTES
  388.  
  389.     BUGS
  390.  
  391.     SEE ALSO
  392.         ged/GedWin
  393.  
  394.  
  395. ged/Ged_Activate                                         ged/Ged_Activate
  396.  
  397.     NAME
  398.         Ged_Activate -- Activate a string or integer gadget.
  399.  
  400.     SYNOPSIS
  401.         Ged_Activate ( window, gadgetid )
  402.                        A0      D0.L
  403.  
  404.         void Ged_Activate ( struct Window *window, int gadgetid );
  405.  
  406.     FUNCTION
  407.         Attempts to activate the gadget identified by the ID value
  408.         given in the supplied window.  Of course, this only works
  409.         for String_ID and Integer_ID style gadgets.
  410.  
  411.     INPUTS
  412.         window -- pointer to the window where the gadget resides.
  413.         id -- ID value of the gadget to activate.
  414.  
  415.     RESULT
  416.         None.
  417.  
  418.     EXAMPLE
  419.  
  420.     NOTES
  421.  
  422.     SEE ALSO
  423.  
  424.  
  425.  
  426. ged/Ged_Add                                                   ged/Ged_Add
  427.  
  428.     NAME
  429.         Ged_Add -- Add a Ged context to a window.
  430.  
  431.     SYNOPSIS
  432.         Ged_Add ( context, window )
  433.                   A0       A1
  434.  
  435.         void Ged_Add ( struct GedContext *context, struct Window *window );
  436.  
  437.     FUNCTION
  438.         Adds (ie. draws) the imagery specified by the supplied GedContext
  439.         to the given window.  This includes gadgets, text, bevel borders,
  440.         and images.
  441.  
  442.     INPUTS
  443.         context -- pointer to a GedContext structure, which has been filled
  444.                     in by a call to Ged_Create().
  445.         window -- pointer to the Window in which to add the context.
  446.  
  447.     RESULT
  448.         None.
  449.  
  450.     EXAMPLE
  451.  
  452.     NOTES
  453.         The normal procedure to follow is something like this:
  454.  
  455.             if (Ged_Create(&context, newGadArray)) {
  456.                 Ged_Add(&context, window);
  457.                 /* do window stuff */
  458.                 Ged_Remove(&context, window);
  459.                 Ged_Delete(&context);
  460.             }
  461.  
  462.     SEE ALSO
  463.         ged/Ged_Create,ged/Ged_Remove
  464.  
  465.  
  466.  
  467. ged/Ged_Create                                               ged/Ged_Create
  468.  
  469.     NAME
  470.         Ged_Create -- Allocate a complete Ged context based on an input
  471.                         array of gadget, text, border, and image
  472.                         specifications.
  473.  
  474.     SYNOPSIS
  475.         success = Ged_Create ( context, newGadArray, textArray )
  476.                                A0       A1           A2
  477.  
  478.         int Ged_Create ( struct GedContext *context,
  479.                          struct NewGad *newGadArray,
  480.                          char **textArray );
  481.  
  482.     FUNCTION
  483.         Fills in the supplied GedContext structure with pointers to
  484.         lists of Gadget, IntuiText, Border, and Images suitable for
  485.         adding to a window with Ged_Add().  Dynamically allocates Gadget
  486.         structures based on the information contained in the input array
  487.         of NewGad specifiers; this list also contains information on where
  488.         and how to place text, borders, and images.
  489.  
  490.     INPUTS
  491.         context -- pointer to GedContext structure which is filled
  492.                     with a bunch of (read only) information.
  493.  
  494.         newGadArray -- pointer to an array of NewGad structures, each
  495.                     element of which describes a UI feature (gadget,
  496.                     text, image, or bevel box).  The contents of each
  497.                     NewGad structure depends on the Style chosen
  498.                     (see scan/ged.h for details of the NewGad struct).
  499.  
  500.         textArray -- pointer to an array of text strings.  Each NewGad
  501.                     should specify it's label as an index into this
  502.                     text array, so that they may be internationalized
  503.                     fairly easily.  If this pointer is NULL, ImageFX
  504.                     will assume that each NewGad.Label is really a
  505.                     pointer to a (char *) string.
  506.  
  507.     RESULT
  508.         success -- 0 if the function failed, non-zero if successful.
  509.  
  510.     EXAMPLE
  511.  
  512.     NOTES
  513.         The newGadArray must remain valid throughout the entire lifetime of
  514.         the gadgets, as the NewGad structure that created a gadget is
  515.         referenced whenever a gadget is fiddled with.  For example, when a
  516.         slider gadget is adjusted, the new value of the slider is stored in
  517.         the NewGad that created the slider.
  518.  
  519.         Also note that each gadget's Pointer argument (as specified in the
  520.         NewGad structure) must remain valid throughout the lifetime of the
  521.         gadgets, as they are updated whenever a gadget is modified.  They are
  522.         also initialized immediately.
  523.  
  524.     SEE ALSO
  525.         ged/Ged_Delete,scan/ged.h
  526.  
  527.  
  528. ged/Ged_Delete                                                 ged/Ged_Delete
  529.  
  530.     NAME
  531.         Ged_Delete -- Free all memory associated with a Ged context.
  532.  
  533.     SYNOPSIS
  534.         Ged_Delete ( context )
  535.                      A0
  536.  
  537.         void Ged_Delete ( struct GedContext *context );
  538.  
  539.     FUNCTION
  540.         Frees all memory associated with the given GedContext structure.
  541.         When this function returns, all pointers within the GedContext
  542.         structure are invalid.
  543.  
  544.     INPUTS
  545.         context -- pointer to GedContext structure as filled in by
  546.                     the Ged_Create() function.
  547.  
  548.     RESULTS
  549.         None.
  550.  
  551.     EXAMPLE
  552.  
  553.     NOTES
  554.  
  555.     BUGS
  556.  
  557.     SEE ALSO
  558.         ged/Ged_Create
  559.  
  560.  
  561. ged/Ged_Enable                                                 ged/Ged_Enable
  562.  
  563.     NAME
  564.         Ged_Enable -- Enable or disable (ghost) a Ged gadget.
  565.  
  566.     SYNOPSIS
  567.         Ged_Enable ( window, gadgetID, enable )
  568.                      A0      D0.W      D1.W
  569.  
  570.         void Ged_Enable ( struct Window *window,
  571.                           short gadgetID,
  572.                           short enable );
  573.  
  574.     FUNCTION
  575.         Use this function to enable or disable a Ged gadget.  Disabling a
  576.         gadget prevents the user from accessing it.  The gadget imagery will
  577.         be refreshed immediately.
  578.  
  579.     INPUTS
  580.         window -- pointer to the Window containing the gadgets.
  581.  
  582.         gadgetID -- the ID number of the gadget you wish to examine.
  583.  
  584.         enable -- flag indication whether you want to enable or disable the
  585.                     gadget.  Use a non-zero value to enable the gadget, or
  586.                     zero to disable (ghost) the gadget.
  587.  
  588.     RESULTS
  589.         None.
  590.  
  591.     EXAMPLE
  592.  
  593.     NOTES
  594.  
  595.     BUGS
  596.  
  597.     SEE ALSO
  598.  
  599.  
  600. ged/Ged_Get                                                       ged/Ged_Get
  601.  
  602.     NAME
  603.         Ged_Get -- return the state of a given Ged gadget.
  604.  
  605.     SYNOPSIS
  606.         value = Ged_Get ( window, gadgetID )
  607.         D0.L              A0      D0.W
  608.  
  609.         long Ged_Get ( struct Window *window, short gadgetID );
  610.  
  611.     FUNCTION
  612.         Returns the current state (value) of any Ged gadget in a window.
  613.         The return value will differ depending on the style of gadget you are
  614.         examining (see below).
  615.  
  616.     INPUTS
  617.         window -- pointer to the Window containing the gadgets.
  618.  
  619.         gadgetID -- the ID number of the gadget you wish to examine.
  620.  
  621.     RESULTS
  622.         value -- the current value of the gadget.  The returned value and type
  623.                     depends on the style of gadget you are examining:
  624.  
  625.                     Button_ID   (long) Always 0.
  626.                     Toggle_ID   (long) Selection state (1=on, 0=off).
  627.                     MX_ID       (long) Selection state (1=on, 0=off).
  628.                     Check_ID    (long) Selection state (1=on, 0=off).
  629.                     String_ID   (char *) String contents.
  630.                     Integer_ID  (long) Integer value.
  631.                     HSlider_ID  (long) Slider value.
  632.                     VSlider_ID  (long) Slider value.
  633.                     Cycle_ID    (long) Cycle index.
  634.  
  635.     EXAMPLE
  636.  
  637.     NOTES
  638.         Examining a gadget's Pointer variable will accomplish the same thing.
  639.  
  640.     BUGS
  641.  
  642.     SEE ALSO
  643.         ged/Ged_Set
  644.  
  645.  
  646. ged/Ged_GetIMsg                                               ged/Ged_GetIMsg
  647.  
  648.     NAME
  649.         Ged_GetIMsg -- Handle Ged gadget events.
  650.  
  651.     SYNOPSIS
  652.         intuiMsg = Ged_GetIMsg ( window, &returnCode )
  653.         D0.L                     A0.L    A1.L
  654.  
  655.         struct IntuiMessage *Ged_GetIMsg ( struct Window *window,
  656.                                            short *returnCode );
  657.  
  658.     FUNCTION
  659.         Process events from the given window, filtering out those events which
  660.         pertain only to Ged gadgets.  If an event is found to be a Ged event,
  661.         then the event is processed and the results of the processing are
  662.         stored in the variable that returnCode points to.
  663.  
  664.         When Ged gadget activity is detected, the Ged system will update the
  665.         gadget imagery as necessary, then call the optional user-supplied code
  666.         (set with NewGad.Code) for the gadget.  The return value from this user-
  667.         supplied code is placed in the variable that returnCode points to.  A
  668.         zero result generally means everything went alright.
  669.  
  670.     INPUTS
  671.         window -- pointer to the Window to process.
  672.  
  673.         returnCode -- where to store the return codes from any user-supplied
  674.                     code processed by the Ged system.
  675.  
  676.     RESULTS
  677.         intuiMsg -- If this event is not of a type that Ged cares about, then
  678.                     the IntuiMessage is returned for you to process normally.
  679.                     If Ged did in fact process the event, NULL is returned.
  680.  
  681.     EXAMPLE
  682.  
  683.     NOTES
  684.  
  685.     BUGS
  686.  
  687.     SEE ALSO
  688.  
  689.  
  690. ged/Ged_Remove                                                 ged/Ged_Remove
  691.  
  692.     NAME
  693.         Ged_Remove -- Remove a Ged context from a window.
  694.  
  695.     SYNOPSIS
  696.         Ged_Remove ( context )
  697.                      A0
  698.  
  699.         void Ged_Remove ( struct GedContext *context );
  700.  
  701.     FUNCTION
  702.         Remove all the gadgets in the Ged context from the window that
  703.         this context was added to (with Ged_Add()).
  704.  
  705.     INPUTS
  706.         context -- pointer to GedContext as filled in by the Ged_Create()
  707.                     function.
  708.  
  709.     RESULTS
  710.         None.
  711.  
  712.     EXAMPLE
  713.  
  714.     NOTES
  715.  
  716.     BUGS
  717.  
  718.     SEE ALSO
  719.         ged/Ged_Add
  720.  
  721.  
  722. ged/Ged_Set                                                       ged/Ged_Set
  723.  
  724.     NAME
  725.         Ged_Set -- Set the state of a Ged gadget.
  726.  
  727.     SYNOPSIS
  728.         Ged_Set ( window, gadgetID, newValue )
  729.                   A0      D0.W      D1.L
  730.  
  731.         void Ged_Set ( struct Window *window,
  732.                        short gadgetID,
  733.                        long newValue );
  734.  
  735.     FUNCTION
  736.         Set the state of a gadget, that is, the contents of a string
  737.         or integer gadget, the value of a slider gadget, or the selection state
  738.         of checkbox or toggle gadgets.
  739.  
  740.     INPUTS
  741.         window -- window containing the gadgets.
  742.  
  743.         gadgetID -- the ID number of the gadget you wish to modify.
  744.  
  745.         newValue -- new value to store in the given gadget.  The value depends
  746.                     on the type of gadget you are modifying:
  747.  
  748.                     Button_ID   Ignored.
  749.                     Toggle_ID   (long) Selection state (1=on, 0=off).
  750.                     MX_ID       (long) Selection state (1=on, 0=off).
  751.                     Check_ID    (long) Selection state (1=on, 0=off).
  752.                     String_ID   (char *) New string contents.
  753.                     Integer_ID  (long) New integer value.
  754.                     HSlider_ID  (long) New slider value.
  755.                     VSlider_ID  (long) New slider value.
  756.                     Cycle_ID    (long) New cycle index.
  757.  
  758.                     Note that there is no range checking on the value you
  759.                     supply.
  760.  
  761.                     The gadget imagery will be refreshed.
  762.  
  763.                     The gadget's Pointer variable (if present) will be updated.
  764.  
  765.     RESULTS
  766.         None.
  767.  
  768.     EXAMPLE
  769.  
  770.     NOTES
  771.         For slider gadgets (styles HSlider_ID and VSlider_ID), the gadgets
  772.         Code function will be called when the imagery is refreshed.  The is
  773.         because in most cases, the code for a slider gadget is used to update
  774.         a numerical value somewhere near the slider.
  775.  
  776.     BUGS
  777.  
  778.     SEE ALSO
  779.         ged/Ged_Get
  780.  
  781.  
  782. ged/PrepareNW                                                   ged/PrepareNW
  783.  
  784.     NAME
  785.         PrepareNW -- Prepare a NewWindow structre for GedWin().
  786.  
  787.     SYNOPSIS
  788.         PrepareNW ( newwindow, width, height, scale );
  789.                     A0         D0.L   D1.L    D2.L
  790.  
  791.         void PrepareNW ( struct NewWindow *, int, int, BOOL );
  792.  
  793.     FUNCTION
  794.         Initialize a NewWindow structure such that the window will open
  795.         properly on the ImageFX screen.
  796.  
  797.         You should call this function before calling GedWin() or
  798.         GedWindow().
  799.  
  800.         This function takes care of setting the Screen field to the
  801.         right value, depending on whether ImageFX is running on its
  802.         own custom screen, the Workbench, or some public screen.
  803.  
  804.     INPUTS
  805.         newwindow -- pointer to the NewWindow structure to initialize.
  806.  
  807.         width, height -- width and height of the window, in pixels.
  808.  
  809.         scale -- if TRUE, the width and height parameters are scaled
  810.             to take into account the user's preferred font.  You will
  811.             almost always want to set this to TRUE.
  812.  
  813.     RESULTS
  814.         None.
  815.  
  816.     EXAMPLE
  817.  
  818.     NOTES
  819.  
  820.     BUGS
  821.  
  822.     SEE ALSO
  823.         ged/GedWin(),ged/GedWindow()
  824.  
  825. ged/zzz
  826.