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