home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / edu / DITOdev.lha / DITOdev / Extensions / Source / Latinum / Funcs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-23  |  14.3 KB  |  563 lines
  1. /*
  2. **  latinum.dito 2.0
  3. **  (C) Dirk Holtwick, 1996
  4. */
  5.  
  6. /// HEADER
  7. #define LOC(a)    GetDITO_latinumString(m_ ## a)
  8. #define OPENCAT   OpenDITO_latinumCatalog(NULL,NULL)
  9. #define CLOSECAT  CloseDITO_latinumCatalog()
  10.  
  11. #define IPIC0 "\033I[6:38]"
  12. #define IPIC1 "\033I[6:34]"
  13. #define IPIC2 "\033I[6:39]"
  14.  
  15. struct DITO_InputData {
  16.     Object
  17.         *obj,                      // First pointer has to be the pointer
  18.                                             // to the whole created object
  19.         *remark,                   // String
  20.         *genitiv,                  // String
  21.         *genus,                    // String
  22.         *adj0,                     // String
  23.         *adj1,                     // String
  24.         *adj2,                     // String
  25.         *verb0,                    // String
  26.         *verb1,                    // String
  27.         *verb2;                    // String
  28. };
  29.  
  30. struct DITO_OutputData {
  31.     Object
  32.         *obj,                      // First Pointer points to created object
  33.  
  34.         *kind,                     // Text
  35.         *info,                     // Floattext
  36.         *grammar,                  // Group
  37.         *weight,                   // Text
  38.         *text1,                    // Text
  39.         *text2;                    // Text
  40. };
  41. ///
  42.  
  43. /// DITO_GetExtInfo
  44. char  *Types[5];
  45.  
  46. SAVEDS ASM struct DITO_ExtInfo *DITO_GetExtInfo(void)
  47. {
  48.     static struct DITO_ExtInfo info;
  49.  
  50.     Types[0] = LOC(part0);
  51.     Types[1] = LOC(part1);
  52.     Types[2] = LOC(part2);
  53.     Types[3] = LOC(part3);
  54.  
  55.     info.Language    = LOC(language);
  56.     info.Author      = AUTHOR;
  57.     info.Version     = VERSIONSTR;
  58.     info.Date        = __DATE__;
  59.     info.Description = LOC(description);
  60.  
  61.     info.NumTypes    = 4;
  62.     info.Types       = Types;
  63.  
  64.     return(&info);
  65. }
  66. ///
  67.  
  68. /// DITO_CreateInput
  69. SAVEDS ASM struct DITO_InputData *DITO_CreateInput(REG(a0) Object *app)
  70. {
  71.     struct   DITO_InputData *data;
  72.     static char *strtab[5], *gentab[5];
  73.  
  74.     strtab[0] = LOC(part0);
  75.     strtab[1] = LOC(part1);
  76.     strtab[2] = LOC(part2);
  77.     strtab[3] = LOC(part3);
  78.     strtab[4] = 0;
  79.  
  80.     gentab[0] = LOC(gen0);
  81.     gentab[1] = LOC(gen1);
  82.     gentab[2] = LOC(gen2);
  83.     gentab[3] = "Commune"; //LOC(gen3);
  84.     gentab[4] = 0;
  85.  
  86.     if(data = AllocVec(sizeof(struct DITO_InputData),0)){
  87.  
  88.         data->obj = RegisterObject,
  89.  
  90.             MUIA_CycleChain, 1,
  91.             MUIA_ShortHelp, "AMIGA + t",
  92.             MUIA_Register_Titles, strtab,
  93.             MUIA_Frame, MUIV_Frame_Group,
  94.  
  95.             // Übriges
  96.             // *******
  97.             Child, VGroup,
  98.                 Child, LLabel(LOC(remark)),
  99.                 Child, data->remark = StringObject,
  100.                     MUIA_CycleChain, 1,
  101.                     MUIA_Frame, MUIV_Frame_String,
  102.                     MUIA_String_Format, MUIV_String_Format_Center,
  103.                     MUIA_String_AdvanceOnCR, TRUE,
  104.                     End,
  105.                 End,
  106.  
  107.             // Substantiv
  108.             // **********
  109.             Child, HGroup,
  110.                 Child, VGroup,
  111.                     Child, LLabel(LOC(genitiv)),
  112.                     Child, data->genitiv = StringObject,
  113.                         MUIA_CycleChain, 1,
  114.                         MUIA_Frame, MUIV_Frame_String,
  115.                         MUIA_String_Format, MUIV_String_Format_Center,
  116.                         MUIA_String_AdvanceOnCR, TRUE,
  117.                         End,
  118.                     End,
  119.                 Child, data->genus = RadioObject,
  120.                     MUIA_CycleChain, 1,
  121.                     NoFrame,
  122.                     MUIA_ControlChar, 'g',
  123.                     MUIA_ShortHelp, "AMIGA + g",
  124.                     MUIA_Radio_Entries, gentab,
  125.                     End,
  126.                 End,
  127.  
  128.             // Adjektiv
  129.             // ********
  130.             Child, ColGroup(3),
  131.                 Child, LLabel(LOC(adj0)),
  132.                 Child, LLabel(LOC(adj1)),
  133.                 Child, LLabel(LOC(adj2)),
  134.                 Child, data->adj0 = StringObject,
  135.                     MUIA_CycleChain, 1,
  136.                     MUIA_Frame, MUIV_Frame_String,
  137.                     MUIA_String_Format, MUIV_String_Format_Center,
  138.                     MUIA_String_AdvanceOnCR, TRUE,
  139.                     End,
  140.                 Child, data->adj1 = StringObject,
  141.                     MUIA_CycleChain, 1,
  142.                     MUIA_Frame, MUIV_Frame_String,
  143.                     MUIA_String_Format, MUIV_String_Format_Center,
  144.                     MUIA_String_AdvanceOnCR, TRUE,
  145.                     End,
  146.                 Child, data->adj2 = StringObject,
  147.                     MUIA_CycleChain, 1,
  148.                     MUIA_Frame, MUIV_Frame_String,
  149.                     MUIA_String_Format, MUIV_String_Format_Center,
  150.                     MUIA_String_AdvanceOnCR, TRUE,
  151.                     End,
  152.                 End,
  153.  
  154.             // Verb
  155.             // ****
  156.             Child, ColGroup(3),
  157.                 Child, LLabel(LOC(verb0)),
  158.                 Child, LLabel(LOC(verb1)),
  159.                 Child, LLabel(LOC(verb2)),
  160.                 Child, data->verb0 = StringObject,
  161.                     MUIA_CycleChain, 1,
  162.                     MUIA_Frame, MUIV_Frame_String,
  163.                     MUIA_String_Format, MUIV_String_Format_Center,
  164.                     MUIA_String_AdvanceOnCR, TRUE,
  165.                     End,
  166.                 Child, data->verb1 = StringObject,
  167.                     MUIA_CycleChain, 1,
  168.                     MUIA_Frame, MUIV_Frame_String,
  169.                     MUIA_String_Format, MUIV_String_Format_Center,
  170.                     MUIA_String_AdvanceOnCR, TRUE,
  171.                     End,
  172.                 Child, data->verb2 = StringObject,
  173.                     MUIA_CycleChain, 1,
  174.                     MUIA_Frame, MUIV_Frame_String,
  175.                     MUIA_String_Format, MUIV_String_Format_Center,
  176.                     MUIA_String_AdvanceOnCR, TRUE,
  177.                     End,
  178.                 End,
  179.             End;
  180.  
  181.           return(data);
  182.     }
  183.  
  184.     return(0);
  185. }
  186. ///
  187. /// DITO_DisposeInput
  188. SAVEDS ASM void DITO_DisposeInput(REG(a0) struct DITO_InputData *data)
  189. {
  190.     if(data) FreeVec(data);
  191. }
  192. ///
  193. /// DITO_ClearInput
  194. SAVEDS ASM void DITO_ClearInput(REG(a0) struct DITO_InputData *data)
  195. {
  196.     set(data->remark,  MUIA_String_Contents, "");
  197.     set(data->genitiv, MUIA_String_Contents, "");
  198.     set(data->adj0,    MUIA_String_Contents, "");
  199.     set(data->adj1,    MUIA_String_Contents, "");
  200.     set(data->adj2,    MUIA_String_Contents, "");
  201.     set(data->verb0,   MUIA_String_Contents, "");
  202.     set(data->verb1,   MUIA_String_Contents, "");
  203.     set(data->verb2,   MUIA_String_Contents, "");
  204.     set(data->genus,   MUIA_Radio_Active, 0);
  205. }
  206. ///
  207. /// DITO_WriteInput
  208. SAVEDS ASM void DITO_WriteInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_Entry *entry)
  209. {
  210.     set (data->obj, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));
  211.  
  212.     DITO_ClearInput (data);
  213.  
  214.     switch(DITO_GetVal (entry, DITO_Val_Type)){
  215.  
  216.         // Default
  217.         case 0:
  218.             set(data->remark, MUIA_String_Contents, DITO_GetStr(entry,0));
  219.             break;
  220.  
  221.         // Noun
  222.         case 1:
  223.             set(data->genitiv, MUIA_String_Contents, DITO_GetStr(entry,0));
  224.             set(data->genus,   MUIA_Radio_Active,    DITO_GetVal(entry,0));
  225.             break;
  226.  
  227.         // Adjective
  228.         case 2:
  229.             set(data->adj0, MUIA_String_Contents, DITO_GetStr(entry,0));
  230.             set(data->adj1, MUIA_String_Contents, DITO_GetStr(entry,1));
  231.             set(data->adj2, MUIA_String_Contents, DITO_GetStr(entry,2));
  232.             break;
  233.  
  234.         // Verb
  235.         case 3:
  236.             set(data->verb0, MUIA_String_Contents, DITO_GetStr(entry,0));
  237.             set(data->verb1, MUIA_String_Contents, DITO_GetStr(entry,1));
  238.             set(data->verb2, MUIA_String_Contents, DITO_GetStr(entry,2));
  239.             break;
  240.     }
  241. }
  242. ///
  243. /// DITO_ReadInput
  244. SAVEDS ASM BOOL DITO_ReadInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_EntryInfo *vi, REG(a2) struct DITO_Entry *entry)
  245. {
  246.     BOOL  changed = FALSE;
  247.  
  248.     get (data->obj, MUIA_Group_ActivePage, &vi->type);
  249.  
  250.     switch(vi->type){
  251.  
  252.         // Default
  253.         case 0:
  254.             vi->snum=1;
  255.             get (data->remark, MUIA_String_Contents, &vi->gr[0]);
  256.             if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  257.             break;
  258.  
  259.         // Noun
  260.         case 1:
  261.             vi->snum=1;
  262.             get (data->genitiv, MUIA_String_Contents, &vi->gr[0]);
  263.             get (data->genus,   MUIA_Radio_Active, &vi->val[0]);
  264.             if(entry){
  265.                 changed =
  266.                     strcmp(DITO_GetStr(entry,0), vi->gr[0])
  267.                 || (DITO_GetVal(entry, 0) != vi->val[0]);
  268.             }
  269.             break;
  270.  
  271.         // Adjective
  272.         case 2:
  273.             vi->snum=3;
  274.             get (data->adj0, MUIA_String_Contents, &vi->gr[0]);
  275.             get (data->adj1, MUIA_String_Contents, &vi->gr[1]);
  276.             get (data->adj2, MUIA_String_Contents, &vi->gr[2]);
  277.             if(entry){
  278.                 changed =
  279.                     strcmp(DITO_GetStr(entry,2), vi->gr[2])
  280.                 || strcmp(DITO_GetStr(entry,1), vi->gr[1])
  281.                 || strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  282.             }
  283.             break;
  284.  
  285.         // Verb
  286.         case 3:
  287.             vi->snum=3;
  288.             get (data->verb0, MUIA_String_Contents, &vi->gr[0]);
  289.             get (data->verb1, MUIA_String_Contents, &vi->gr[1]);
  290.             get (data->verb2, MUIA_String_Contents, &vi->gr[2]);
  291.             if(entry){
  292.                 changed =
  293.                     strcmp(DITO_GetStr(entry,2), vi->gr[2])
  294.                 || strcmp(DITO_GetStr(entry,1), vi->gr[1])
  295.                 || strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  296.             }
  297.             break;
  298.     }
  299.     return(changed);
  300. }
  301. ///
  302. /// DITO_ActivateFirstInput
  303. SAVEDS ASM Object *DITO_ActivateFirstInput(REG(a0) struct DITO_InputData *data)
  304. {
  305.     LONG  p;
  306.  
  307.     get (data->obj, MUIA_Group_ActivePage, &p);
  308.     switch(p){
  309.         case 0:  return(data->remark);
  310.         case 1:  return(data->genitiv);
  311.         case 2:  return(data->adj0);
  312.         case 3:  return(data->verb0);
  313.     }
  314. }
  315. ///
  316. /// DITO_FontsInput
  317. SAVEDS ASM void DITO_FontsInput(REG(a0) struct DITO_InputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon)
  318. {
  319.     set(data->remark,       MUIA_Font, word);
  320.     set(data->genitiv,      MUIA_Font, word);
  321.     set(data->verb0,        MUIA_Font, word);
  322.     set(data->verb1,        MUIA_Font, word);
  323.     set(data->verb2,        MUIA_Font, word);
  324.     set(data->adj0,         MUIA_Font, word);
  325.     set(data->adj1,         MUIA_Font, word);
  326.     set(data->adj2,         MUIA_Font, word);
  327. }
  328. ///
  329. /// DITO_UpdateInput
  330. SAVEDS ASM void DITO_UpdateInput(REG(a0) struct DITO_InputData *data)
  331. {
  332. }
  333. ///
  334.  
  335. /// DITO_CreateOutput
  336. SAVEDS ASM struct DITO_OutputData *DITO_CreateOutput(REG(a0) Object *app)
  337. {
  338.     struct   DITO_OutputData *data;
  339.     static   char *strtab[5];
  340.  
  341.     strtab[0] = LOC(part0);
  342.     strtab[1] = LOC(part1);
  343.     strtab[2] = LOC(part2);
  344.     strtab[3] = LOC(part3);
  345.     strtab[4] = 0;
  346.  
  347.     if(data = AllocVec(sizeof(struct DITO_OutputData),0)){
  348.  
  349.         data->obj = VGroup,
  350.             Child, VGroup,
  351.                 MUIA_Frame, MUIV_Frame_Group,
  352.                 Child, HGroup,
  353.                     MUIA_Background, MUII_TextBack,
  354.                     MUIA_Frame, MUIV_Frame_Text,
  355.                     Child, data->kind = TextObject,
  356.                         MUIA_Text_PreParse, "\033c\033b",
  357.                         MUIA_Weight, 5000,
  358. //                  MUIA_Text_SetMin, TRUE,
  359.                         End,
  360.                     Child, data->weight = TextObject,
  361.                         MUIA_Text_Contents, IPIC0,
  362.                         MUIA_Text_SetMin, TRUE,
  363.                         End,
  364.                     End,
  365.                 Child, data->info = ListviewObject,
  366.                     MUIA_Frame, MUIV_Frame_Text,
  367.                     MUIA_Background, MUII_TextBack,
  368.                     MUIA_Listview_Input, FALSE,
  369. //             MUIA_Listview_ScrollerPos, MUIV_Listview_ScrollerPos_None,
  370.                     MUIA_Listview_List, FloattextObject,
  371.                         MUIA_Background, MUII_TextBack,
  372. //                  MUIA_Font, trans,
  373.                         MUIA_List_Format, "p=\033c",
  374.                         End,
  375.                     End,
  376.                 End,
  377. /*         Child, data->grammar = VGroup,
  378.                 MUIA_FrameTitle, LOC(grammar),
  379.                 MUIA_Frame, MUIV_Frame_Group,
  380.                 MUIA_Group_PageMode, TRUE,
  381.                 MUIA_VertDisappear, 1,
  382.  
  383.                 // Rest
  384.                 Child, TextObject,
  385.                     MUIA_Text_Contents, "\033cKeine Angaben",
  386.                     End,
  387.  
  388.                 // Noun
  389.                 Child, data->text1 = TextObject,
  390.                     MUIA_Font, word,
  391.                     MUIA_ShortHelp, "Singular\nPlural",
  392.                     MUIA_Frame, MUIV_Frame_Text,
  393.                     MUIA_Background, MUII_TextBack,
  394.                     MUIA_Text_Contents, "\033c\n",
  395.                     End,
  396.  
  397.                 // Verb
  398.                 Child, data->text2 = TextObject,
  399.                     MUIA_Font, word,
  400.                     MUIA_ShortHelp, "Infinitiv\nPräteritum\nPartizip Perfekt",
  401.                     MUIA_Frame, MUIV_Frame_Text,
  402.                     MUIA_Background, MUII_TextBack,
  403.                     MUIA_Text_Contents, "\033c\n\n",
  404.                     End,
  405.                 End,
  406. */
  407.             End;
  408.  
  409.         return(data);
  410.     }
  411.  
  412.     return(0);
  413. }
  414. ///
  415. /// DITO_DisposeOutput
  416. SAVEDS ASM void DITO_DisposeOutput(REG(a0) struct DITO_OutputData *data)
  417. {
  418.     if(data) FreeVec(data);
  419. }
  420. ///
  421. /// DITO_WriteOutput
  422. extern SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str);
  423.  
  424. SAVEDS ASM void DITO_WriteOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
  425. {
  426.     static char str[1000],gr[700];
  427. //   static char form[500];
  428.     static char *imptab[3];
  429.  
  430.     imptab[0] = IPIC0;
  431.     imptab[1] = IPIC1;
  432.     imptab[2] = IPIC2;
  433.  
  434.     set(data->weight, MUIA_Text_Contents, imptab[DITO_GetVal (entry, DITO_Val_Weight)]);
  435.  
  436. //   set(data->grammar, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));
  437.  
  438.     sprintf (str,"\n\033b%s\033n\n\n%s\n\n\033i%s",
  439.         DITO_GrammarString (entry, gr),
  440.         DITO_GetStr(entry, DITO_Str_Translation),
  441.         DITO_GetStr(entry, DITO_Str_Note)
  442.     );
  443.  
  444.     switch(DITO_GetVal (entry, DITO_Val_Type)){
  445.  
  446.         // Default
  447.         case 0:
  448.             set(data->kind, MUIA_Text_Contents, LOC(part0));
  449.             break;
  450.  
  451.         // Noun
  452.         case 1:
  453.             set(data->kind, MUIA_Text_Contents, LOC(part1));
  454. /*         if(DITO_GetStr(entry, 0)[0]){
  455.                 sprintf(form,"\033c%s\n\0338%s",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, 0));
  456.             }else{
  457.                 sprintf(form,"\033c%s\n%ss",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, DITO_Str_Word));
  458.             }
  459.             set(data->text1, MUIA_Text_Contents, form);
  460. */         break;
  461.  
  462.         // Adjective
  463.         case 2:
  464.             set(data->kind, MUIA_Text_Contents, LOC(part2));
  465.             break;
  466.  
  467.         // Verb
  468.         case 3:
  469.             set(data->kind, MUIA_Text_Contents, LOC(part3));
  470. /*         strcpy(form,"\033c");
  471.             strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  472.             if(DITO_GetStr(entry, 0)[0]){
  473.                 strcat(form,"\n\0338");
  474.                 strcat(form,DITO_GetStr(entry,0));
  475.             }else{
  476.                 strcat(form,"\n\0330");
  477.                 strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  478.                 strcat(form,"ed");
  479.             }
  480.             if(DITO_GetStr(entry, 1)[0]){
  481.                 strcat(form,"\n\0338");
  482.                 strcat(form,DITO_GetStr(entry,1));
  483.             }else{
  484.                 strcat(form,"\n\0330");
  485.                 strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  486.                 strcat(form,"ed");
  487.             }
  488.             set(data->text2, MUIA_Text_Contents, form);
  489. */         break;
  490.     }
  491.  
  492.     set(data->info,   MUIA_Floattext_Text, str);
  493. }
  494. ///
  495. /// DITO_FontsOutput
  496. SAVEDS ASM void DITO_FontsOutput (REG(a0) struct DITO_OutputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon){
  497. }
  498. ///
  499. /// DITO_UpdateOutput
  500. SAVEDS ASM void DITO_UpdateOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
  501. {
  502. }
  503. ///
  504. /// DITO_ParseInput
  505. SAVEDS ASM Object *DITO_ParseInput (REG(a0) struct DITO_InputData *data, REG(a1) char *in, REG(a2) char *out){
  506.     return(DITO_ActivateFirstInput(data));
  507. }
  508. ///
  509.  
  510. /// DITO_GrammarString
  511. SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str){
  512.     char  *h,*h2;
  513.     int   v;
  514.     static char *gen[4]={"m.","f.","n.","m.+f."};
  515.  
  516.     switch(DITO_GetVal(entry, DITO_Val_Type)){
  517.  
  518.         // Rest
  519.         case 0:
  520.             h = DITO_GetStr(entry, 0);
  521.             if(*h) sprintf(str,"%s (%s)", DITO_GetStr(entry, DITO_Str_Word),h);
  522.             else strcpy(str, DITO_GetStr(entry, DITO_Str_Word));
  523.             break;
  524.  
  525.         // Noun
  526.         case 1:
  527.             h = DITO_GetStr(entry, 0);
  528.             if(*h) sprintf(str,"%s, %s %s", DITO_GetStr(entry, DITO_Str_Word),h,gen[DITO_GetVal(entry, 0)]);
  529.             else sprintf(str,"%s %s", DITO_GetStr(entry, DITO_Str_Word),gen[DITO_GetVal(entry, 0)]);
  530.             break;
  531.  
  532. /*
  533.         // Adjektive
  534.         case 2:
  535.             v = DITO_GetVal(entry, 0);
  536.             if(v) sprintf(str,"%s (adj. inv.)", DITO_GetStr(entry, DITO_Str_Word));
  537.             else sprintf(str,"%s (adj.)", DITO_GetStr(entry, DITO_Str_Word));
  538.             break;
  539.  
  540.         // Verb
  541.         case 4:
  542.             v = DITO_GetVal(entry, 0);
  543.             if(v) sprintf(str,"%s (irr. #%d)", DITO_GetStr(entry, DITO_Str_Word),v);
  544.             else sprintf(str,"%s", DITO_GetStr(entry, DITO_Str_Word));
  545.             break;
  546.  
  547.         // Expression
  548.         case 5:
  549.             h = DITO_GetStr(entry, 0);
  550.             if(*h) sprintf(str, "\"%s\" (%s)", DITO_GetStr(entry, DITO_Str_Word),h);
  551.             else sprintf(str, "\"%s\"", DITO_GetStr(entry, DITO_Str_Word));
  552.             break;
  553. */
  554.         // else ... Adverb
  555.         default:
  556.             strcpy(str, DITO_GetStr(entry, DITO_Str_Word));
  557.             break;
  558.     }
  559.     return(str);
  560. }
  561. ///
  562.  
  563.