home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / misc / wingnuplot / source.lha / source / Hooks.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  5.7 KB  |  292 lines
  1. #include "struct.c"
  2. #include "WinPlot.h"
  3.  
  4. /* Contruct Entry for FontListView */
  5. static __saveds __asm char *ConFont(register __a0 struct Hook *hook,
  6.                     register __a2 APTR         mem_pool,
  7.                     register __a1 struct FileInfoBlock *fib)
  8. {
  9.  char pattern[14];
  10.  
  11.  ParsePatternNoCase("#?.otag", pattern, 14);
  12.  
  13.  if (fib->fib_DirEntryType < 0)
  14.   {
  15.    if (MatchPatternNoCase(pattern, fib->fib_FileName))
  16.     {
  17.      char *entry;
  18.      int   len;
  19.  
  20.      len = strlen(fib->fib_FileName)-5;
  21.  
  22.      if (entry = LibAllocPooled(mem_pool, len+1))
  23.       {
  24.        fib->fib_FileName[len] = '\0';
  25.        strcpy(entry, fib->fib_FileName);
  26.        return entry;
  27.       }
  28.     }
  29.   }
  30.  
  31.  return NULL;
  32. }
  33.  
  34. struct Hook ConFontHook =
  35. {
  36.  {
  37.   NULL, NULL
  38.  },
  39.  (void *)ConFont,
  40.  NULL, NULL
  41. };
  42.  
  43. /* Deconstruct FontListView Entry */
  44. static __saveds __asm void DesFont(register __a0 struct Hook *hook,
  45.                    register __a2 APTR         mem_pool,
  46.                    register __a1 char        *line)
  47. {
  48.  LibFreePooled(mem_pool, line, strlen(line)+1);
  49. }
  50.  
  51. struct Hook DesFontHook =
  52. {
  53.  {
  54.   NULL, NULL
  55.  },
  56.  (void *)DesFont,
  57.  NULL, NULL,
  58. };
  59.  
  60. static __saveds __asm void RexxCommandFunc(register __a0 struct Hook *hook,
  61.                        register __a2 APTR         object,
  62.                        register __a1 APTR         param[])
  63. {
  64.  SendRexxMsg(param[0]);
  65. }
  66.  
  67. struct Hook RexxCommandHook =
  68. {
  69.  {
  70.   NULL, NULL
  71.  },
  72.  (void *)RexxCommandFunc,
  73.  NULL, NULL
  74. };
  75.  
  76. static __saveds __asm void StringCommandFunc(register __a0 struct Hook *hook,
  77.                          register __a2 APTR         object)
  78. {
  79.  char *Command;
  80.  
  81.  get(object, MUIA_String_Contents, &Command);
  82.  SendRexxMsg(Command);
  83. }
  84.  
  85. struct Hook StringCommandHook =
  86. {
  87.  {
  88.   NULL, NULL
  89.  },
  90.  (void *)StringCommandFunc,
  91.  NULL, NULL
  92. };
  93.  
  94. static __saveds __asm void CheckFunc(register __a0 struct Hook *hook,
  95.                      register __a2 APTR         object,
  96.                      register __a1 APTR         param[])
  97. {
  98.  char  Command[255];
  99.  ULONG Selected;
  100.  
  101.  get(object, MUIA_Selected, &Selected);
  102.  sprintf(Command, param[0], Selected ? "" : "no");
  103.  SendRexxMsg(Command);
  104. }
  105.  
  106. struct Hook CheckHook =
  107. {
  108.  {
  109.   NULL, NULL,
  110.  },
  111.  (void *)CheckFunc,
  112.  NULL, NULL
  113. };
  114.  
  115. static __saveds __asm void RangeFunc(register __a0 struct Hook *hook,
  116.                      register __a2 APTR         object,
  117.                      register __a1 APTR         param[])
  118. {
  119.  struct RangeObject *ro; 
  120.  char               *s, *Buffer, Command[255];
  121.  double              min, max;
  122.  
  123.  ro = (struct RangeObject *)param[0];
  124.  s = (char *)param[1];
  125.  get(ro->Min, MUIA_String_Contents, &Buffer);
  126.  sscanf(Buffer, "%lg", &min);
  127.  get(ro->Max, MUIA_String_Contents, &Buffer);
  128.  sscanf(Buffer, "%lg", &max);
  129.  sprintf(Command, "set %s [%g:%g]", s, min, max);
  130.  SendRexxMsg(Command);
  131. }
  132.  
  133. struct Hook RangeHook =
  134. {
  135.  {
  136.   NULL, NULL
  137.  },
  138.  (void *)RangeFunc,
  139.  NULL, NULL
  140. };
  141.  
  142. static __saveds __asm void LogScaleFunc(register __a0 struct Hook *hook,
  143.                     register __a2 APTR         object,
  144.                     register __a1 APTR         param[])
  145. {
  146.  struct LogScaleObject *lco;
  147.  char                  *s, *Buffer, Command[255];
  148.  ULONG                  Selected;
  149.  
  150.  lco = (struct LogScaleObject *)param[0];
  151.  s = (char *)param[1];
  152.  get(lco->LogScale, MUIA_Selected, &Selected);
  153.  if (Selected)
  154.   {
  155.    get(lco->Base, MUIA_String_Contents, &Buffer);
  156.    sprintf(Command, s, "", Buffer);
  157.   }
  158.  else
  159.   sprintf(Command, s, "no", "");
  160.  
  161.  SendRexxMsg(Command);
  162. }
  163.  
  164. struct Hook LogScaleHook =
  165. {
  166.  {
  167.   NULL, NULL
  168.  },
  169.  (void *)LogScaleFunc,
  170.  NULL, NULL
  171. };
  172.  
  173. static __saveds __asm void StyleFunc(register __a0 struct Hook *hook,
  174.                      register __a2 APTR         object,
  175.                      register __a1 APTR         param[])
  176. {
  177.  char *s, Command[255];
  178.  ULONG ca;
  179.  
  180.  s = (char *)param[0];
  181.  get(object, MUIA_Cycle_Active, &ca);
  182.  sprintf(Command, s, StyleEntries[ca]);
  183.  
  184.  SendRexxMsg(Command);
  185. }
  186.  
  187. struct Hook StyleHook =
  188. {
  189.  {
  190.   NULL, NULL,
  191.  },
  192.  (void *)StyleFunc,
  193.  NULL, NULL
  194. };
  195.  
  196. static __saveds __asm void LabelFunc(register __a0 struct Hook *hook,
  197.                      register __a2 APTR         object,
  198.                      register __a1 APTR         param[])
  199. {
  200.  struct LabelObject *lo;
  201.  char               *Title, *Label, *XOff, *YOff, Command[255];
  202.  
  203.  lo = (struct LabelObject *)param[0];
  204.  Title = (char *)param[1];
  205.  get(lo->Label, MUIA_String_Contents, &Label);
  206.  get(lo->XOff, MUIA_String_Contents, &XOff);
  207.  get(lo->YOff, MUIA_String_Contents, &YOff);
  208.  sprintf(Command, "set %s \"%s\" %s,%s", Title, Label, XOff, YOff);
  209.  SendRexxMsg(Command);
  210. }
  211.  
  212. struct Hook LabelHook =
  213. {
  214.  {
  215.   NULL, NULL,
  216.  },
  217.  (void *)LabelFunc,
  218.  NULL, NULL
  219. };
  220.  
  221. static __saveds __asm void ViewFunc(register __a0 struct Hook *hook,
  222.                     register __a2 APTR         object,
  223.                     register __a1 APTR         param[])
  224. {
  225.  char *s, Command[255];
  226.  
  227.  get(object, MUIA_String_Contents, &s);
  228.  sprintf(Command, param[0], s);
  229.    
  230.  SendRexxMsg(Command);
  231. }
  232.  
  233. struct Hook ViewHook =
  234. {
  235.  {
  236.   NULL, NULL,
  237.  },
  238.  (void *)ViewFunc,
  239.  NULL, NULL
  240. };
  241.  
  242. /* Construct Entry for VarListView */ 
  243. static __saveds __asm char *ConVar(register __a0 struct Hook *hook,
  244.                         register __a2 APTR         mem_pool,
  245.                         register __a1 udvt_entry  *udvt)
  246. {
  247.  char *entry, Buffer[255];
  248.  int   len;
  249.  
  250.  switch(udvt->udv_value.type)
  251.   {
  252.   case INTGR:
  253.    len = sprintf(Buffer, "%s=%d", udvt->udv_name, udvt->udv_value.v.int_val);
  254.    break;
  255.   case CMPLX:
  256.    len = sprintf(Buffer, "%s={%f, %f}", udvt->udv_name,
  257.          udvt->udv_value.v.cmplx_val.real,
  258.          udvt->udv_value.v.cmplx_val.imag);
  259.    break;
  260.   }
  261.  entry = LibAllocPooled(mem_pool, len+1);
  262.  strcpy(entry, Buffer);
  263.  
  264.  return entry;
  265. }
  266.  
  267. struct Hook ConVarHook =
  268. {
  269.  {
  270.   NULL, NULL
  271.  },
  272.  (void *)ConVar,
  273.  NULL, NULL
  274. };
  275.  
  276. /* Deconstruct VarListView Entry */
  277. static __saveds __asm void DesVar(register __a0 struct Hook *hook,
  278.                   register __a2 APTR         mem_pool,
  279.                   register __a1 char        *entry)
  280. {
  281.  LibFreePooled(mem_pool, entry, strlen(entry)+1);
  282. }
  283.  
  284. struct Hook DesVarHook =
  285. {
  286.  {
  287.   NULL, NULL
  288.  },
  289.  (void *)DesVar,
  290.  NULL, NULL,
  291. };
  292.