home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / edu / DITOdev.lha / DITOdev / FastDict / FastDict.c next >
C/C++ Source or Header  |  1996-12-26  |  23KB  |  885 lines
  1. /*
  2.  *  FastDict © Dirk Holtwick, 1996
  3.  *
  4.  */
  5.  
  6. #define VERS "0.1 beta"
  7. #define NAME "FastDict"
  8.  
  9. /// DEBUG
  10. #define X printf("Zeile: %4d, Datei: '%s', Taste: ",__LINE__,__FILE__); gets(debugstr);
  11. #ifndef X
  12.     #define X
  13. #else
  14.     char  debugstr[80];
  15. #endif
  16. ///
  17. /// Includes
  18. #define DitoExtBase data->DitoExtBaseOO
  19.  
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <stdio.h>
  23.  
  24. #include <exec/memory.h>
  25. #include <prefs/prefhdr.h>
  26. #include <datatypes/pictureclass.h>
  27. #include <libraries/locale.h>
  28. #include <libraries/asl.h>
  29. #include <libraries/gadtools.h>
  30. #include <libraries/mui.h>
  31.  
  32. #include <clib/exec_protos.h>
  33. #include <clib/graphics_protos.h>
  34. #include <clib/intuition_protos.h>
  35. #include <clib/utility_protos.h>
  36. #include <clib/dos_protos.h>
  37. #include <clib/locale_protos.h>
  38. #include <clib/muimaster_protos.h>
  39.  
  40. #include <clib/alib_protos.h>
  41.  
  42. #include <pragmas/exec_pragmas.h>
  43. #include <pragmas/graphics_pragmas.h>
  44. #include <pragmas/intuition_pragmas.h>
  45. #include <pragmas/utility_pragmas.h>
  46. #include <pragmas/dos_pragmas.h>
  47. #include <pragmas/locale_pragmas.h>
  48. #include <pragmas/muimaster_pragmas.h>
  49.  
  50. #include <proto/dito.h>
  51. #include <proto/ditoext.h>
  52.  
  53. ///
  54. /// Compiler Stuff
  55. #ifdef _DCC
  56. #define REG(x) __ ## x
  57. #define ASM
  58. #define SAVEDS __geta4
  59. #else
  60. #define REG(x) register __ ## x
  61. #define ASM    __asm
  62. #define SAVEDS __saveds
  63. #endif
  64. ///
  65. /// Some Definitions
  66. #define MUISERIALNR_STUNTZI 1
  67. #define TAGBASE_STUNTZI (TAG_USER | ( MUISERIALNR_STUNTZI << 16))
  68.  
  69. #define MUIM_MainWindow_Finish        (TAGBASE_STUNTZI | 0x1070)
  70. #define MUIM_MainWindow_About         (TAGBASE_STUNTZI | 0x1071)
  71. #define MUIM_MainWindow_Open          (TAGBASE_STUNTZI | 0x1073)
  72. #define MUIM_MainWindow_Refresh       (TAGBASE_STUNTZI | 0x1074)
  73. #define MUIM_MainWindow_Grammar       (TAGBASE_STUNTZI | 0x1075)
  74. #define MUIM_MainWindow_Update        (TAGBASE_STUNTZI | 0x1076)
  75. #define MUIM_MainWindow_Iconify       (TAGBASE_STUNTZI | 0x1077)
  76. ///
  77. /// Global Vars
  78.  
  79. LONG __stack = 8192;
  80.  
  81. struct Library *DitoBase     ;
  82. struct Library *MUIMasterBase;
  83. struct Library *GfxBase      ;
  84. struct Library *IntuitionBase;
  85. struct Library *LocaleBase   ;
  86. struct Library *AslBase      ;
  87. struct Library *UtilityBase  ;
  88.  
  89. Object *win;
  90.  
  91. extern struct Library *DOSBase;
  92.  
  93. struct DITO_UserInfo    ui;
  94.  
  95. struct MUI_CustomClass *CL_MainWindow  ;
  96.  
  97. #define TG CHECKIT|MENUTOGGLE
  98.  
  99. enum { MEN_OPEN=1,MEN_ABOUT,MEN_QUIT,MEN_HIDE,MEN_MUI };
  100.  
  101. struct NewMenu MainMenu[] =
  102. {
  103.     { NM_TITLE, (STRPTR)"Project"                 , 0 ,0,0,(APTR)0             },
  104.     { NM_ITEM , (STRPTR)"Open"                    ,"O",0,0,(APTR)MEN_OPEN      },
  105.     { NM_ITEM , (STRPTR)NM_BARLABEL               , 0 ,0,0,(APTR)0             },
  106.     { NM_ITEM , (STRPTR)"About"                   ,"?",0,0,(APTR)MEN_ABOUT     },
  107.     { NM_ITEM , (STRPTR)NM_BARLABEL               , 0 ,0,0,(APTR)0             },
  108.     { NM_ITEM , (STRPTR)"Hide"                    ,"H",0,0,(APTR)MEN_HIDE      },
  109.     { NM_ITEM , (STRPTR)"Quit"                    ,"Q",0,0,(APTR)MEN_QUIT      },
  110.  
  111.     { NM_TITLE, (STRPTR)"Config"                  , 0 ,0,0,(APTR)0             },
  112.     { NM_ITEM , (STRPTR)"MUI"                     , 0 ,0,0,(APTR)MEN_MUI       },
  113.  
  114.     { NM_END,NULL,0,0,0,(APTR)0 },
  115. };
  116. ///
  117. /// Misc Help Functions
  118.  
  119. LONG xget(Object *obj,ULONG attribute)
  120. {
  121.     LONG x;
  122.     get(obj,attribute,&x);
  123.     return(x);
  124. }
  125.  
  126. char *getstr(Object *obj)
  127. {
  128.     return((char *)xget(obj,MUIA_String_Contents));
  129. }
  130.  
  131. BOOL getbool(Object *obj)
  132. {
  133.     return((BOOL)xget(obj,MUIA_Selected));
  134. }
  135.  
  136. VOID setstr(APTR str,LONG num)
  137. {
  138.     DoMethod(str,MUIM_SetAsString,MUIA_String_Contents,"%ld",num);
  139. }
  140.  
  141. VOID settxt(APTR str,LONG num)
  142. {
  143.     DoMethod(str,MUIM_SetAsString,MUIA_Text_Contents,"%ld",num);
  144. }
  145.  
  146. ULONG __stdargs DoSuperNew(struct IClass *cl,Object *obj,ULONG tag1,...)
  147. {
  148.     return(DoSuperMethod(cl,obj,OM_NEW,&tag1,NULL));
  149. }
  150.  
  151. Object *MakeCheck(char *s)
  152. {
  153.     Object *obj = MUI_MakeObject(MUIO_Checkmark,s);
  154.     if (obj) set(obj,MUIA_CycleChain,1);
  155.     return(obj);
  156. }
  157.  
  158. Object *MakeButton(char *s)
  159. {
  160.     Object *obj = MUI_MakeObject(MUIO_Button,s);
  161.     if (obj) set(obj,MUIA_CycleChain,1);
  162.     return(obj);
  163. }
  164.  
  165. /*
  166. Object *MakeBackground(int num)
  167. {
  168.     Object *obj;
  169.  
  170.     obj = MUI_NewObject(MUIC_Popimage,
  171.         MUIA_Imageadjust_Type, MUIV_Imageadjust_Type_Background,
  172.         MUIA_Window_Title, "Adjust Screen Background",
  173.         MUIA_CycleChain, 1,
  174.         TAG_DONE);
  175.  
  176.     return(obj);
  177. }
  178. */
  179.  
  180. Object *MakeString(int maxlen, char *s)
  181. {
  182.     Object *obj = MUI_MakeObject(MUIO_String,s,maxlen);
  183.  
  184.     if (obj)
  185.     {
  186.         SetAttrs(obj,
  187.             MUIA_CycleChain,1,
  188.             MUIA_String_AdvanceOnCR,TRUE,
  189.             TAG_DONE);
  190.     }
  191.  
  192.     return(obj);
  193. }
  194.  
  195. Object *MakeCycle(char **array,char *s)
  196. {
  197.     Object *obj = MUI_MakeObject(MUIO_Cycle ,s,array);
  198.     if (obj) set(obj,MUIA_CycleChain,1);
  199.     return(obj);
  200. }
  201.  
  202. Object *MakeSlider(int min,int max,char *s)
  203. {
  204.     Object *obj = MUI_MakeObject(MUIO_Slider,s,min,max);
  205.     if (obj) set(obj,MUIA_CycleChain,1);
  206.     return(obj);
  207. }
  208.  
  209. /*
  210. static Object *MakeCLabel(int num) { return(MUI_MakeObject(MUIO_Label,GetStr(num),MUIO_Label_Centered)); }
  211.  
  212. Object *MakeLabel    (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),0)); }
  213. Object *MakeLabel1   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_SingleFrame)); }
  214. Object *MakeLabel2   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_DoubleFrame)); }
  215. Object *MakeLLabel   (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_LeftAligned)); }
  216. Object *MakeLLabel1  (int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_LeftAligned|MUIO_Label_SingleFrame)); }
  217. Object *MakeFreeLabel(int num)  { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_FreeVert)); }
  218. Object *MakeFreeLLabel(int num) { return(MUI_MakeObject(MUIO_Label    ,GetStr(num),MUIO_Label_FreeVert|MUIO_Label_LeftAligned)); }
  219. */
  220. ///
  221.  
  222. // Mainwindow
  223.  
  224. /// struct MainWindow_Data
  225. struct MainWindow_Data
  226. {
  227.     struct DITO_Database    *db;
  228.     struct DITO_Dict        *dict;
  229.     struct DITO_OutputData  *output;
  230.  
  231.     struct Library *DitoExtBaseOO;
  232.  
  233.     Object   *str, *list, *balance, *grammar;
  234. };
  235. ///
  236. /// Display
  237. SAVEDS ASM void Display (REG(a2) char **array, REG(a1) struct DITO_Entry *act)
  238. {
  239.     *array++ = DITO_GetStr(act, DITO_Str_Word);
  240.     *array   = DITO_GetStr(act, DITO_Str_Translation);
  241. }
  242. ///
  243. /// InitSearch
  244. void InitSearch(struct MainWindow_Data *data)
  245. {
  246.     DoMethod (data->list, MUIM_List_Clear);
  247.     if(data->db) DITO_InitDatabase(data->db);
  248. }
  249. ///
  250. /// DisposeExt
  251. void DisposeExt(struct MainWindow_Data *data)
  252. {
  253.     if(data->output)
  254.     {
  255.         DITO_DisposeOutput(data->output);
  256.         data->output = 0;
  257.     }
  258.     if(DitoExtBase)
  259.     {
  260.         CloseLibrary(DitoExtBase);
  261.         DitoExtBase = 0;
  262.     }
  263. }
  264. ///
  265. /// MainWindow_Iconify
  266. ULONG MainWindow_Iconify(struct IClass *cl,Object *obj,struct Msg *msg)
  267. {
  268.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  269.  
  270.     set((Object *)xget(obj,MUIA_ApplicationObject),MUIA_Application_Iconified,TRUE);
  271.  
  272.     return(0);
  273. }
  274. ///
  275. /// MainWindow_Finish
  276. ULONG MainWindow_Finish(struct IClass *cl,Object *obj,struct Msg *msg)
  277. {
  278.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  279.  
  280. //   puts("MW_Finish");
  281. /*
  282.     {
  283.         ULONG i;
  284.  
  285.         DITO_LoadDictData (data->db, data->dict, "vaca", 0);
  286.  
  287.         for(i=0;i<data->db->sum;i++)
  288.         {
  289.             puts(
  290.                 DITO_GetStr( DITO_GetPtr(data->db, i), DITO_Str_Word)
  291.             );
  292.         }
  293.     }
  294. */
  295.     if(data->db) DITO_DisposeDatabase(data->db);
  296.     if(data->dict) DITO_CloseDict(data->dict);
  297.     DisposeExt(data);
  298.  
  299.     DoMethod((Object *)xget(obj,MUIA_ApplicationObject),MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  300.  
  301.     return(0);
  302. }
  303. ///
  304. /// MainWindow_Refresh
  305. ULONG MainWindow_Refresh(struct IClass *cl,Object *obj,struct {ULONG MethodID; char *s;} *msg)
  306. {
  307.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  308.     Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  309.     char  *str;
  310.  
  311.     if(msg->s)
  312.     {
  313.         set(data->str, MUIA_String_Contents, msg->s);
  314.     }
  315. //   else
  316.     {
  317.         set(data->str, MUIA_Disabled, TRUE);
  318.  
  319.         set(app,MUIA_Application_Sleep,TRUE);
  320.         get(data->str, MUIA_String_Contents, &str);
  321.  
  322.         set (data->list, MUIA_List_Quiet, TRUE);
  323.         InitSearch(data);
  324.  
  325.         if(data->dict && *str)
  326.         {
  327.             DITO_LoadDictData (data->db, data->dict, str, DITO_Cmp_First);
  328.  
  329.             if(data->db->sum)
  330.             {
  331.                 DoMethod (
  332.                     data->list,
  333.                     MUIM_List_Insert,
  334.                     data->db->arr.entries,              // Table of found entries
  335.                     data->db->sum,                      // Number of entries
  336.                     MUIV_List_Insert_Bottom
  337.                 );
  338.             }
  339.         }
  340.  
  341.         set (data->list, MUIA_List_Quiet, FALSE);
  342.  
  343.         set(app,MUIA_Application_Sleep,FALSE);
  344.  
  345.         set (data->str, MUIA_Disabled, FALSE);
  346.         set (obj, MUIA_Window_ActiveObject, data->str);
  347.     }
  348.     return(0);
  349. }
  350. ///
  351. /// MainWindow_Grammar
  352. ULONG MainWindow_Grammar(struct IClass *cl,Object *obj,struct Msg *msg)
  353. {
  354.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  355.     struct DITO_Entry  *v;
  356.  
  357. //   Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  358.  
  359.  
  360.     DoMethod (data->list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &v);
  361.     if(v){
  362.         set(data->grammar, MUIA_Disabled, FALSE);
  363.  
  364. //      if(!data->master){
  365.             DITO_WriteOutput (data->output, v);
  366.             DoMethod(obj, MUIM_MainWindow_Update, 0);
  367. //      }
  368.  
  369.     }else{
  370.         set(data->grammar, MUIA_Disabled, TRUE);
  371.     }
  372.  
  373.  
  374.     return(0);
  375. }
  376. ///
  377. /// MainWindow_Update
  378. ULONG MainWindow_Update(struct IClass *cl,Object *obj,struct Msg *msg)
  379. {
  380.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  381.     struct DITO_Entry  *v;
  382.  
  383. //   if(!data->master){
  384. //      set(app,MUIA_Application_Sleep,TRUE);
  385.         DoMethod (data->list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &v);
  386.         if(v){
  387.             DITO_UpdateOutput(data->output, v);
  388.         }
  389. //      get(listview, MUIA_Listview_ClickColumn, &col);
  390. //      set(app,MUIA_Application_Sleep,FALSE);
  391. //   }
  392.     return(0);
  393. }
  394. ///
  395. /// MainWindow_About
  396. ULONG MainWindow_About(struct IClass *cl,Object *obj,Msg msg)
  397. {
  398.     char  userstr[200];
  399.     Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  400.     static const char AboutText[] = "\33b\33c" NAME "\33n\n\33cVersion %s\n\33c%s\n\n\033c%s\n\n\33c\33i %s \33n\n\n\33cARexx-Port: %s";
  401.  
  402. //   struct MainWindow_Data *data = INST_DATA(cl,obj);
  403.     if(ui.nr) sprintf(userstr,"Registered for %s, #%u",ui.name,ui.nr);
  404.     else strcpy(userstr,"!!! UNREGISTERED VERSION !!!");
  405.  
  406.     MUI_Request(app,obj,0,NULL,"*_OK",(char *)AboutText,
  407.         ((char *)xget(app,MUIA_Application_Version))+7+strlen(NAME),
  408.         ((char *)xget(app,MUIA_Application_Copyright)),
  409.         userstr,
  410.         ((char *)xget(app,MUIA_Application_Description)),
  411.         ((char *)xget(app,MUIA_Application_Base)));
  412.     return(0);
  413. }
  414. ///
  415. /// IntuiMsgFunc
  416. SAVEDS ASM VOID IntuiMsgFunc(REG(a1) struct IntuiMessage *imsg,REG(a2) struct FileRequester *req)
  417. {
  418.     if (imsg->Class==IDCMP_REFRESHWINDOW)
  419.         DoMethod(req->fr_UserData,MUIM_Application_CheckRefresh);
  420. }
  421. ///
  422. /// getfilename
  423. char *getfilename(char *title,BOOL save)
  424. {
  425.     static char buf[512];
  426.     struct FileRequester *req;
  427.     struct Window *w;
  428.     static LONG left=-1,top=-1,width=-1,height=-1;
  429.     Object *app = (Object *)xget(win,MUIA_ApplicationObject);
  430.     char *res = NULL;
  431.     static const struct Hook IntuiMsgHook = { { 0,0 },(VOID *)IntuiMsgFunc,NULL,NULL };
  432.  
  433.     get(win,MUIA_Window_Window,&w);
  434.     if (left==-1)
  435.     {
  436.         left   = w->LeftEdge+w->BorderLeft+2;
  437.         top    = w->TopEdge+w->BorderTop+2;
  438.         width  = w->Width-w->BorderLeft-w->BorderRight-4;
  439.         height = w->Height-w->BorderTop-w->BorderBottom-4;
  440.     }
  441.  
  442.     if (req=MUI_AllocAslRequestTags(ASL_FileRequest,
  443.         ASLFR_Window, w,
  444.         ASLFR_TitleText, title,
  445.         ASLFR_InitialLeftEdge, left,
  446.         ASLFR_InitialTopEdge , top,
  447.         ASLFR_InitialWidth   , width,
  448.         ASLFR_InitialHeight  , height,
  449.         ASLFR_InitialDrawer  , "DITO:Dict",
  450.         ASLFR_InitialPattern , "#?.dict",
  451.         ASLFR_DoSaveMode     , save,
  452.         ASLFR_DoPatterns     , TRUE,
  453.         ASLFR_RejectIcons    , TRUE,
  454.         ASLFR_UserData       , app,
  455.         ASLFR_IntuiMsgFunc   , &IntuiMsgHook,
  456.         TAG_DONE))
  457.     {
  458.         set(app,MUIA_Application_Sleep,TRUE);
  459.         if (MUI_AslRequestTags(req,TAG_DONE))
  460.         {
  461.             if (*req->fr_File)
  462.             {
  463.                 res = buf;
  464.                 stccpy(buf,req->fr_Drawer,sizeof(buf));
  465.                 AddPart(buf,req->fr_File,sizeof(buf));
  466.             }
  467.             left   = req->fr_LeftEdge;
  468.             top    = req->fr_TopEdge;
  469.             width  = req->fr_Width;
  470.             height = req->fr_Height;
  471.         }
  472.         MUI_FreeAslRequest(req);
  473.         set(app,MUIA_Application_Sleep,FALSE);
  474.     }
  475.     return(res);
  476. }
  477. ///
  478. /// MainWindow_Open
  479. ULONG MainWindow_Open(struct IClass *cl,Object *obj,struct {ULONG MethodID; char *name;} *msg)
  480. {
  481.     struct MainWindow_Data *data = INST_DATA(cl,obj);
  482.     Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  483.     char *name;
  484.  
  485.     if(msg->name)
  486.     {
  487.         name = msg->name;
  488.     }
  489.     else
  490.     {
  491.         name = getfilename("Select Dictionary",FALSE);
  492.     }
  493.  
  494.     if(name)
  495.     {
  496.         set(obj, MUIA_Window_Open, FALSE);
  497.  
  498.         InitSearch(data);
  499.         if(data->dict) DITO_CloseDict(data->dict);
  500.         if(data->dict = DITO_OpenDict(name))
  501.         {
  502.             struct DITO_FileInfo fi;
  503.  
  504.             if(data->output)
  505.             {
  506.                 DoMethod (data->grammar, OM_REMMEMBER, data->output->obj);
  507.                 MUI_DisposeObject(data->output->obj);
  508.             }
  509.             DisposeExt(data);
  510.  
  511.             DITO_GetFileInfo(&fi,name);
  512.             {
  513.                 char lib[200];
  514.  
  515.                 sprintf(lib, "PROGDIR:Ext/%s.dito", fi.Language);
  516.  
  517.                 if(DitoExtBase = OpenLibrary(lib,0))
  518.                 {
  519.                     if(data->output = DITO_CreateOutput(app))
  520.                     {
  521.                         DoMethod (data->grammar, OM_ADDMEMBER, data->output->obj);
  522.                     }
  523.                     else puts("Couldn't open DITO output extension");
  524.                 }
  525.                 else puts("ditoext.library");
  526.             }
  527.         }
  528.  
  529.         set(data->str,     MUIA_String_Contents, "");
  530.         set(data->grammar, MUIA_Disabled, TRUE);
  531.         set(data->grammar, MUIA_ShowMe, TRUE);
  532.         set(data->balance, MUIA_ShowMe, TRUE);
  533.  
  534.         set(obj, MUIA_Window_Open, TRUE);
  535.     }
  536.  
  537.     return(0);
  538. }
  539. ///
  540. /// MainWindow_New
  541. ULONG MainWindow_New(struct IClass *cl,Object *obj,struct opSet *msg)
  542. {
  543.     Object *strip;
  544.     struct MainWindow_Data tmp = {0};
  545.     static const struct Hook DisplayHook   = { { NULL,NULL },(VOID *)Display  ,NULL,NULL };
  546.  
  547.     if (obj = (Object *)DoSuperNew(cl,obj,
  548.             MUIA_Window_Title, NAME " " VERS,
  549.             MUIA_Window_ID   , MAKE_ID('M','A','I','N'),
  550.             MUIA_Window_Menustrip, strip = MUI_MakeObject(MUIO_MenustripNM,MainMenu,0),
  551.             WindowContents, VGroup,
  552.                 Child, HGroup,
  553.                     Child, tmp.list = ListviewObject,
  554.                         MUIA_CycleChain,           1,
  555.                         MUIA_Listview_DoubleClick, TRUE,
  556.                         MUIA_Listview_Input,       TRUE,
  557.                         MUIA_Listview_List,        ListObject,
  558.                             MUIA_Frame,             MUIV_Frame_InputList,
  559.                             MUIA_List_Format,       "miw=50 maw=50 p=\033b, miw=50",
  560.                             MUIA_List_DisplayHook,  &DisplayHook,
  561.                             End,
  562.                         End,
  563.                     Child, tmp.balance = BalanceObject,
  564.                         MUIA_ShowMe, FALSE,
  565.                         End,
  566.                     Child, tmp.grammar = VGroup,
  567.                         MUIA_ShowMe, FALSE,
  568.                         End,
  569.                     End,
  570.                 Child, tmp.str = StringObject,
  571.                     MUIA_CycleChain, 1,
  572.                     MUIA_String_MaxLen, 255,
  573.                     MUIA_ControlChar, ' ',
  574.                     MUIA_Frame, MUIV_Frame_String,
  575.                     MUIA_ShortHelp, "AMIGA + SPACE",
  576.                     End,
  577.                 End,
  578.             TAG_MORE,msg->ops_AttrList))
  579.     {
  580.         struct MainWindow_Data *data = INST_DATA(cl,obj);
  581.         Object *app = (Object *)xget(obj,MUIA_ApplicationObject);
  582.  
  583.         DoMethod(obj      ,MUIM_Notify,MUIA_Window_CloseRequest,TRUE ,obj,1,MUIM_MainWindow_Iconify);
  584.  
  585.         DoMethod(tmp.str,  MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,obj,2,MUIM_MainWindow_Refresh, 0);
  586.         DoMethod(tmp.list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, obj,1,MUIM_MainWindow_Grammar);
  587.  
  588. //    DoMethod(app,      MUIM_Notify, MUIA_Application_ReturnID, 1,obj,1,MUIM_MainWindow_Update);
  589.  
  590.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_ABOUT    ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,1,MUIM_MainWindow_About);
  591.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_OPEN     ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Open,0);
  592.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_HIDE     ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,1,MUIM_MainWindow_Iconify);
  593.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_QUIT     ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,obj,2,MUIM_MainWindow_Finish,0);
  594.  
  595.         DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MEN_MUI      ),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,MUIV_Notify_Application,2,MUIM_Application_OpenConfigWindow,0);
  596.  
  597. /*
  598.         set(BT_Save  ,MUIA_ShortHelp,GetStr(MSG_HELP_SAVE  ));
  599.         set(BT_Use   ,MUIA_ShortHelp,GetStr(MSG_HELP_USE   ));
  600.         set(BT_Cancel,MUIA_ShortHelp,GetStr(MSG_HELP_CANCEL));
  601. */
  602.  
  603.         set(obj,     MUIA_Window_ActiveObject,  tmp.str);
  604.         set(obj,     MUIA_Window_DefaultObject, tmp.str);
  605.         set(tmp.str, MUIA_String_AttachedList,  tmp.list);
  606.  
  607.         tmp.db = DITO_CreateDatabase();
  608.         tmp.dict = 0;
  609.         tmp.DitoExtBaseOO = 0;
  610.         tmp.output = 0;
  611.  
  612.         *data = tmp;
  613.  
  614.         return((ULONG)obj);
  615.     }
  616.     return(0);
  617. }
  618. ///
  619. /// MainWindow_Dispatcher
  620. SAVEDS ASM ULONG MainWindow_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  621. {
  622.     switch (msg->MethodID)
  623.     {
  624.         case OM_NEW                 : return(MainWindow_New    (cl,obj,(APTR)msg));
  625.         case MUIM_MainWindow_Finish : return(MainWindow_Finish (cl,obj,(APTR)msg));
  626.         case MUIM_MainWindow_Iconify: return(MainWindow_Iconify(cl,obj,(APTR)msg));
  627.         case MUIM_MainWindow_About  : return(MainWindow_About  (cl,obj,(APTR)msg));
  628.         case MUIM_MainWindow_Open   : return(MainWindow_Open   (cl,obj,(APTR)msg));
  629.         case MUIM_MainWindow_Refresh: return(MainWindow_Refresh(cl,obj,(APTR)msg));
  630.         case MUIM_MainWindow_Grammar: return(MainWindow_Grammar(cl,obj,(APTR)msg));
  631.         case MUIM_MainWindow_Update : return(MainWindow_Update (cl,obj,(APTR)msg));
  632.     }
  633.     return(DoSuperMethodA(cl,obj,msg));
  634. }
  635.  
  636. ///
  637.  
  638. // ARexx
  639.  
  640. /// Rexx_Query
  641. SAVEDS ASM LONG Rexx_Query (REG(a1) struct {char *word; } *msg)
  642. {
  643.     DoMethod(win, MUIM_MainWindow_Refresh, msg->word);
  644.     return(0);
  645. }
  646. ///
  647. /// Rexx_File
  648. SAVEDS ASM LONG Rexx_File (REG(a1) struct {char *name; LONG lang; } *msg)
  649. {
  650.     DoMethod(win, MUIM_MainWindow_Open, msg->name);
  651.     return(0);
  652. }
  653. ///
  654.  
  655. // Init
  656.  
  657. /// ExitLibs
  658. VOID ExitLibs(VOID)
  659. {
  660.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  661.     if (GfxBase      ) CloseLibrary(GfxBase      );
  662.     if (AslBase      ) CloseLibrary(AslBase      );
  663.     if (UtilityBase  ) CloseLibrary(UtilityBase  );
  664.     if (MUIMasterBase) CloseLibrary(MUIMasterBase);
  665.     if (DitoBase)      CloseLibrary(DitoBase);
  666. }
  667. ///
  668. /// InitLibs
  669. BOOL InitLibs(VOID)
  670. {
  671.     DitoBase      = OpenLibrary(DITO_NAME, DITO_VMIN);
  672.     MUIMasterBase = OpenLibrary("muimaster.library",11);
  673.     UtilityBase   = OpenLibrary("utility.library"  ,36);
  674.     AslBase       = OpenLibrary("asl.library"      ,36);
  675.     GfxBase       = OpenLibrary("graphics.library" ,36);
  676.     IntuitionBase = OpenLibrary("intuition.library",36);
  677.  
  678.     if (DitoBase && MUIMasterBase && UtilityBase && AslBase && GfxBase && IntuitionBase)
  679.         return(TRUE);
  680.  
  681.     ExitLibs();
  682.     return(FALSE);
  683. }
  684. ///
  685. /// ExitClasses
  686. VOID ExitClasses(VOID)
  687. {
  688.     if (CL_MainWindow  ) MUI_DeleteCustomClass(CL_MainWindow  );
  689. }
  690. ///
  691. /// InitClasses
  692. BOOL InitClasses(VOID)
  693. {
  694.     CL_MainWindow   = MUI_CreateCustomClass(NULL,MUIC_Window    ,NULL,sizeof(struct MainWindow_Data  ),MainWindow_Dispatcher  );
  695.  
  696.     if (CL_MainWindow)
  697.         return(TRUE);
  698.  
  699.     ExitClasses();
  700.     return(FALSE);
  701. }
  702. ///
  703. /// HandleArgs
  704. /*
  705. const char CLITemplate[] = "NAME,LANGUAGE=L/S,DEFAULT=D/S";
  706.  
  707. const char CLIHelp[] = "\
  708. \n\
  709. Usage: FastDict <name> LANGUAGE DEFAULT\n\
  710.  <name>   : name of file or language\n\
  711.  LANGUAGE : understand <name> as language\n\
  712. ";
  713.  
  714. LONG HandleArgs(Object *mainwin)
  715. {
  716.     struct RDArgs *rda,*rdas;
  717.     LONG msg = 0;
  718.  
  719.     struct CLIArgs
  720.     {
  721.         char *Name;
  722.         LONG Language;
  723.         LONG Default;
  724.     } argarray = { 0,0 };
  725.  
  726.     if (rdas = AllocDosObject(DOS_RDARGS,NULL))
  727.     {
  728.         rdas->RDA_ExtHelp = (char *)CLIHelp;
  729.  
  730.         if (rda = ReadArgs((char *)CLITemplate,(LONG *)&argarray,rdas))
  731.         {
  732.             if(argarray.Default)
  733.             {
  734.                 DoMethod(mainwin,MUIM_MainWindow_Open,"PROGDIR:Dict/Default.dict");
  735.             }
  736.             if (argarray.Name)
  737.             {
  738.                 DoMethod(mainwin,MUIM_MainWindow_Open,argarray.Name);
  739.  
  740.                 if (argarray.Language)
  741.                 {
  742. */
  743. /*               if (!desc)
  744.                         msg = MSG_CLI_SCREENNOTFOUND;
  745.                     else if (MUIS_OpenPubScreen(desc))
  746.                         msg = MSG_CLI_SCREENOPENED;
  747.                     else
  748.                         msg = MSG_CLI_SCREENOPENFAILED;
  749. */
  750. /*            }
  751.             }
  752.             FreeArgs(rda);
  753.         }
  754.         FreeDosObject(DOS_RDARGS,rdas);
  755.     }
  756.     return(msg);
  757. }
  758. */
  759. ///
  760.  
  761. // Main
  762.  
  763. /// Main Program
  764.  
  765. int main(int argc,char *argv[])
  766. //void __stdargs __main(char *comline)
  767. {
  768. //   extern struct WBStartup *_WBenchMsg;
  769.     ULONG sigs=0, id;
  770.     Object *app;
  771.     int res;
  772.     int msg=0;
  773.  
  774.     static const struct Hook Rexx_QueryHook   = { { NULL,NULL },(VOID *)Rexx_Query  ,NULL,NULL };
  775.     static const struct Hook Rexx_FileHook    = { { NULL,NULL },(VOID *)Rexx_File   ,NULL,NULL };
  776.  
  777.     static struct MUI_Command commands[] =
  778.     {
  779.         { "search"    ,"word/a"              , 1        , (void *)&Rexx_QueryHook },
  780.         { "file"      ,"name/a,language/s"   , 2        , (void *)&Rexx_FileHook  },
  781.         { NULL        , NULL                 , NULL     , NULL     }
  782.     };
  783.  
  784. //   InitLocale();
  785.  
  786.  
  787.     if (InitLibs())
  788.     {
  789.  
  790.         DITO_GetUserInfo(&ui);
  791.  
  792.         if (InitClasses())
  793.         {
  794.  
  795.             app = ApplicationObject,
  796.                 MUIA_Application_Title      , NAME,
  797.                 MUIA_Application_Version    , "$VER: " NAME" " VERS " " __AMIGADATE__,
  798.                 MUIA_Application_Copyright  , "© Dirk Holtwick, 1996",
  799.                 MUIA_Application_Author     , "Dirk Holtwick",
  800.                 MUIA_Application_Description, "Fast Dictionary Tool for DITO Databases",
  801.                 MUIA_Application_Base       , "FASTDICT",
  802.                 MUIA_Application_SingleTask , TRUE,
  803.                 MUIA_Application_Commands   , commands,
  804.                 MUIA_Application_Window     , win = NewObject(CL_MainWindow->mcc_Class,NULL,TAG_DONE),
  805.                 End;
  806.  
  807.             if (app)
  808.             {
  809.  
  810. /*
  811.                 if (_WBenchMsg)
  812.                     msg = 0;
  813.                 else
  814.                     msg = HandleArgs(win);
  815.  
  816. */
  817.                 if(argc==2)
  818.                 {
  819.                     puts(argv[1]);
  820.                     DoMethod(win, MUIM_MainWindow_Open, argv[1]);
  821.                 }
  822.  
  823. /*
  824.                 if (!msg)
  825.                 {
  826. */
  827.                     set(win,MUIA_Window_Open,TRUE);
  828.  
  829.                     while ((id = DoMethod(app,MUIM_Application_NewInput,&sigs)) != MUIV_Application_ReturnID_Quit)
  830.                     {
  831.  
  832.                         if(id==1) DoMethod(win, MUIM_MainWindow_Update, 0);
  833.  
  834.                         if (sigs)
  835.                         {
  836.                             sigs = Wait(sigs | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F);
  837.  
  838.                             /* quit when receiving break from console */
  839.                             if (sigs & SIGBREAKF_CTRL_C)
  840.                                 break;
  841.  
  842.                             /* update listview whenever a screen was opened/closed */
  843. //                     if (sigs & SIGBREAKF_CTRL_E)
  844. //                        DoMethod(win,MUIM_Panel_Update);
  845.  
  846.                             /* deiconify & activate on ctrl-f just like the other prefs programs */
  847.                             if (sigs & SIGBREAKF_CTRL_F)
  848.                             {
  849.                                 set(app,MUIA_Application_Iconified,FALSE);
  850.                                 set(win,MUIA_Window_Open,TRUE);
  851.                             }
  852.                         }
  853.                     }
  854.  
  855. //             DoMethod(win,MUIM_Panel_CloseWindows);
  856.                     set(win,MUIA_Window_Open,FALSE);
  857.                 }
  858.                 MUI_DisposeObject(app);
  859. //         }
  860. //         else msg = MSG_CLI_NOAPPLICATION;
  861.             ExitClasses();
  862.         }
  863. //      else msg = MSG_CLI_OUTOFMEMORY;
  864.         ExitLibs();
  865.     }
  866. //   else msg = MSG_CLI_NOMUIMASTER;
  867.  
  868.     if (msg)
  869.     {
  870. /*      char *str = GetStr(msg);
  871.         char *c = strchr(str,'(');
  872.         Write(Output(),str,strlen(str));
  873.         res = c ? atol(c+1) : RETURN_OK;
  874. */
  875.         res = RETURN_OK;
  876.     }
  877.     else
  878.         res = RETURN_OK;
  879.  
  880. //   ExitLocale();
  881.     exit(res);
  882. }
  883. ///
  884.  
  885.