home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / edu / DITOdev.lha / DITOdev / Extensions / Source / English / Funcs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-17  |  12.7 KB  |  498 lines
  1. //////////////////////////////////////////////////////////
  2. // Some definitions for lacalization
  3. //////////////////////////////////////////////////////////
  4.  
  5. #define LOC(a)    GetDITO_englishString(m_ ## a)
  6. #define OPENCAT   OpenDITO_englishCatalog(NULL,NULL)
  7. #define CLOSECAT  CloseDITO_englishCatalog()
  8.  
  9. #define IPIC0 "\033I[6:38]"
  10. #define IPIC1 "\033I[6:34]"
  11. #define IPIC2 "\033I[6:39]"
  12.  
  13. //////////////////////////////////////////////////////////
  14. // Language specific InputData
  15. //////////////////////////////////////////////////////////
  16.  
  17. struct DITO_InputData {
  18.     Object
  19.         *obj,                      // First pointer has to be the pointer
  20.                                             // to the whole created object
  21.         *remark,                   // String
  22.         *rremark,                  // String
  23.         *plural,                   // String
  24.         *verb0,                    // String
  25.         *verb1;                    // String
  26. };
  27.  
  28. //////////////////////////////////////////////////////////
  29. // Language specific OutputData
  30. //////////////////////////////////////////////////////////
  31.  
  32. struct DITO_OutputData {
  33.     Object
  34.         *obj,                      // First Pointer points to created object
  35.  
  36.         *kind,                     // Text
  37.         *info,                     // Floattext
  38.         *grammar,                  // Group
  39.         *weight,                   // Text
  40.         *text1,                    // Text
  41.         *text2;                    // Text
  42. };
  43.  
  44. //////////////////////////////////////////////////////////
  45. // Get Extension Info
  46. //////////////////////////////////////////////////////////
  47.  
  48. char  *Types[5];
  49.  
  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(part2);
  58.  
  59.     info.Language    = LOC(language);
  60.     info.Author      = AUTHOR;
  61.     info.Version     = VERSIONSTR;
  62.     info.Date        = __DATE__;
  63.     info.Description = LOC(description);
  64.  
  65.     info.NumTypes    = 4;
  66.     info.Types       = Types;
  67.  
  68.     return(&info);
  69. }
  70.  
  71. //////////////////////////////////////////////////////////
  72. // Create Input
  73. //////////////////////////////////////////////////////////
  74.  
  75. SAVEDS ASM struct DITO_InputData *DITO_CreateInput(REG(a0) Object *app)
  76. {
  77.     struct   DITO_InputData *data;
  78.     static char *strtab[5];
  79.  
  80.     strtab[0] = LOC(part0);
  81.     strtab[1] = LOC(part1);
  82.     strtab[2] = LOC(part2);
  83.     strtab[3] = LOC(part3);
  84.     strtab[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, VGroup,
  110.                 Child, LLabel(LOC(plural)),
  111.                 Child, data->plural = StringObject,
  112.                     MUIA_CycleChain, 1,
  113.                     MUIA_Frame, MUIV_Frame_String,
  114.                     MUIA_String_Format, MUIV_String_Format_Center,
  115.                     MUIA_String_AdvanceOnCR, TRUE,
  116.                     End,
  117.                 End,
  118.  
  119.             // Verb
  120.             // ****
  121.             Child, ColGroup(2),
  122.                 Child, LLabel(LOC(verb0)),
  123.                 Child, LLabel(LOC(verb1)),
  124.                 Child, data->verb0 = StringObject,
  125.                     MUIA_CycleChain, 1,
  126.                     MUIA_Frame, MUIV_Frame_String,
  127.                     MUIA_String_Format, MUIV_String_Format_Center,
  128.                     MUIA_String_AdvanceOnCR, TRUE,
  129.                     End,
  130.                 Child, data->verb1 = StringObject,
  131.                     MUIA_CycleChain, 1,
  132.                     MUIA_Frame, MUIV_Frame_String,
  133.                     MUIA_String_Format, MUIV_String_Format_Center,
  134.                     MUIA_String_AdvanceOnCR, TRUE,
  135.                     End,
  136.                 End,
  137.  
  138.             // Ausdruck
  139.             // ********
  140.             Child, VGroup,
  141.                 Child, LLabel(LOC(remark)),
  142.                 Child, data->rremark = StringObject,
  143.                     MUIA_CycleChain, 1,
  144.                     MUIA_Frame, MUIV_Frame_String,
  145.                     MUIA_String_Format, MUIV_String_Format_Center,
  146.                     MUIA_String_AdvanceOnCR, TRUE,
  147.                     End,
  148.                 End,
  149.             End;
  150.  
  151.           return(data);
  152.     }
  153.  
  154.     return(0);
  155. }
  156.  
  157. //////////////////////////////////////////////////////////
  158. // Dispose Input
  159. //////////////////////////////////////////////////////////
  160.  
  161. SAVEDS ASM void DITO_DisposeInput(REG(a0) struct DITO_InputData *data)
  162. {
  163.     if(data) FreeVec(data);
  164. }
  165.  
  166. //////////////////////////////////////////////////////////
  167. // Clear Input
  168. //////////////////////////////////////////////////////////
  169.  
  170. SAVEDS ASM void DITO_ClearInput(REG(a0) struct DITO_InputData *data)
  171. {
  172.     set(data->remark, MUIA_String_Contents, "");
  173.     set(data->rremark,MUIA_String_Contents, "");
  174.     set(data->plural, MUIA_String_Contents, "");
  175.     set(data->verb0,  MUIA_String_Contents, "");
  176.     set(data->verb1,  MUIA_String_Contents, "");
  177. }
  178.  
  179. //////////////////////////////////////////////////////////
  180. // Write Input
  181. //////////////////////////////////////////////////////////
  182.  
  183. SAVEDS ASM void DITO_WriteInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_Entry *entry)
  184. {
  185.     set (data->obj, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));
  186.  
  187.     DITO_ClearInput (data);
  188.  
  189.     switch(DITO_GetVal (entry, DITO_Val_Type)){
  190.  
  191.         // Default
  192.         case 0:
  193.             set(data->remark, MUIA_String_Contents, DITO_GetStr(entry,0));
  194.             break;
  195.  
  196.         // Noun
  197.         case 1:
  198.             set(data->plural, MUIA_String_Contents, DITO_GetStr(entry,0));
  199.             break;
  200.  
  201.         // Verb
  202.         case 2:
  203.             set(data->verb0, MUIA_String_Contents, DITO_GetStr(entry,0));
  204.             set(data->verb1, MUIA_String_Contents, DITO_GetStr(entry,1));
  205.             break;
  206.  
  207.         // Expression
  208.         case 3:
  209.             set(data->rremark, MUIA_String_Contents, DITO_GetStr(entry,0));
  210.             break;
  211.  
  212.     }
  213. }
  214.  
  215. //////////////////////////////////////////////////////////
  216. // Read Input
  217. //////////////////////////////////////////////////////////
  218.  
  219. SAVEDS ASM BOOL DITO_ReadInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_EntryInfo *vi, REG(a2) struct DITO_Entry *entry)
  220. {
  221.     BOOL  changed = FALSE;
  222.  
  223.     get (data->obj, MUIA_Group_ActivePage, &vi->type);
  224.  
  225.     switch(vi->type){
  226.  
  227.         // Default
  228.         case 0:
  229.             vi->snum=1;
  230.             get (data->remark, MUIA_String_Contents, &vi->gr[0]);
  231.             if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  232.             break;
  233.  
  234.         // Noun
  235.         case 1:
  236.             vi->snum=1;
  237.             get (data->plural, MUIA_String_Contents, &vi->gr[0]);
  238.             if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  239.             break;
  240.  
  241.         // Verb
  242.         case 2:
  243.             vi->snum=2;
  244.             get (data->verb0, MUIA_String_Contents, &vi->gr[0]);
  245.             get (data->verb1, MUIA_String_Contents, &vi->gr[1]);
  246.             if(entry){
  247.                 changed =
  248.                     strcmp(DITO_GetStr(entry,1), vi->gr[1])
  249.                 || strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  250.             }
  251.             break;
  252.  
  253.         // Expression
  254.         case 3:
  255.             vi->snum=1;
  256.             get (data->rremark, MUIA_String_Contents, &vi->gr[0]);
  257.             if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0]);
  258.             break;
  259.  
  260.     }
  261.     return(changed);
  262. }
  263.  
  264. //////////////////////////////////////////////////////////
  265. // Activate first gadget, Input
  266. //////////////////////////////////////////////////////////
  267.  
  268. SAVEDS ASM Object *DITO_ActivateFirstInput(REG(a0) struct DITO_InputData *data)
  269. {
  270.     LONG  p;
  271.  
  272.     get (data->obj, MUIA_Group_ActivePage, &p);
  273.     switch(p){
  274.         case 0:  return(data->remark);
  275.         case 1:  return(data->plural);
  276.         case 2:  return(data->verb0);
  277.         case 3:  return(data->rremark);
  278.     }
  279. }
  280.  
  281. //////////////////////////////////////////////////////////
  282. // Refresh fonts, Input
  283. //////////////////////////////////////////////////////////
  284.  
  285. SAVEDS ASM void DITO_FontsInput(REG(a0) struct DITO_InputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon)
  286. {
  287.     set(data->remark,       MUIA_Font, word);
  288.     set(data->rremark,      MUIA_Font, word);
  289.     set(data->plural,       MUIA_Font, word);
  290.     set(data->verb0,        MUIA_Font, word);
  291.     set(data->verb1,        MUIA_Font, word);
  292. }
  293.  
  294. //////////////////////////////////////////////////////////
  295. // Update input
  296. //////////////////////////////////////////////////////////
  297.  
  298. SAVEDS ASM void DITO_UpdateInput(REG(a0) struct DITO_InputData *data)
  299. {
  300. }
  301.  
  302. //////////////////////////////////////////////////////////
  303. // Create output object
  304. //////////////////////////////////////////////////////////
  305.  
  306. SAVEDS ASM struct DITO_OutputData *DITO_CreateOutput(REG(a0) Object *app)
  307. {
  308.     struct   DITO_OutputData *data;
  309.  
  310.     if(data = AllocVec(sizeof(struct DITO_OutputData),0)){
  311.  
  312.         data->obj = VGroup,
  313.             Child, VGroup,
  314.                 MUIA_Frame, MUIV_Frame_Group,
  315.                 MUIA_VertDisappear, 1,
  316.                 Child, HGroup,
  317.                     MUIA_Background, MUII_TextBack,
  318.                     MUIA_Frame, MUIV_Frame_Text,
  319.                     Child, data->kind = TextObject,
  320.                         MUIA_Text_PreParse, "\033c\033b",
  321.                         MUIA_Weight, 5000,
  322. //                  MUIA_Text_SetMin, TRUE,
  323.                         End,
  324.                     Child, data->weight = TextObject,
  325.                         MUIA_Text_Contents, IPIC0,
  326.                         MUIA_Text_SetMin, TRUE,
  327.                         End,
  328.                     End,
  329.                 Child, data->info = ListviewObject,
  330.                     MUIA_Frame, MUIV_Frame_Text,
  331.                     MUIA_Background, MUII_TextBack,
  332.                     MUIA_Listview_Input, FALSE,
  333. //             MUIA_Listview_ScrollerPos, MUIV_Listview_ScrollerPos_None,
  334.                     MUIA_Listview_List, FloattextObject,
  335.                         MUIA_Background, MUII_TextBack,
  336. //                  MUIA_Font, trans,
  337.                         MUIA_List_Format, "p=\033c",
  338.                         End,
  339.                     End,
  340.                 End,
  341.             Child, data->grammar = VGroup,
  342.                 MUIA_FrameTitle, LOC(grammar),
  343.                 MUIA_Frame, MUIV_Frame_Group,
  344.                 MUIA_Group_PageMode, TRUE,
  345.  
  346.                 // Rest
  347.                 Child, TextObject,
  348.                     MUIA_Text_Contents, LOC(nocom),
  349.                     End,
  350.  
  351.                 // Noun
  352.                 Child, data->text1 = TextObject,
  353.                     MUIA_ShortHelp, LOC(bubnoun),
  354.                     MUIA_Frame, MUIV_Frame_Text,
  355.                     MUIA_Background, MUII_TextBack,
  356.                     MUIA_Text_Contents, "\033c\n",
  357.                     End,
  358.  
  359.                 // Verb
  360.                 Child, data->text2 = TextObject,
  361.                     MUIA_ShortHelp, LOC(bubverb),
  362.                     MUIA_Frame, MUIV_Frame_Text,
  363.                     MUIA_Background, MUII_TextBack,
  364.                     MUIA_Text_Contents, "\033c\n\n",
  365.                     End,
  366.  
  367.                 // Expression
  368.                 Child, TextObject,
  369.                     MUIA_Text_Contents, LOC(nocom),
  370.                     End,
  371.                 End,
  372.  
  373.             End;
  374.  
  375.         return(data);
  376.     }
  377.  
  378.     return(0);
  379. }
  380.  
  381. //////////////////////////////////////////////////////////
  382. // Dispose object
  383. //////////////////////////////////////////////////////////
  384.  
  385. SAVEDS ASM void DITO_DisposeOutput(REG(a0) struct DITO_OutputData *data)
  386. {
  387.     if(data) FreeVec(data);
  388. }
  389.  
  390.  
  391. //////////////////////////////////////////////////////////
  392. // Fill output
  393. //////////////////////////////////////////////////////////
  394.  
  395. SAVEDS ASM void DITO_WriteOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
  396. {
  397.     static char str[1000];
  398.     static char form[500];
  399.     static char *imptab[3];
  400.  
  401.     imptab[0] = IPIC0;
  402.     imptab[1] = IPIC1;
  403.     imptab[2] = IPIC2;
  404.  
  405.     set(data->weight, MUIA_Text_Contents, imptab[DITO_GetVal (entry, DITO_Val_Weight)]);
  406.  
  407.     set(data->grammar, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));
  408.  
  409.     sprintf (str,"\n\033b%s\033n\n\n%s\n\n\033i%s",
  410.         DITO_GetStr(entry, DITO_Str_Word),
  411.         DITO_GetStr(entry, DITO_Str_Translation),
  412.         DITO_GetStr(entry, DITO_Str_Note)
  413.     );
  414.  
  415.     switch(DITO_GetVal (entry, DITO_Val_Type)){
  416.  
  417.         // Default
  418.         case 0:
  419.             set(data->kind, MUIA_Text_Contents, LOC(part0));
  420.             break;
  421.  
  422.         // Noun
  423.         case 1:
  424.             set(data->kind, MUIA_Text_Contents, LOC(part1));
  425.             if(DITO_GetStr(entry, 0)[0]){
  426.                 sprintf(form,"\033c%s\n\0338%s",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, 0));
  427.             }else{
  428.                 sprintf(form,"\033c%s\n%ss",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, DITO_Str_Word));
  429.             }
  430.             set(data->text1, MUIA_Text_Contents, form);
  431.             break;
  432.  
  433.         // Verb
  434.         case 2:
  435.             set(data->kind, MUIA_Text_Contents, LOC(part2));
  436.             strcpy(form,"\033c");
  437.             strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  438.             if(DITO_GetStr(entry, 0)[0]){
  439.                 strcat(form,"\n\0338");
  440.                 strcat(form,DITO_GetStr(entry,0));
  441.             }else{
  442.                 strcat(form,"\n\0330");
  443.                 strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  444.                 strcat(form,"ed");
  445.             }
  446.             if(DITO_GetStr(entry, 1)[0]){
  447.                 strcat(form,"\n\0338");
  448.                 strcat(form,DITO_GetStr(entry,1));
  449.             }else{
  450.                 strcat(form,"\n\0330");
  451.                 strcat(form,DITO_GetStr(entry,DITO_Str_Word));
  452.                 strcat(form,"ed");
  453.             }
  454.             set(data->text2, MUIA_Text_Contents, form);
  455.             break;
  456.  
  457.         // Expression
  458.         case 3:
  459.             set(data->kind, MUIA_Text_Contents, LOC(part3));
  460.             break;
  461.  
  462.     }
  463.  
  464.     set(data->info,   MUIA_Floattext_Text, str);
  465. }
  466.  
  467. /// DITO_FontsOutput
  468. SAVEDS ASM void DITO_FontsOutput (REG(a0) struct DITO_OutputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon){
  469.     set(data->text1,       MUIA_Font, word);
  470.     set(data->text2,       MUIA_Font, word);
  471. }
  472. ///
  473. //////////////////////////////////////////////////////////
  474. // Update output
  475. //////////////////////////////////////////////////////////
  476.  
  477. SAVEDS ASM void DITO_UpdateOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
  478. {
  479. }
  480.  
  481. //////////////////////////////////////////////////////////
  482. // Parse Input String
  483. //////////////////////////////////////////////////////////
  484.  
  485. SAVEDS ASM Object *DITO_ParseInput (REG(a0) struct DITO_InputData *data, REG(a1) char *in, REG(a2) char *out){
  486.     return(DITO_ActivateFirstInput(data));
  487. }
  488.  
  489. //////////////////////////////////////////////////////////
  490. // Create a grammar String
  491. //////////////////////////////////////////////////////////
  492.  
  493. SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str){
  494.     return(str);
  495. }
  496.  
  497.  
  498.