home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / misc / wingnuplot / source.lha / source / Window.c < prev    next >
C/C++ Source or Header  |  1994-06-19  |  31KB  |  847 lines
  1. #include "struct.c"
  2. #include "WinPlot.h"
  3. #include "OutlineFont.h"
  4. #include "amigawin.h"
  5.  
  6. /* like mui.h KeyButton, but with AmigaGuide node */
  7. #define KeyButtonGuide(name, key, helpnode)\
  8.     TextObject,\
  9.         ButtonFrame,\
  10.         MUIA_Text_Contents, name,\
  11.         MUIA_Text_PreParse, "\33c",\
  12.         MUIA_Text_SetMax  , FALSE,\
  13.         MUIA_Text_HiChar  , key,\
  14.         MUIA_ControlChar  , key,\
  15.         MUIA_InputMode    , MUIV_InputMode_RelVerify,\
  16.         MUIA_Background   , MUII_ButtonBack,\
  17.                 MUIA_HelpNode     , helpnode,\
  18.         End
  19.  
  20. #define CheckMarkGuide(selected, helpnode)\
  21.     ImageObject,\
  22.         ImageButtonFrame,\
  23.         MUIA_InputMode        , MUIV_InputMode_Toggle,\
  24.         MUIA_Image_Spec       , MUII_CheckMark,\
  25.         MUIA_Image_FreeVert   , TRUE,\
  26.         MUIA_Selected         , selected,\
  27.         MUIA_Background       , MUII_ButtonBack,\
  28.         MUIA_ShowSelState     , FALSE,\
  29.                 MUIA_HelpNode         , helpnode,\
  30.         End
  31.  
  32. #define CycleGuide(entries, helpnode)\
  33.         CycleObject,\
  34.          MUIA_Cycle_Entries , entries,\
  35.          MUIA_HelpNode      , helpnode,\ 
  36.         End
  37.  
  38. #define RangeObject(object, name)\
  39.          Child, Label2(name"Min:"),\
  40.          Child, object.Min = StringObject, MUIA_HelpNode, name"range", StringFrame, End,\
  41.          Child, Label2(name"Max:"),\
  42.          Child, object.Max = StringObject, MUIA_HelpNode, name"range", StringFrame, End,\
  43.          Child, Label("Auto_"name":"),\
  44.          Child, object.Auto = CheckMarkGuide(FALSE, "autoscale")
  45.  
  46. #define LogScaleObject(object, name)\
  47.          Child, Label("LogScale_"name":"),\
  48.          Child, object.LogScale = CheckMark(FALSE),\
  49.          Child, Label2("LogBase:"),\
  50.          Child, object.Base = StringObject, MUIA_Weight, 200, StringFrame, End
  51.  
  52. #define LabelObject(object, name)\
  53.          Child, Label(name),\
  54.          Child, object.Label = StringObject, StringFrame,\
  55.           MUIA_HelpNode, name,\
  56.          End,\
  57.          Child, Label("X"),\
  58.          Child, object.XOff = StringObject, StringFrame,\
  59.           MUIA_Weight, 50,\
  60.           MUIA_String_MaxLen, 6,\
  61.           MUIA_String_Integer, 0,\
  62.           MUIA_HelpNode, name,\
  63.          End,\
  64.          Child, Label("Y"),\
  65.          Child, object.YOff = StringObject, StringFrame,\
  66.           MUIA_Weight, 50,\
  67.           MUIA_String_MaxLen, 6,\
  68.           MUIA_String_Integer, 0,\
  69.           MUIA_HelpNode, name,\
  70.          End
  71.  
  72. #define WSpace(x) \
  73.          MUI_NewObject(MUIC_Rectangle, \
  74.                        MUIA_HorizWeight, 0, \
  75.                        MUIA_VertWeight, x, \
  76.                TAG_DONE)
  77.  
  78. /* the ContourCycle labels */
  79. static char *ContourEntries[] =
  80. {
  81.  "no", "base", "surface", "both", NULL
  82. };
  83.  
  84. /* the Mapping labels */
  85. static char *MappingEntries[] =
  86. {
  87.  "cartesian", "spherical", "cylindrical", NULL
  88. };
  89.  
  90. /* the StyleCycle labels */
  91. char *StyleEntries[] =
  92. {
  93.  "lines", "points", "impulses", "linespoints", "dots", "errorbars", "boxes",
  94.  "boxerrorbars", "steps", NULL
  95. };
  96.  
  97. /* the Settings pagegroup labels */
  98. char *SetPages[] =
  99. {
  100.  "PlotRanges", "LogScales", "3D-Options", "Misc", "Fonts", "Labels", "Colors", 
  101.  "User Defined", NULL,
  102. };
  103.  
  104. /* the Gadget IDs */
  105. enum IDs
  106. {
  107.  ID_ReqOk=1, ID_Load, ID_Save, ID_CD, ID_NewFont, ID_Color, ID_About,
  108.  ID_Variable, ID_Function, ID_NewWindow, ID_Close                    /* ID_Close must be last !! */
  109. };
  110.  
  111. /* some simple menu */
  112. static struct NewMenu Menu[] =
  113. {
  114.  { NM_TITLE, "Project",   0,   0, 0, NULL},
  115.  { NM_ITEM,  "About...",  "?", 0, 0, (APTR)ID_About},
  116.  { NM_ITEM,  NM_BARLABEL, 0,   0, 0, 0},
  117.  { NM_ITEM,  "Load",      "L", 0, 0, (APTR)ID_Load},
  118.  { NM_ITEM,  "Save",      "S", 0, 0, (APTR)ID_Save},
  119.  { NM_ITEM,  "CD",        "C", 0, 0, (APTR)ID_CD},
  120.  { NM_ITEM,  NM_BARLABEL, 0,   0, 0, 0},
  121.  { NM_ITEM,  "Quit",      "Q", 0, 0, (APTR)MUIV_Application_ReturnID_Quit},
  122.  { NM_END,   NULL,        0,   0, 0, 0}
  123. };
  124.  
  125. /* the MUI objects */
  126.        APTR AP_WinPlot    = NULL; /* Application */
  127. static APTR WI_Settings   = NULL; /* Settings window */
  128. static APTR WI_Request    = NULL; /* Request window */
  129. static APTR BT_ReqOk      = NULL; /* Quit Requester button */
  130.        APTR LV_Font       = NULL; /* Font ListView */
  131. static APTR TO_Req        = NULL; /* Requester text */
  132. static APTR CY_Contour    = NULL; /* Contour gadget */
  133. static APTR CY_Function   = NULL; /* Function Style gadget */
  134. static APTR CY_Data       = NULL; /* Data Style gadget */
  135. static APTR CY_Mapping    = NULL; /* Mapping gadget */
  136. static APTR CM_Hidden3d   = NULL; /* Hidden3D button */
  137. static APTR CM_Surface    = NULL;
  138. static APTR SO_RotX       = NULL;
  139. static APTR SO_RotZ       = NULL;
  140. static APTR SO_Scale      = NULL;
  141. static APTR SO_ScaleZ     = NULL;
  142. static APTR SO_RePlot     = NULL; /* last plot command */
  143. static APTR CM_Parametric = NULL;
  144. static APTR CM_Polar      = NULL;
  145. static APTR CM_Grid       = NULL;
  146. static APTR CM_Border     = NULL;
  147. static APTR CM_XZero      = NULL;
  148. static APTR CM_YZero      = NULL;
  149. static APTR PO_Color      = NULL;
  150. static APTR BT_Color      = NULL;
  151. static APTR LV_Variable   = NULL; /* user defined variables */
  152. static APTR LV_Function   = NULL; /* user defined functions */
  153. static APTR SO_Variable   = NULL;
  154. static APTR SO_Function   = NULL;
  155.        APTR RG_Set        = NULL; /* the settings register group */
  156.  
  157. static struct RangeObject    XRange, YRange, ZRange, RRange, TRange, URange, VRange;
  158. static struct LogScaleObject XLog, YLog, ZLog;
  159. static struct LabelObject    Title, XLabel, YLabel, ZLabel;
  160.  
  161. /* These are the plotwindows */
  162. struct PlotWindow Windows[5];
  163. LONG              ActiveWindow = 0;
  164.  
  165. /* this routine freshes the plot, e.g. after a font change */
  166. void Refresh(void)
  167. {
  168.  struct Window *MainWindow;
  169.  struct Gadget *PlotGadget;
  170.  
  171.  get(Windows[ActiveWindow].WI_Plot, MUIA_Window_Window, &MainWindow);
  172.  get(Windows[ActiveWindow].BO_Plot, MUIA_Boopsi_Object, &PlotGadget);
  173.  if (MainWindow && PlotGadget)
  174.   RefreshGList(PlotGadget, MainWindow, NULL, 1);
  175. }
  176.  
  177. /* build the fontlist */
  178. static void InsertFonts(void)
  179. {
  180.  struct FileInfoBlock *fib;
  181.  struct DevProc        *devproc = NULL;
  182.  
  183.  if (fib = AllocDosObject(DOS_FIB, NULL))
  184.   {
  185.    /* sometimes FONTS: is a MultiAssign */
  186.    while (devproc = GetDeviceProc("FONTS:", devproc))
  187.     {
  188.      /* see Guru-Book  page.437 */
  189.      struct MsgPort *old;
  190.      BPTR dup;
  191.  
  192.      old = SetFileSysTask(devproc->dvp_Port);
  193.      dup = DupLock(devproc->dvp_Lock);
  194.      SetFileSysTask(old);
  195.  
  196.      if (dup)
  197.       {
  198.        Examine(dup, fib);
  199.        while (ExNext(dup, fib) && (IoErr() != ERROR_NO_MORE_ENTRIES))
  200.     DoMethod(LV_Font, MUIM_List_InsertSingle, fib, MUIV_List_Insert_Sorted);
  201.        UnLock(dup);
  202.       }
  203.     }
  204.    FreeDeviceProc(devproc);
  205.    FreeDosObject(DOS_FIB, fib);
  206.   }
  207. }
  208.  
  209. /* Notifation for a RangeObject */
  210. static void NotifyRange(APTR GUI, struct RangeObject *ro, char *name, char *command)
  211. {
  212.  DoMethod(ro->Min, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  213.       GUI, 4, MUIM_CallHook, &RangeHook, ro, name);
  214.  DoMethod(ro->Max, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  215.       GUI, 4, MUIM_CallHook, &RangeHook, ro, name);
  216.  DoMethod(ro->Auto, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  217.       ro->Auto, 3, MUIM_CallHook, &CheckHook, command);
  218. }
  219.  
  220. /* Notification for a LogScaleObject */
  221. static void NotifyLogScale(APTR GUI, struct LogScaleObject *lco, char *command)
  222. {
  223.  DoMethod(lco->LogScale, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  224.       lco->LogScale, 4, MUIM_CallHook, &LogScaleHook, lco, command);
  225.  DoMethod(lco->Base, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  226.       GUI, 4, MUIM_CallHook, &LogScaleHook, lco, command);
  227. }
  228.  
  229. /* Notification for a LabelObject */
  230. static void NotifyLabel(APTR GUI, struct LabelObject *lo, char *title)
  231. {
  232.  DoMethod(lo->Label, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  233.       GUI, 4, MUIM_CallHook, &LabelHook, lo, title);
  234.  DoMethod(lo->XOff, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  235.       GUI, 4, MUIM_CallHook, &LabelHook, lo, title);
  236.  DoMethod(lo->YOff, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  237.       GUI, 4, MUIM_CallHook, &LabelHook, lo, title);
  238. }
  239.  
  240. /* Build the Plot Window */
  241. void InitPlotWindow(APTR GUI, int n)
  242. {
  243.  sprintf(Windows[n].Title, "WinPlot_%d", n+1);
  244.  Windows[n].WI_Plot = WindowObject,
  245.                        MUIA_Window_Title, Windows[n].Title,
  246.                        MUIA_Window_ID,MAKE_ID('P','L','T','0'+n),
  247.                        WindowContents, VGroup, 
  248.                         Child, HGroup, GroupFrame,
  249.                          MUIA_Group_SameSize, TRUE,
  250.                          Child, Windows[n].BT_Plot = KeyButtonGuide("RePlot", 'p', "replot"),
  251.                          Child, Windows[n].BT_Load = KeyButtonGuide("Load", 'l', "load"),
  252.                          Child, Windows[n].BT_Save = KeyButtonGuide("Save", 's', "save"),
  253.                          Child, Windows[n].BT_CD   = KeyButtonGuide("CD", 'c', "cd"),
  254.                          Child, Windows[n].BT_Set  = KeyButtonGuide("Edit", 'e', "set-show"),
  255.                          Child, Windows[n].BT_New  = KeyButton("New Window", 'n'),
  256.                         End,
  257.                         Child, Windows[n].BO_Plot = BoopsiObject,
  258.                          GroupFrame,
  259.                          MUIA_Boopsi_Class, PlotImgClass,
  260.                          MUIA_Boopsi_MinWidth, 30,
  261.                          MUIA_Boopsi_MinHeight, 30,
  262.                          GA_LEFT, 0,
  263.                          GA_TOP, 0,
  264.                          GA_WIDTH, 0,
  265.                          GA_HEIGHT, 0,
  266.                         End,
  267.                        End,
  268.                       End;
  269.  if (Windows[n].WI_Plot)
  270.   {
  271.    DoMethod(Windows[n].WI_Plot, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  272.         GUI, 2, MUIM_Application_ReturnID, ID_Close + n);
  273.    DoMethod(Windows[n].BT_Plot, MUIM_Notify, MUIA_Pressed, FALSE,
  274.         GUI, 3, MUIM_CallHook, &RexxCommandHook, "replot");
  275.    DoMethod(Windows[n].BT_Load, MUIM_Notify, MUIA_Pressed, FALSE,
  276.         GUI, 2, MUIM_Application_ReturnID, ID_Load);
  277.    DoMethod(Windows[n].BT_Save, MUIM_Notify, MUIA_Pressed, FALSE,
  278.         GUI, 2, MUIM_Application_ReturnID, ID_Save);
  279.    DoMethod(Windows[n].BT_CD, MUIM_Notify, MUIA_Pressed, FALSE,
  280.         GUI, 2, MUIM_Application_ReturnID, ID_CD);
  281.    DoMethod(Windows[n].BT_New, MUIM_Notify, MUIA_Pressed, FALSE,
  282.         GUI, 2, MUIM_Application_ReturnID, ID_NewWindow);
  283.    DoMethod(Windows[n].BT_Set, MUIM_Notify, MUIA_Pressed, FALSE,
  284.         WI_Settings, 3, MUIM_Set, MUIA_Window_Open, TRUE);
  285.    DoMethod(Windows[n].WI_Plot, MUIM_Notify, MUIA_Window_Activate, TRUE,
  286.         GUI, 3, MUIM_WriteLong, n, &ActiveWindow);
  287.    DoMethod(GUI, OM_ADDMEMBER, Windows[n].WI_Plot);
  288.   }
  289. }
  290.  
  291. /* Build the GUI */
  292. APTR GetGUI(void)
  293. {
  294.  APTR GUI;
  295.  
  296.  GUI = ApplicationObject,
  297.     MUIA_Application_Title, "WinPlot",
  298.     MUIA_Application_Version, "$VER: WinPlot 2.1  "__AMIGADATE__,
  299.         MUIA_Application_Copyright, "Copyright © 1994 by Michael Illgner",
  300.         MUIA_Application_Author, "Michael Illgner",
  301.         MUIA_Application_Description, "A MUI GnuPlot Frontend",
  302.         MUIA_Application_Base, "WINPLOT",
  303.         MUIA_Application_SingleTask, TRUE,
  304.         MUIA_Application_Menu, Menu,
  305.     MUIA_HelpFile, "PROGDIR:gnuplot.guide",
  306.         SubWindow, WI_Settings = WindowObject,
  307.          MUIA_Window_Title, "GnuPlot settings",
  308.          MUIA_Window_ID, MAKE_ID('P','S','E','T'),
  309.          MUIA_HelpNode, "set-show",
  310.          WindowContents, VGroup,
  311.           Child, RG_Set = RegisterGroup(SetPages),
  312.            MUIA_Register_Frame, TRUE,
  313.             Child, VGroup,
  314.             Child, WSpace(100), 
  315.             Child, ColGroup(6),
  316.              RangeObject(XRange, "X"),
  317.              RangeObject(YRange, "Y"),
  318.              RangeObject(ZRange, "Z"),
  319.              RangeObject(RRange, "R"),
  320.              RangeObject(TRange, "T"),
  321.              RangeObject(URange, "U"),
  322.              RangeObject(VRange, "V"),
  323.             End,
  324.             Child, WSpace(100),
  325.            End,
  326.            Child, VGroup,
  327.             Child, WSpace(100),
  328.             Child, ColGroup(4), MUIA_HelpNode, "logscale",
  329.              LogScaleObject(XLog, "X"),
  330.              LogScaleObject(YLog, "Y"),
  331.              LogScaleObject(ZLog, "Z"),
  332.             End,
  333.             Child, WSpace(100),
  334.            End,
  335.            Child, VGroup,
  336.             Child, WSpace(100),
  337.             Child, VGroup,
  338.              Child, ColGroup(4),
  339.               Child, HSpace(0),
  340.               Child, Label("Contour:"),
  341.               Child, CY_Contour = CycleGuide(ContourEntries, "contour"),
  342.               Child, HSpace(0),
  343.               Child, HSpace(0),
  344.               Child, Label("Mapping:"),
  345.               Child, CY_Mapping = CycleGuide(MappingEntries, "mapping"),
  346.               Child, HSpace(0),
  347.              End,
  348.              Child, WSpace(50),
  349.              Child, ColGroup(4),
  350.               Child, HSpace(0),
  351.               Child, Label("Hidden3D:"),
  352.               Child, CM_Hidden3d = CheckMarkGuide(FALSE, "hidden3d"),
  353.               Child, HSpace(0),
  354.               Child, HSpace(0),
  355.               Child, Label("Surface"),
  356.               Child, CM_Surface = CheckMarkGuide(FALSE, "surface"),
  357.               Child, HSpace(0),
  358.              End,
  359.              Child, WSpace(50),
  360.              Child, ColGroup(2),
  361.               Child, Label("Rotation_X:"),
  362.               Child, SO_RotX = StringObject, StringFrame,
  363.                MUIA_HelpNode, "view",
  364.               End,
  365.               Child, Label("Rotation_Z:"),
  366.               Child, SO_RotZ = StringObject, StringFrame,
  367.                MUIA_HelpNode, "view",
  368.               End,
  369.               Child, Label("Scale:"),
  370.               Child, SO_Scale = StringObject, StringFrame,
  371.                MUIA_HelpNode, "view",
  372.               End,
  373.               Child, Label("Scale_Z:"),
  374.               Child, SO_ScaleZ = StringObject, StringFrame,
  375.                MUIA_HelpNode, "view",
  376.               End,
  377.              End,
  378.             End,
  379.             Child, WSpace(100),
  380.            End,
  381.            Child, VGroup,
  382.             Child, WSpace(100),
  383.             Child, ColGroup(6),
  384.              Child, HSpace(0),
  385.              Child, Label("Functionstyle:"),
  386.              Child, CY_Function = CycleGuide(StyleEntries, "style"),
  387.              Child, Label("Datastyle:"),
  388.              Child, CY_Data = CycleGuide(StyleEntries, "style"),
  389.              Child, HSpace(0),
  390.              Child, HSpace(0),
  391.              Child, WSpace(25),
  392.              Child, WSpace(25),
  393.              Child, WSpace(25),
  394.              Child, WSpace(25),
  395.              Child, HSpace(0),
  396.              Child, HSpace(0),
  397.              Child, Label("Parametric:"),
  398.              Child, CM_Parametric = CheckMarkGuide(FALSE, "parametric"),
  399.              Child, Label("Polar:"),
  400.              Child, CM_Polar = CheckMarkGuide(FALSE, "polar"),
  401.              Child, HSpace(0),
  402.              Child, HSpace(0),
  403.              Child, Label("Grid:"),
  404.              Child, CM_Grid = CheckMarkGuide(FALSE, "grid"),
  405.              Child, Label("Border:"),
  406.              Child, CM_Border = CheckMarkGuide(FALSE, "border"),
  407.              Child, HSpace(0),
  408.              Child, HSpace(0),
  409.              Child, Label("xzeroaxis"),
  410.              Child, CM_XZero = CheckMarkGuide(FALSE, "xzeroaxis"),
  411.              Child, Label("yzeroaxis"),
  412.              Child, CM_YZero = CheckMarkGuide(FALSE, "yzeroaxis"),
  413.              Child, HSpace(0),
  414.             End,
  415.             Child, WSpace(100),
  416.            End,
  417.            Child, LV_Font = ListviewObject, InputListFrame,
  418.             MUIA_Listview_List, ListObject,
  419.              MUIA_List_ConstructHook, &ConFontHook,
  420.              MUIA_List_DestructHook, &DesFontHook,
  421.             End,
  422.            End,
  423.            Child, VGroup,
  424.             Child, WSpace(100),
  425.             Child, ColGroup(6),
  426.              LabelObject(Title, "Title"),
  427.              LabelObject(XLabel, "XLabel"),
  428.              LabelObject(YLabel, "YLabel"),
  429.              LabelObject(ZLabel, "ZLabel"),
  430.             End,
  431.             Child, WSpace(100),
  432.            End,
  433.            Child, VGroup,
  434.             Child, WSpace(100),
  435.             Child, PO_Color = PaletteObject, GroupFrame,
  436.              MUIA_Palette_Entries, ColorEntries,
  437.              MUIA_Palette_Names, ColorNames,
  438.             End,
  439.             Child, WSpace(50),
  440.             Child, BT_Color = KeyButton("Change Colors", 'c'),
  441.             Child, WSpace(100),
  442.            End,
  443.            Child, VGroup,
  444.             MUIA_HelpNode, "user-defined",
  445.             Child, VGroup, InputListFrame,
  446.              Child, LV_Variable = ListviewObject,
  447.               MUIA_FrameTitle, "User defined Variables",
  448.               MUIA_Listview_List, ListObject,
  449.                MUIA_List_ConstructHook, &ConVarHook,
  450.                MUIA_List_DestructHook, &DesVarHook,
  451.               End,
  452.              End,
  453.              Child, VSpace(1),
  454.              Child, SO_Variable = StringObject, StringFrame, 
  455.               MUIA_String_AttachedList, LV_Variable,
  456.              End,
  457.             End,
  458.             Child, VSpace(5),
  459.             Child, VGroup, InputListFrame,
  460.              Child, LV_Function = ListviewObject,
  461.               MUIA_FrameTitle, "User defined Functions",
  462.               MUIA_Listview_List, ListObject, End,
  463.              End,
  464.              Child, VSpace(1),
  465.              Child, SO_Function = StringObject, StringFrame,
  466.               MUIA_String_AttachedList, LV_Function,
  467.               End,
  468.             End,
  469.            End,
  470.           End,
  471.           Child, VGroup,
  472.            MUIA_Frame, MUIV_Frame_String,
  473.            MUIA_FrameTitle, "Last Plot",
  474.            Child, SO_RePlot = StringObject,
  475.             MUIA_HelpNode, "plot",
  476.            End,
  477.           End,
  478.          End,
  479.         End,
  480.         SubWindow, WI_Request = WindowObject,
  481.          MUIA_Window_Title, "WinPlot Requester",
  482.          MUIA_Window_SizeGadget, FALSE,
  483.          MUIA_Window_CloseGadget, FALSE,
  484.          MUIA_Window_ID, MAKE_ID('P','R','E','Q'),
  485.          WindowContents, VGroup,
  486.        MUIA_Background, MUII_RequesterBack,
  487.           Child, TO_Req = TextObject, TextFrame,
  488.        MUIA_Background, MUII_TextBack,
  489.            MUIA_Text_PreParse, "\33c",
  490.           End,
  491.       Child, BT_ReqOk = TextObject,
  492.            ButtonFrame,
  493.        MUIA_Text_Contents, "Ok",
  494.            MUIA_Text_PreParse, "\33c",
  495.            MUIA_Text_SetMax, TRUE,
  496.            MUIA_Text_HiChar, '\r',
  497.            MUIA_ControlChar, '\r',
  498.            MUIA_InputMode, MUIV_InputMode_RelVerify,
  499.            MUIA_Background, MUII_ActiveBack,
  500.           End,
  501.          End,
  502.         End,
  503.        End;
  504.  
  505.  if (GUI)
  506.   {
  507.    DoMethod(WI_Settings, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  508.             WI_Settings, 3, MUIM_Set, MUIA_Window_Open, FALSE);
  509.    DoMethod(SO_RePlot, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  510.         SO_RePlot, 2, MUIM_CallHook, &StringCommandHook);
  511.    DoMethod(BT_ReqOk, MUIM_Notify, MUIA_Pressed, FALSE,
  512.         GUI, 2, MUIM_Application_ReturnID, ID_ReqOk);
  513.    DoMethod(LV_Font, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  514.         GUI, 2, MUIM_Application_ReturnID, ID_NewFont);
  515.    NotifyRange(GUI, &XRange, "xrange", "set %sautoscale x");
  516.    NotifyRange(GUI, &YRange, "yrange", "set %sautoscale y");
  517.    NotifyRange(GUI, &ZRange, "zrange", "set %sautoscale z");
  518.    NotifyRange(GUI, &RRange, "rrange", "set %sautoscale r");
  519.    NotifyRange(GUI, &TRange, "trange", "set %sautoscale t");
  520.    NotifyRange(GUI, &URange, "urange", "set %sautoscale u");
  521.    NotifyRange(GUI, &VRange, "vrange", "set %sautoscale v");
  522.    DoMethod(CM_Hidden3d, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  523.         CM_Hidden3d, 3, MUIM_CallHook, &CheckHook, "set %shidden3d");
  524.    DoMethod(CM_Parametric, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  525.         CM_Parametric, 3, MUIM_CallHook, &CheckHook, "set %sparametric");
  526.    DoMethod(CM_Polar, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  527.         CM_Polar, 3, MUIM_CallHook, &CheckHook, "set %spolar");
  528.    DoMethod(CM_Grid, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  529.         CM_Grid, 3, MUIM_CallHook, &CheckHook, "set %sgrid");
  530.    DoMethod(CM_Border, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  531.         CM_Border, 3, MUIM_CallHook, &CheckHook, "set %sborder");
  532.    DoMethod(CM_XZero, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  533.         CM_XZero, 3, MUIM_CallHook, &CheckHook, "set %sxzeroaxis");
  534.    DoMethod(CM_YZero, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  535.         CM_YZero, 3, MUIM_CallHook, &CheckHook, "set %syzeroaxis");
  536.    DoMethod(CM_Surface, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
  537.         CM_Surface, 3, MUIM_CallHook, &CheckHook, "set %ssurface");
  538.    DoMethod(CY_Contour, MUIM_Notify, MUIA_Cycle_Active, 0,
  539.             GUI, 3, MUIM_CallHook, &RexxCommandHook, "set nocontour");
  540.    DoMethod(CY_Contour, MUIM_Notify, MUIA_Cycle_Active, 1,
  541.             GUI, 3, MUIM_CallHook, &RexxCommandHook, "set contour base");
  542.    DoMethod(CY_Contour, MUIM_Notify, MUIA_Cycle_Active, 2,
  543.             GUI, 3, MUIM_CallHook, &RexxCommandHook, "set contour surface");
  544.    DoMethod(CY_Contour, MUIM_Notify, MUIA_Cycle_Active, 3,
  545.             GUI, 3, MUIM_CallHook, &RexxCommandHook, "set contour both");
  546.    DoMethod(CY_Mapping, MUIM_Notify, MUIA_Cycle_Active, 0,
  547.         GUI, 3, MUIM_CallHook, &RexxCommandHook, "set mapping cartesian");
  548.    DoMethod(CY_Mapping, MUIM_Notify, MUIA_Cycle_Active, 1,
  549.         GUI, 3, MUIM_CallHook, &RexxCommandHook, "set mapping spherical");
  550.    DoMethod(CY_Mapping, MUIM_Notify, MUIA_Cycle_Active, 2,
  551.         GUI, 3, MUIM_CallHook, &RexxCommandHook, "set mapping cylindrical");
  552.    DoMethod(SO_RotX, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  553.         SO_RotX, 3, MUIM_CallHook, &ViewHook, "set view %s");
  554.    DoMethod(SO_RotZ, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  555.         SO_RotZ, 3, MUIM_CallHook, &ViewHook, "set view ,%s");
  556.    DoMethod(SO_Scale, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  557.         SO_Scale, 3, MUIM_CallHook, &ViewHook, "set view ,,%s");
  558.    DoMethod(SO_ScaleZ, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  559.         SO_ScaleZ, 3, MUIM_CallHook, &ViewHook, "set view ,,,%s");
  560.    DoMethod(CY_Function, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
  561.         CY_Function, 3, MUIM_CallHook, &StyleHook, "set function style %s");
  562.    DoMethod(CY_Data, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
  563.         CY_Data, 3, MUIM_CallHook, &StyleHook, "set data style %s");
  564.    NotifyLogScale(GUI, &XLog, "set %slogscale x %s");
  565.    NotifyLogScale(GUI, &YLog, "set %slogscale y %s");
  566.    NotifyLogScale(GUI, &ZLog, "set %slogscale z %s");
  567.    NotifyLabel(GUI, &Title, "title");
  568.    NotifyLabel(GUI, &XLabel, "xlabel");
  569.    NotifyLabel(GUI, &YLabel, "ylabel");
  570.    NotifyLabel(GUI, &ZLabel, "zlabel");
  571.    DoMethod(BT_Color, MUIM_Notify, MUIA_Pressed, FALSE,
  572.         GUI, 2, MUIM_Application_ReturnID, ID_Color);
  573.    DoMethod(LV_Variable ,MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  574.         GUI, 2, MUIM_Application_ReturnID, ID_Variable);
  575.    DoMethod(SO_Variable, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  576.         SO_Variable, 2, MUIM_CallHook, &StringCommandHook);
  577.    DoMethod(LV_Function ,MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
  578.         GUI, 2, MUIM_Application_ReturnID, ID_Function);
  579.    DoMethod(SO_Function, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  580.         SO_Function, 2, MUIM_CallHook, &StringCommandHook);
  581.    InsertFonts();
  582.    LoadConf();
  583.    InitPlotWindow(GUI, 0); ActiveWindow = 0;
  584.  
  585.    DoMethod(WI_Settings, MUIM_Window_SetCycleChain,
  586.         SO_RePlot,
  587.         XRange.Min, XRange.Max, XRange.Auto,
  588.         YRange.Min, YRange.Max, YRange.Auto,
  589.         ZRange.Min, ZRange.Max, ZRange.Auto,
  590.         RRange.Min, RRange.Max, RRange.Auto,
  591.         TRange.Min, TRange.Max, TRange.Auto,
  592.         URange.Min, URange.Max, URange.Auto,
  593.         VRange.Min, VRange.Max, VRange.Auto,
  594.         XLog.LogScale, XLog.Base,
  595.         YLog.LogScale, YLog.Base,
  596.         ZLog.LogScale, ZLog.Base,
  597.         CY_Contour, CY_Mapping, CM_Hidden3d, CM_Surface,
  598.         SO_RotX, SO_RotZ, SO_Scale, SO_ScaleZ,
  599.         CY_Data, CY_Function,
  600.             CM_Parametric, CM_Polar, CM_Grid, CM_Border, CM_XZero, CM_YZero,
  601.         LV_Font,
  602.         Title.Label, Title.XOff, Title.YOff,
  603.         XLabel.Label, XLabel.XOff, XLabel.YOff,
  604.         YLabel.Label, YLabel.XOff, YLabel.YOff,
  605.         ZLabel.Label, ZLabel.XOff, ZLabel.YOff,
  606.             PO_Color, BT_Color,
  607.         LV_Variable, SO_Variable,
  608.         LV_Function, SO_Function,
  609.             NULL);
  610.   }
  611.  
  612.  return GUI;
  613. }
  614.  
  615. /* the 'please press <return>' requester */
  616. /* it looks like a requester, but is in fact a window */
  617. void WaitRequest(char *Text)
  618. {
  619.  BOOL Quit = FALSE;
  620.  int  i;
  621.   
  622.  set(TO_Req, MUIA_Text_Contents, Text);
  623.  set(WI_Request, MUIA_Window_Open, TRUE);
  624.  
  625.  /* disable the mainbuttons in all PlotWindows */
  626.  for(i=0; i<MAXWINDOW; i++)
  627.   if (Windows[i].WI_Plot)
  628.    DoMethod(WI_Request, MUIM_MultiSet, MUIA_Disabled, TRUE,
  629.         Windows[i].BT_Plot, Windows[i].BT_CD, Windows[i].BT_Load,
  630.         Windows[i].BT_Save, Windows[i].BT_New,
  631.         NULL);
  632.  
  633.  while (!Quit)
  634.   {
  635.    ULONG ID, Signals;
  636.    
  637.    ID = DoMethod(AP_WinPlot, MUIM_Application_Input, &Signals);
  638.    switch (ID)
  639.     {
  640.     case ID_ReqOk:
  641.      Quit = TRUE;
  642.      break;
  643.     }
  644.    if (Signals) Wait(Signals);
  645.   }
  646.  
  647.  /* enable the main buttons */
  648.  for(i=0; i<MAXWINDOW; i++)
  649.   if (Windows[i].WI_Plot)
  650.    DoMethod(WI_Request, MUIM_MultiSet, MUIA_Disabled, FALSE,
  651.         Windows[i].BT_Plot, Windows[i].BT_CD, Windows[i].BT_Load,
  652.         Windows[i].BT_Save, Windows[i].BT_New,
  653.         NULL);
  654.  
  655.  set(WI_Request, MUIA_Window_Open, FALSE);
  656. }
  657.  
  658. /* set StringObject to double*/
  659. static void SetString(APTR so, double val)
  660. {
  661.  char Buffer[255];
  662.  
  663.  sprintf(Buffer, "%lg", val);
  664.  nnset(so, MUIA_String_Contents, Buffer);
  665.  nnset(so, MUIA_String_BufferPos, 0);
  666. }
  667.  
  668. /* set RangeObject values */
  669. static void SetRange(struct RangeObject ro, double min, double max, BOOL autorange)
  670. {
  671.  SetString(ro.Min, min);
  672.  SetString(ro.Max, max);
  673. }
  674.  
  675. /* set LogScaleObject values */
  676. static void SetLogScale(struct LogScaleObject lco, double base, BOOL logscale)
  677. {
  678.  if (base != 0.0)
  679.   SetString(lco.Base, base);
  680.  nnset(lco.LogScale, MUIA_Selected, logscale);
  681. }
  682.  
  683. /* set LabelObject values */
  684. static void SetLabel(struct LabelObject lo, char *Title, int XOff, int YOff)
  685. {
  686.  nnset(lo.Label, MUIA_String_Contents, Title);
  687.  nnset(lo.Label, MUIA_String_BufferPos, 0);
  688.  nnset(lo.XOff, MUIA_String_Integer, XOff);
  689.  nnset(lo.YOff, MUIA_String_Integer, YOff);
  690. }
  691.  
  692. void Settings(struct SetVar *sv)
  693. {
  694.  udvt_entry *udv;
  695.  udft_entry *udf;
  696.  
  697.  if (sv)
  698.   {
  699.    SetRange(XRange, sv->xmin, sv->xmax, sv->autox);
  700.    SetRange(YRange, sv->ymin, sv->ymax, sv->autoy);
  701.    SetRange(ZRange, sv->zmin, sv->zmax, sv->autoz);
  702.    SetRange(RRange, sv->rmin, sv->rmax, sv->autor);
  703.    SetRange(TRange, sv->tmin, sv->tmax, sv->autot);
  704.    SetRange(URange, sv->umin, sv->umax, sv->autou);
  705.    SetRange(VRange, sv->vmin, sv->vmax, sv->autov);
  706.  
  707.    SetLogScale(XLog, sv->basex, sv->logx);
  708.    SetLogScale(YLog, sv->basey, sv->logy);
  709.    SetLogScale(ZLog, sv->basez, sv->logz);
  710.  
  711.    nnset(CY_Contour, MUIA_Cycle_Active, sv->contour);
  712.    nnset(CY_Mapping, MUIA_Cycle_Active, sv->mapping);
  713.    nnset(CM_Hidden3d, MUIA_Selected, sv->hidden3d);
  714.    nnset(CM_Surface, MUIA_Selected, sv->surface);
  715.    SetString(SO_RotX, sv->rotx);
  716.    SetString(SO_RotZ, sv->rotz);
  717.    SetString(SO_Scale, sv->scale);
  718.    SetString(SO_ScaleZ, sv->zscale);
  719.    nnset(CY_Function, MUIA_Cycle_Active, sv->functionstyle);
  720.    nnset(CY_Data, MUIA_Cycle_Active, sv->datastyle);
  721.    
  722.    nnset(CM_Parametric, MUIA_Selected, sv->parametric);
  723.    nnset(CM_Polar, MUIA_Selected, sv->polar);
  724.    nnset(CM_Grid, MUIA_Selected, sv->grid);
  725.    nnset(CM_Border, MUIA_Selected, sv->border);
  726.    nnset(CM_XZero, MUIA_Selected, sv->xzeroaxis);
  727.    nnset(CM_YZero, MUIA_Selected, sv->yzeroaxis);
  728.  
  729.    SetLabel(Title, sv->title, sv->title_xoff, sv->title_yoff);
  730.    SetLabel(XLabel, sv->xlabel, sv->xlabel_xoff, sv->xlabel_yoff);
  731.    SetLabel(YLabel, sv->ylabel, sv->ylabel_xoff, sv->ylabel_yoff);
  732.    SetLabel(ZLabel, sv->zlabel, sv->zlabel_xoff, sv->zlabel_yoff);
  733.  
  734.    nnset(SO_RePlot, MUIA_String_Contents, sv->replot);
  735.    nnset(SO_RePlot, MUIA_String_BufferPos, 0);
  736.  
  737.    set(LV_Variable, MUIA_List_Quiet, TRUE);
  738.    DoMethod(LV_Variable, MUIM_List_Clear);
  739.    for(udv = sv->user_variables; udv; udv=udv->next_udv)
  740.     DoMethod(LV_Variable, MUIM_List_InsertSingle, udv, MUIV_List_Insert_Bottom);
  741.    set(LV_Variable, MUIA_List_Quiet, FALSE);
  742.  
  743.    set(LV_Function, MUIA_List_Quiet, TRUE);
  744.    DoMethod(LV_Function, MUIM_List_Clear);
  745.    for(udf = sv->user_functions; udf; udf=udf->next_udf)
  746.     DoMethod(LV_Function, MUIM_List_InsertSingle, udf->definition, MUIV_List_Insert_Bottom);
  747.    set(LV_Function, MUIA_List_Quiet, FALSE);
  748.   }
  749. }
  750.  
  751. BOOL HandleMUI(LONG Id)
  752. {
  753.  BOOL   Quit = FALSE;
  754.  int    i, NewWindow;
  755.  char  *s;
  756.  
  757.  switch(Id)
  758.   {
  759.   case MUIV_Application_ReturnID_Quit:
  760.    if (MUI_Request(AP_WinPlot, NULL, 0, NULL, "Ok|*Cancel", "Do you really want to quit ?!"))
  761.     {
  762.      if (FindPort(GNUREPLY))
  763.       SendRexxMsg("quit");
  764.      else Quit = TRUE;
  765.     }
  766.    break;
  767.   case ID_NewFont:
  768.    DoMethod(LV_Font, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &s);
  769.    CloseOutlineFont();
  770.    OpenOutlineFont(s);
  771.    Refresh();
  772.    break;
  773.   case ID_Load:
  774.    LoadFunc();
  775.    break;
  776.   case ID_Save:
  777.    SaveFunc();
  778.    break;
  779.   case ID_CD:
  780.    CDFunc();
  781.    break;
  782.   case ID_Color:
  783.    Refresh();
  784.    break;
  785.   case ID_About:
  786.    MUI_Request(AP_WinPlot, NULL, 0, NULL, "OK",
  787.            "\033c\0338WinPlot\n\n"
  788.            "\0332Version 2.1  ("__DATE__")\n"
  789.            "Copyright 1994 by Michael Illgner.\n"
  790.            "\nThis is a MUI-Application.\n"
  791.            "MUI is copyrighted by Stefan Stuntz.");
  792.    break;
  793.   case ID_Variable:
  794.    DoMethod(LV_Variable, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &s);
  795.    set(SO_Variable, MUIA_String_Contents, s);
  796.    break;
  797.   case ID_Function:
  798.    DoMethod(LV_Function, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &s);
  799.    set(SO_Function, MUIA_String_Contents, s);
  800.    break;
  801.   case ID_NewWindow:
  802.    NewWindow = -1; i = 0;
  803.    while(NewWindow < 0 && i < MAXWINDOW)
  804.     {
  805.      if (Windows[i].WI_Plot == NULL)
  806.       NewWindow = i;
  807.      i++;
  808.     }
  809.    if (NewWindow >= 0 && NewWindow < MAXWINDOW)
  810.     {
  811.      InitPlotWindow(AP_WinPlot, NewWindow);
  812.      set(Windows[NewWindow].WI_Plot, MUIA_Window_Open, TRUE);
  813.      ActiveWindow = NewWindow;
  814.     }
  815.    else
  816.     WaitRequest("Sorry, No more Windows available");
  817.    break;
  818.   default:
  819.    if (Id >= ID_Close && Id < ID_Close+MAXWINDOW)
  820.     {
  821.      int OpenWindows = 0;
  822.      
  823.      for(i=0; i<MAXWINDOW; i++)
  824.       if (Windows[i].WI_Plot)
  825.        OpenWindows++;
  826.      
  827.      if (OpenWindows != 1)
  828.       {
  829.        set(Windows[Id-ID_Close].WI_Plot, MUIA_Window_Open, FALSE);
  830.        DoMethod(AP_WinPlot, OM_REMMEMBER, Windows[Id-ID_Close].WI_Plot);
  831.        MUI_DisposeObject(Windows[Id-ID_Close].WI_Plot);
  832.        Windows[Id-ID_Close].WI_Plot = NULL;
  833.       }
  834.      else /* Last Window is closed */
  835.       if (MUI_Request(AP_WinPlot, NULL, 0, NULL, "Ok|*Cancel", "Do you really want to quit ?!"))
  836.        {
  837.     if (FindPort(GNUREPLY))
  838.      SendRexxMsg("quit");
  839.     else Quit = TRUE;
  840.        }
  841.     }
  842.    break;
  843.   }
  844.  
  845.  return Quit;
  846. }
  847.