home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / term-source.lha / TranslationPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-28  |  15.1 KB  |  744 lines
  1. /*
  2. **    TranslationPanel.c
  3. **
  4. **    Character code translation editing panel
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_PAGE=1,GAD_USE,GAD_DEFAULT,GAD_LOAD,GAD_SAVE,GAD_CANCEL,GAD_CLOSE,
  13.         GAD_CHAR=700
  14.     };
  15.  
  16. STATIC BOOLEAN __regargs
  17. CodePanel(struct Window *Window,UBYTE CharCode,struct TranslationEntry **SendTable,struct TranslationEntry **ReceiveTable)
  18. {
  19.     struct LayoutHandle    *Handle;
  20.     BOOLEAN             Result = FALSE;
  21.  
  22.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  23.         LH_LocaleHook,    &LocaleHook,
  24.     TAG_DONE))
  25.     {
  26.         struct Window    *PanelWindow;
  27.         UBYTE         SendBuffer[256],
  28.                  ReceiveBuffer[256];
  29.  
  30.         if(SendTable[CharCode])
  31.             TranslateBack(SendTable[CharCode] -> String,SendTable[CharCode] -> Len,SendBuffer);
  32.         else
  33.             SendBuffer[0] = 0;
  34.  
  35.         if(ReceiveTable[CharCode])
  36.             TranslateBack(ReceiveTable[CharCode] -> String,ReceiveTable[CharCode] -> Len,ReceiveBuffer);
  37.         else
  38.             ReceiveBuffer[0] = 0;
  39.  
  40.         LT_New(Handle,
  41.             LA_Type,    VERTICAL_KIND,
  42.         TAG_DONE);
  43.         {
  44.             UBYTE    OctalBuffer[6],HexBuffer[6],BinBuffer[10];
  45.             WORD    i,Code;
  46.  
  47.             OctalBuffer[0] = '0';
  48.  
  49.             for(Code = CharCode, i = 0 ; i < 3 ; i++)
  50.             {
  51.                 OctalBuffer[2 - i + 1] = '0' + (Code & 7);
  52.  
  53.                 Code = Code >> 3;
  54.             }
  55.  
  56.             OctalBuffer[4] = 0;
  57.  
  58.             SPrintf(HexBuffer,"$%02lx",CharCode);
  59.  
  60.             BinBuffer[0] = '%';
  61.  
  62.             for(Code = CharCode, i = 0 ; i < 8 ; i++)
  63.             {
  64.                 BinBuffer[7 - i + 1] = '0' + (Code & 1);
  65.  
  66.                 Code = Code >> 1;
  67.             }
  68.  
  69.             BinBuffer[9] = 0;
  70.  
  71.             if(CharCodes[CharCode][0] == '1' && CharCodes[CharCode][1])
  72.                 SPrintf(SharedBuffer,LocaleString(MSG_V36_1772),CharCodes[CharCode]);
  73.             else
  74.                 SPrintf(SharedBuffer,LocaleString(MSG_V36_1773),CharCode,CharCodes[CharCode]);
  75.  
  76.             SPrintf(SharedBuffer + strlen(SharedBuffer)," · %s · %s · %s",HexBuffer,OctalBuffer,BinBuffer);
  77.  
  78.             LT_New(Handle,
  79.                 LA_Type,    VERTICAL_KIND,
  80.                 LA_LabelText,    SharedBuffer,
  81.             TAG_DONE);
  82.             {
  83.                 LT_New(Handle,
  84.                     LA_Type,        STRING_KIND,
  85.                     LA_LabelID,        MSG_TRANSLATIONPANEL_SEND_CODE_AS_GAD,
  86.                     LA_STRPTR,        SendBuffer,
  87.                     LA_Chars,        30,
  88.                     STRINGA_Justification,    GACT_STRINGCENTER,
  89.                     GTST_MaxChars,        255,
  90.                 TAG_DONE);
  91.  
  92.                 LT_New(Handle,
  93.                     LA_Type,        STRING_KIND,
  94.                     LA_LabelID,        MSG_TRANSLATIONPANEL_RECEIVE_CODE_AS_GAD,
  95.                     LA_STRPTR,        ReceiveBuffer,
  96.                     STRINGA_Justification,    GACT_STRINGCENTER,
  97.                     GTST_MaxChars,        255,
  98.                 TAG_DONE);
  99.  
  100.                 LT_EndGroup(Handle);
  101.             }
  102.  
  103.             LT_New(Handle,
  104.                 LA_Type,VERTICAL_KIND,
  105.             TAG_DONE);
  106.             {
  107.                 LT_New(Handle,
  108.                     LA_Type,    XBAR_KIND,
  109.                     LAXB_FullSize,    TRUE,
  110.                 TAG_DONE);
  111.  
  112.                 LT_EndGroup(Handle);
  113.             }
  114.  
  115.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  116.                 LAGR_SameSize,    TRUE,
  117.                 LAGR_Spread,    TRUE,
  118.             TAG_DONE);
  119.             {
  120.                 LT_New(Handle,
  121.                     LA_Type,    BUTTON_KIND,
  122.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  123.                     LA_ID,        GAD_USE,
  124.                     LABT_ReturnKey,    TRUE,
  125.                     LABT_ExtraFat,    TRUE,
  126.                 TAG_DONE);
  127.  
  128.                 LT_New(Handle,
  129.                     LA_Type,    BUTTON_KIND,
  130.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  131.                     LA_ID,        GAD_CANCEL,
  132.                     LABT_EscKey,    TRUE,
  133.                     LABT_ExtraFat,    TRUE,
  134.                 TAG_DONE);
  135.  
  136.                 LT_EndGroup(Handle);
  137.             }
  138.  
  139.             LT_EndGroup(Handle);
  140.         }
  141.  
  142.         if(PanelWindow = LT_Build(Handle,
  143.             LAWN_TitleID,        MSG_TRANSLATIONPANEL_CHARACTER_CODE_TRANSLATION_TXT,
  144.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  145.             LAWN_HelpHook,        &GuideHook,
  146.             LAWN_Parent,        Window,
  147.             WA_DepthGadget,        TRUE,
  148.             WA_CloseGadget,        TRUE,
  149.             WA_DragBar,        TRUE,
  150.             WA_RMBTrap,        TRUE,
  151.             WA_Activate,        TRUE,
  152.             WA_SimpleRefresh,    TRUE,
  153.         TAG_DONE))
  154.         {
  155.             struct IntuiMessage    *Message;
  156.             BOOLEAN             Done = FALSE;
  157.             ULONG             MsgClass;
  158.             struct Gadget        *MsgGadget;
  159.  
  160.             LT_ShowWindow(Handle,TRUE);
  161.  
  162.             GuideContext(CONTEXT_TRANSLATION);
  163.  
  164.             PushWindow(PanelWindow);
  165.  
  166.             do
  167.             {
  168.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  169.                     break;
  170.  
  171.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  172.                 {
  173.                     MsgClass    = Message -> Class;
  174.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  175.  
  176.                     LT_ReplyIMsg(Message);
  177.  
  178.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  179.                         Done = TRUE;
  180.  
  181.                     if(MsgClass == IDCMP_GADGETUP)
  182.                     {
  183.                         switch(MsgGadget -> GadgetID)
  184.                         {
  185.                             case GAD_USE:
  186.  
  187.                                 LT_UpdateStrings(Handle);
  188.  
  189.                                 if(SendBuffer[0])
  190.                                 {
  191.                                     struct TranslationEntry *Entry = AllocTranslationEntry(SendBuffer);
  192.  
  193.                                     if(Entry)
  194.                                     {
  195.                                         if(SendTable[CharCode])
  196.                                             FreeTranslationEntry(SendTable[CharCode]);
  197.  
  198.                                         SendTable[CharCode] = Entry;
  199.  
  200.                                         Result = TRUE;
  201.                                     }
  202.                                 }
  203.                                 else
  204.                                 {
  205.                                     if(SendTable[CharCode])
  206.                                         FreeTranslationEntry(SendTable[CharCode]);
  207.  
  208.                                     SendTable[CharCode] = NULL;
  209.  
  210.                                     Result = TRUE;
  211.                                 }
  212.  
  213.                                 if(ReceiveBuffer[0])
  214.                                 {
  215.                                     struct TranslationEntry *Entry = AllocTranslationEntry(ReceiveBuffer);
  216.  
  217.                                     if(Entry)
  218.                                     {
  219.                                         if(ReceiveTable[CharCode])
  220.                                             FreeTranslationEntry(ReceiveTable[CharCode]);
  221.  
  222.                                         ReceiveTable[CharCode] = Entry;
  223.  
  224.                                         Result = TRUE;
  225.                                     }
  226.                                 }
  227.                                 else
  228.                                 {
  229.                                     if(ReceiveTable[CharCode])
  230.                                         FreeTranslationEntry(ReceiveTable[CharCode]);
  231.  
  232.                                     ReceiveTable[CharCode] = NULL;
  233.  
  234.                                     Result = TRUE;
  235.                                 }
  236.  
  237.                                 Done = TRUE;
  238.                                 break;
  239.  
  240.                             case GAD_CANCEL:
  241.  
  242.                                 Done = TRUE;
  243.                                 break;
  244.                         }
  245.                     }
  246.                 }
  247.             }
  248.             while(!Done);
  249.  
  250.             PopWindow();
  251.         }
  252.  
  253.         LT_DeleteHandle(Handle);
  254.     }
  255.  
  256.     return(Result);
  257. }
  258.  
  259. BOOLEAN __regargs
  260. TranslationPanel(struct TranslationEntry ***SendTablePtr,struct TranslationEntry ***ReceiveTablePtr,STRPTR LastTranslation,struct Window *Parent,BYTE *ChangePtr)
  261. {
  262.     struct LayoutHandle    *Handle;
  263.     BOOLEAN             MadeChanges,
  264.                  Created = FALSE;
  265.  
  266.     struct TranslationEntry    **SendTable    = *SendTablePtr,
  267.                 **ReceiveTable    = *ReceiveTablePtr;
  268.  
  269.     if(ChangePtr)
  270.         MadeChanges = *ChangePtr;
  271.     else
  272.         MadeChanges = FALSE;
  273.  
  274.     if(!SendTable)
  275.     {
  276.         if(!(SendTable = AllocTranslationTable()))
  277.         {
  278.             DisplayBeep(Window -> WScreen);
  279.  
  280.             return(FALSE);
  281.         }
  282.  
  283.         if(!(ReceiveTable = AllocTranslationTable()))
  284.         {
  285.             DisplayBeep(Window -> WScreen);
  286.  
  287.             FreeTranslationTable(SendTable);
  288.  
  289.             SendTable = NULL;
  290.  
  291.             return(FALSE);
  292.         }
  293.  
  294.         if(!FillTranslationTable(SendTable))
  295.         {
  296.             DisplayBeep(Window -> WScreen);
  297.  
  298.             FreeTranslationTable(SendTable);
  299.  
  300.             SendTable = NULL;
  301.  
  302.             FreeTranslationTable(ReceiveTable);
  303.  
  304.             ReceiveTable = NULL;
  305.  
  306.             return(FALSE);
  307.         }
  308.  
  309.         if(!FillTranslationTable(ReceiveTable))
  310.         {
  311.             DisplayBeep(Window -> WScreen);
  312.  
  313.             FreeTranslationTable(SendTable);
  314.  
  315.             SendTable = NULL;
  316.  
  317.             FreeTranslationTable(ReceiveTable);
  318.  
  319.             ReceiveTable = NULL;
  320.  
  321.             return(FALSE);
  322.         }
  323.  
  324.         Created = TRUE;
  325.     }
  326.  
  327.     *SendTablePtr        = SendTable;
  328.     *ReceiveTablePtr    = ReceiveTable;
  329.  
  330.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  331.         LH_LocaleHook,    &LocaleHook,
  332.     TAG_DONE))
  333.     {
  334.         struct Window    *PanelWindow;
  335.         LONG         i,Width,Max = 0;
  336.  
  337.         for(i = 0 ; i < 256 ; i++)
  338.         {
  339.             if((Width = LT_LabelChars(Handle,CharCodes[i])) > Max)
  340.                 Max = Width;
  341.         }
  342.  
  343.         LT_New(Handle,
  344.             LA_Type,    VERTICAL_KIND,
  345.         TAG_DONE);
  346.         {
  347.             LT_New(Handle,
  348.                 LA_Type,    VERTICAL_KIND,
  349.             TAG_DONE);
  350.             {
  351.                 STATIC STRPTR Halfs[] =
  352.                 {
  353.                     "NUL-DEL",
  354.                     "128-\"ÿ\"",
  355.                     NULL
  356.                 };
  357.  
  358.                 LT_New(Handle,
  359.                     LA_Type,    TAB_KIND,
  360.                     LA_LabelID,    MSG_TRANSLATIONPANEL_CHARACTER_PAGE_GAD,
  361.                     LA_ID,        GAD_PAGE,
  362.                     GTCY_Labels,    Halfs,
  363.                     LA_NoKey,    TRUE,
  364.                     LATB_FullWidth,    TRUE,
  365.                 TAG_DONE);
  366.  
  367.                 LT_EndGroup(Handle);
  368.             }
  369.  
  370.             LT_New(Handle,
  371.                 LA_Type,    VERTICAL_KIND,
  372.             TAG_DONE);
  373.             {
  374.                 WORD i,j;
  375.  
  376.                 for(i = 0 ; i < 8 ; i++)
  377.                 {
  378.                     LT_New(Handle,
  379.                         LA_Type,    HORIZONTAL_KIND,
  380.                         LA_SameSize,    TRUE,
  381.                     TAG_DONE);
  382.                     {
  383.                         for(j = 0 ; j < 16 ; j++)
  384.                         {
  385.                             LT_New(Handle,
  386.                                 LA_Type,    BUTTON_KIND,
  387.                                 LA_LabelText,    CharCodes[i * 16 + j],
  388.                                 LA_ID,        GAD_CHAR + i * 16 + j,
  389.                                 LA_Chars,    Max,
  390.                                 LA_NoKey,    TRUE,
  391.                             TAG_DONE);
  392.                         }
  393.  
  394.                         LT_EndGroup(Handle);
  395.                     }
  396.                 }
  397.  
  398.                 LT_EndGroup(Handle);
  399.             }
  400.  
  401.             LT_New(Handle,
  402.                 LA_Type,VERTICAL_KIND,
  403.             TAG_DONE);
  404.             {
  405.                 LT_New(Handle,
  406.                     LA_Type,    XBAR_KIND,
  407.                     LAXB_FullSize,    TRUE,
  408.                 TAG_DONE);
  409.  
  410.                 LT_EndGroup(Handle);
  411.             }
  412.  
  413.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  414.                 LAGR_Spread,    TRUE,
  415.             TAG_DONE);
  416.             {
  417.                 LT_New(Handle,
  418.                     LA_Type,    BUTTON_KIND,
  419.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  420.                     LA_ID,        GAD_USE,
  421.                     LA_NoKey,    TRUE,
  422.                     LABT_ExtraFat,    TRUE,
  423.                 TAG_DONE);
  424.  
  425.                 LT_New(Handle,
  426.                     LA_Type,    BUTTON_KIND,
  427.                     LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  428.                     LA_ID,        GAD_DEFAULT,
  429.                     LA_NoKey,    TRUE,
  430.                     LABT_ExtraFat,    TRUE,
  431.                 TAG_DONE);
  432.  
  433.                 LT_New(Handle,
  434.                     LA_Type,    BUTTON_KIND,
  435.                     LA_LabelID,    MSG_GLOBAL_LOAD_GAD,
  436.                     LA_ID,        GAD_LOAD,
  437.                     LA_NoKey,    TRUE,
  438.                     LABT_ExtraFat,    TRUE,
  439.                 TAG_DONE);
  440.  
  441.                 LT_New(Handle,
  442.                     LA_Type,    BUTTON_KIND,
  443.                     LA_LabelID,    MSG_GLOBAL_SAVE_GAD,
  444.                     LA_ID,        GAD_SAVE,
  445.                     LA_NoKey,    TRUE,
  446.                     LABT_ExtraFat,    TRUE,
  447.                 TAG_DONE);
  448.  
  449.                 LT_New(Handle,
  450.                     LA_Type,    BUTTON_KIND,
  451.                     LA_LabelID,    MSG_GLOBAL_CLOSE_TXT,
  452.                     LA_ID,        GAD_CANCEL,
  453.                     LA_NoKey,    TRUE,
  454.                     LABT_ExtraFat,    TRUE,
  455.                 TAG_DONE);
  456.  
  457.                 LT_EndGroup(Handle);
  458.             }
  459.  
  460.             LT_EndGroup(Handle);
  461.         }
  462.  
  463.         if(PanelWindow = LT_Build(Handle,
  464.             LAWN_TitleID,        MSG_TRANSLATIONPANEL_CHARACTER_TABLE_TXT,
  465.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  466.             LAWN_HelpHook,        &GuideHook,
  467.             LAWN_Parent,        Parent,
  468.             WA_DepthGadget,        TRUE,
  469.             WA_CloseGadget,        TRUE,
  470.             WA_DragBar,        TRUE,
  471.             WA_RMBTrap,        TRUE,
  472.             WA_Activate,        TRUE,
  473.             WA_SimpleRefresh,    TRUE,
  474.         TAG_DONE))
  475.         {
  476.             struct IntuiMessage    *Message;
  477.             BOOLEAN             Done = FALSE;
  478.             ULONG             MsgClass,
  479.                          MsgQualifier;
  480.             UWORD             MsgCode;
  481.             struct Gadget        *MsgGadget;
  482.             LONG             CharBase = 0,i;
  483.             UBYTE             DummyBuffer[256],
  484.                         *DummyChar;
  485.             struct FileRequester    *FileRequest;
  486.             WORD             KeyCode;
  487.  
  488.             PushWindow(PanelWindow);
  489.  
  490.             LT_ShowWindow(Handle,TRUE);
  491.  
  492.             do
  493.             {
  494.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  495.                     break;
  496.  
  497.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  498.                 {
  499.                     MsgClass    = Message -> Class;
  500.                     MsgQualifier    = Message -> Qualifier;
  501.                     MsgCode        = Message -> Code;
  502.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  503.  
  504.                     if(MsgClass == IDCMP_RAWKEY)
  505.                         KeyCode = LT_GetCode(MsgQualifier,MsgClass,MsgCode,MsgGadget);
  506.                     else
  507.                         KeyCode = -1;
  508.  
  509.                     GT_ReplyIMsg(Message);
  510.  
  511.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  512.  
  513.                     if(MsgClass == IDCMP_CLOSEWINDOW && KeyCode == -1)
  514.                         Done = TRUE;
  515.  
  516.                     if(KeyCode != -1)
  517.                     {
  518.                         if(KeyCode >= CharBase && KeyCode < CharBase + 128)
  519.                             LT_PressButton(Handle,GAD_CHAR + KeyCode - CharBase);
  520.  
  521.                         LT_LockWindow(PanelWindow);
  522.  
  523.                         MadeChanges |= CodePanel(PanelWindow,KeyCode,SendTable,ReceiveTable);
  524.  
  525.                         LT_UnlockWindow(PanelWindow);
  526.  
  527.                         LT_ShowWindow(Handle,TRUE);
  528.                     }
  529.  
  530.                     if(MsgClass == IDCMP_GADGETUP)
  531.                     {
  532.                         switch(MsgGadget -> GadgetID)
  533.                         {
  534.                             case GAD_PAGE:
  535.  
  536.                                 LT_LockWindow(PanelWindow);
  537.  
  538.                                 if(MsgCode)
  539.                                 {
  540.                                     for(i = 0 ; i < 128 ; i++)
  541.                                         LT_SetAttributes(Handle,GAD_CHAR + i,LA_LabelText,CharCodes[128 + i],TAG_DONE);
  542.  
  543.                                     CharBase = 128;
  544.                                 }
  545.                                 else
  546.                                 {
  547.                                     for(i = 0 ; i < 128 ; i++)
  548.                                         LT_SetAttributes(Handle,GAD_CHAR + i,LA_LabelText,CharCodes[0 + i],TAG_DONE);
  549.  
  550.                                     CharBase = 0;
  551.                                 }
  552.  
  553.                                 if(!LT_Rebuild(Handle,NULL,0,0,FALSE))
  554.                                 {
  555.                                     LT_DeleteHandle(Handle);
  556.  
  557.                                     Handle = NULL;
  558.  
  559.                                     Done = TRUE;
  560.                                 }
  561.                                 else
  562.                                     LT_UnlockWindow(PanelWindow);
  563.  
  564.                                 break;
  565.  
  566.                             case GAD_DEFAULT:
  567.  
  568.                                 if(SendTable)
  569.                                 {
  570.                                     struct TranslationEntry **Table;
  571.  
  572.                                     if(Table = AllocTranslationTable())
  573.                                     {
  574.                                         if(FillTranslationTable(Table))
  575.                                         {
  576.                                             FreeTranslationTable(SendTable);
  577.  
  578.                                             SendTable = Table;
  579.                                         }
  580.                                     }
  581.                                 }
  582.  
  583.                                 if(ReceiveTable)
  584.                                 {
  585.                                     struct TranslationEntry **Table;
  586.  
  587.                                     if(Table = AllocTranslationTable())
  588.                                     {
  589.                                         if(FillTranslationTable(Table))
  590.                                         {
  591.                                             FreeTranslationTable(ReceiveTable);
  592.  
  593.                                             ReceiveTable = Table;
  594.                                         }
  595.                                     }
  596.                                 }
  597.  
  598.                                 break;
  599.  
  600.                             case GAD_CLOSE:
  601.                             case GAD_USE:
  602.  
  603.                                 Done = TRUE;
  604.                                 break;
  605.  
  606.                             case GAD_CANCEL:
  607.  
  608.                                 Done = TRUE;
  609.                                 break;
  610.  
  611.                             case GAD_LOAD:
  612.  
  613.                                 strcpy(DummyBuffer,LastTranslation);
  614.  
  615.                                 DummyChar = PathPart(DummyBuffer);
  616.  
  617.                                 *DummyChar = 0;
  618.  
  619.                                 LT_LockWindow(PanelWindow);
  620.  
  621.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_TRANSLATIONPANEL_LOAD_TRANSLATION_TABLES_TXT),DummyBuffer,FilePart(LastTranslation),DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  622.                                 {
  623.                                     struct TranslationEntry **Send,**Receive = NULL;
  624.                                     BOOLEAN            Success = FALSE;
  625.  
  626.                                     if(Send = AllocTranslationTable())
  627.                                     {
  628.                                         if(Receive = AllocTranslationTable())
  629.                                             Success = LoadTranslationTables(DummyBuffer,Send,Receive);
  630.                                     }
  631.  
  632.                                     if(!Success)
  633.                                     {
  634.                                         ShowError(PanelWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  635.  
  636.                                         if(Send)
  637.                                             FreeTranslationTable(Send);
  638.  
  639.                                         if(Receive)
  640.                                             FreeTranslationTable(Receive);
  641.                                     }
  642.                                     else
  643.                                     {
  644.                                         strcpy(Config -> TranslationFileName,DummyBuffer);
  645.  
  646.                                         strcpy(LastTranslation,DummyBuffer);
  647.  
  648.                                         MadeChanges    = FALSE;
  649.                                         Created        = FALSE;
  650.  
  651.                                         FreeTranslationTable(SendTable);
  652.                                         FreeTranslationTable(ReceiveTable);
  653.  
  654.                                         SendTable    = Send;
  655.                                         ReceiveTable    = Receive;
  656.  
  657.                                         if(ChangePtr)
  658.                                             *ChangePtr = FALSE;
  659.                                     }
  660.  
  661.                                     FreeAslRequest(FileRequest);
  662.                                 }
  663.  
  664.                                 LT_UnlockWindow(PanelWindow);
  665.                                 break;
  666.  
  667.                             case GAD_SAVE:
  668.  
  669.                                 strcpy(DummyBuffer,LastTranslation);
  670.  
  671.                                 DummyChar = PathPart(DummyBuffer);
  672.  
  673.                                 *DummyChar = 0;
  674.  
  675.                                 LT_LockWindow(PanelWindow);
  676.  
  677.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT),DummyBuffer,FilePart(LastTranslation),DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  678.                                 {
  679.                                     if(!SaveTranslationTables(DummyBuffer,SendTable,ReceiveTable))
  680.                                         ShowError(PanelWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  681.                                     else
  682.                                     {
  683.                                         strcpy(LastTranslation,DummyBuffer);
  684.  
  685.                                         MadeChanges = FALSE;
  686.  
  687.                                         Created = FALSE;
  688.  
  689.                                         if(ChangePtr)
  690.                                             *ChangePtr = FALSE;
  691.                                     }
  692.  
  693.                                     FreeAslRequest(FileRequest);
  694.                                 }
  695.  
  696.                                 LT_UnlockWindow(PanelWindow);
  697.                                 break;
  698.  
  699.                             default:
  700.  
  701.                                 if(MsgGadget -> GadgetID >= GAD_CHAR && MsgGadget -> GadgetID < GAD_CHAR + 128)
  702.                                 {
  703.                                     LT_LockWindow(PanelWindow);
  704.  
  705.                                     MadeChanges |= CodePanel(PanelWindow,CharBase + MsgGadget -> GadgetID - GAD_CHAR,SendTable,ReceiveTable);
  706.  
  707.                                     LT_UnlockWindow(PanelWindow);
  708.  
  709.                                     LT_ShowWindow(Handle,TRUE);
  710.                                 }
  711.  
  712.                                 break;
  713.                         }
  714.                     }
  715.                 }
  716.             }
  717.             while(!Done);
  718.  
  719.             PopWindow();
  720.         }
  721.  
  722.         LT_DeleteHandle(Handle);
  723.     }
  724.  
  725.     if(!MadeChanges && Created || (IsStandardTable(SendTable) && IsStandardTable(ReceiveTable)))
  726.     {
  727.         FreeTranslationTable(SendTable);
  728.  
  729.         SendTable = NULL;
  730.  
  731.         FreeTranslationTable(ReceiveTable);
  732.  
  733.         ReceiveTable = NULL;
  734.     }
  735.  
  736.     *SendTablePtr        = SendTable;
  737.     *ReceiveTablePtr    = ReceiveTable;
  738.  
  739.     if(ChangePtr)
  740.         *ChangePtr |= MadeChanges;
  741.  
  742.     return(MadeChanges);
  743. }
  744.