home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / telecomm / terms / term-4.1-source.lha / Extras / Source / term-Source.lha / CapturePanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  19.5 KB  |  802 lines
  1. /*
  2. **    CapturePanel.c
  3. **
  4. **    Editing panel for log file, buffer and capture configuration
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LOGACTIONS, GAD_LOGFILE, GAD_SELECT_LOGFILE, GAD_LOGCALLS, GAD_CALL_LOGFILE,GAD_SELECT_CALL_LOGFILE,
  13.         GAD_MAX_BUFFER_SIZE,GAD_BUFFER_ENABLED,GAD_BUFFER_PATH,GAD_SELECT_BUFFER_PATH,
  14.         GAD_CONNECT_AUTO_CAPTURE, GAD_AUTOCAPTURE_DATE, GAD_CAPTURE_FILTER,
  15.         GAD_CAPTURE_PATH, GAD_SELECT_CAPTURE_PATH, GAD_OPEN_BUFFER_WINDOW,
  16.         GAD_REMEMBER_WINDOW_POS,GAD_OPEN_BUFFER_SCREEN,GAD_REMEMBER_SCREEN_POS,GAD_SEARCH_HISTORY,
  17.         GAD_SCREENMODE,GAD_BUFFERSCREEN_POSITION,GAD_BUFFERWIDTH,GAD_USE, GAD_CANCEL, GAD_DEFAULT };
  18.  
  19. STATIC BYTE  __regargs
  20. SelectDisplayMode(struct Window *Window,ULONG *CurrentMode,struct Configuration *Config)
  21. {
  22.     BYTE Success = FALSE;
  23.  
  24.     if(!Kick30)
  25.     {
  26.         struct List    *ModeList;
  27.         LONG         Index;
  28.  
  29.         if(ModeList = BuildModeList(&Index,*CurrentMode,NULL))
  30.         {
  31.             struct LayoutHandle *Handle;
  32.  
  33.             if(Handle = LT_CreateHandleTags(Window -> WScreen,
  34.                 LH_LocaleHook,    &LocaleHook,
  35.             TAG_DONE))
  36.             {
  37.                 struct Window *LocalWindow;
  38.  
  39.                 LT_New(Handle,
  40.                     LA_Type,    VERTICAL_KIND,
  41.                 TAG_DONE);
  42.                 {
  43.                     LT_New(Handle,
  44.                         LA_Type,    VERTICAL_KIND,
  45.                     TAG_DONE);
  46.                     {
  47.                         LT_New(Handle,
  48.                             LA_Type,    LISTVIEW_KIND,
  49.                             LA_LabelID,    MSG_V36_0160,
  50.                             GTLV_Labels,    ModeList,
  51.                             LA_LONG,    &Index,
  52.                             LALV_CursorKey,    TRUE,
  53.                             LALV_Link,    NIL_LINK,
  54.                             LALV_MaxGrowY,    20,
  55.                             LA_Lines,    10,
  56.                             LA_Chars,    40,
  57.                             LA_CursorKey,    TRUE,
  58.                         TAG_DONE);
  59.  
  60.                         LT_EndGroup(Handle);
  61.                     }
  62.  
  63.                     LT_New(Handle,
  64.                         LA_Type,VERTICAL_KIND,
  65.                     TAG_DONE);
  66.                     {
  67.                         LT_New(Handle,
  68.                             LA_Type,    XBAR_KIND,
  69.                             LAXB_FullSize,    TRUE,
  70.                         TAG_DONE);
  71.  
  72.                         LT_EndGroup(Handle);
  73.                     }
  74.  
  75.                     LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  76.                         LAGR_SameSize,    TRUE,
  77.                         LAGR_Spread,    TRUE,
  78.                     TAG_DONE);
  79.                     {
  80.                         LT_New(Handle,
  81.                             LA_Type,    BUTTON_KIND,
  82.                             LA_LabelID,    MSG_GLOBAL_USE_GAD,
  83.                             LA_ID,        GAD_USE,
  84.                             LABT_ReturnKey,    TRUE,
  85.                             LABT_ExtraFat,    TRUE,
  86.                         TAG_DONE);
  87.  
  88.                         LT_New(Handle,
  89.                             LA_Type,    BUTTON_KIND,
  90.                             LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  91.                             LA_ID,        GAD_CANCEL,
  92.                             LABT_EscKey,    TRUE,
  93.                             LABT_ExtraFat,    TRUE,
  94.                         TAG_DONE);
  95.  
  96.                         LT_EndGroup(Handle);
  97.                     }
  98.  
  99.                     LT_EndGroup(Handle);
  100.                 }
  101.  
  102.                 if(LocalWindow = LT_Layout(Handle,LocaleString(MSG_V36_0161),NULL,0,0,IDCMP_CLOSEWINDOW,NULL,
  103.                     LAWN_HelpHook,        &GuideHook,
  104.                     LAWN_Parent,        Window,
  105.                     WA_DepthGadget,        TRUE,
  106.                     WA_CloseGadget,        TRUE,
  107.                     WA_DragBar,        TRUE,
  108.                     WA_RMBTrap,        TRUE,
  109.                     WA_Activate,        TRUE,
  110.                 TAG_DONE))
  111.                 {
  112.                     struct IntuiMessage    *Message;
  113.                     BOOL             Done = FALSE;
  114.                     ULONG             MsgClass,
  115.                                  MsgQualifier;
  116.                     UWORD             MsgCode;
  117.                     struct Gadget        *MsgGadget;
  118.                     LONG             i;
  119.                     struct ModeNode        *ModeNode;
  120.  
  121.                     do
  122.                     {
  123.                         WaitPort(LocalWindow -> UserPort);
  124.  
  125.                         while(Message = (struct IntuiMessage *)GT_GetIMsg(LocalWindow -> UserPort))
  126.                         {
  127.                             MsgClass    = Message -> Class;
  128.                             MsgCode        = Message -> Code;
  129.                             MsgQualifier    = Message -> Qualifier;
  130.                             MsgGadget    = (struct Gadget *)Message -> IAddress;
  131.  
  132.                             GT_ReplyIMsg(Message);
  133.  
  134.                             LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  135.  
  136.                             if(MsgClass == IDCMP_CLOSEWINDOW)
  137.                                 Done = TRUE;
  138.  
  139.                             if(MsgClass == IDCMP_GADGETUP)
  140.                             {
  141.                                 switch(MsgGadget -> GadgetID)
  142.                                 {
  143.                                     case GAD_USE:
  144.  
  145.                                         for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0 ; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  146.                                         {
  147.                                             if(Index == i)
  148.                                             {
  149.                                                 *CurrentMode = ModeNode -> DisplayID;
  150.  
  151.                                                 break;
  152.                                             }
  153.                                         }
  154.  
  155.                                         Success = Done = TRUE;
  156.                                         break;
  157.  
  158.                                     case GAD_CANCEL:
  159.  
  160.                                         Done = TRUE;
  161.                                         break;
  162.                                 }
  163.                             }
  164.  
  165.                             if(MsgClass == IDCMP_IDCMPUPDATE)
  166.                             {
  167.                                 for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  168.                                 {
  169.                                     if(Index == i)
  170.                                     {
  171.                                         *CurrentMode = ModeNode -> DisplayID;
  172.  
  173.                                         Success = Done = TRUE;
  174.  
  175.                                         LT_PressButton(Handle,GAD_USE);
  176.  
  177.                                         break;
  178.                                     }
  179.                                 }
  180.                             }
  181.                         }
  182.                     }
  183.                     while(!Done);
  184.                 }
  185.  
  186.                 LT_DeleteHandle(Handle);
  187.             }
  188.  
  189.             DeleteList(ModeList);
  190.         }
  191.     }
  192.     else
  193.     {
  194.         struct ScreenModeRequester    *Request;
  195.         LONG                 Left    = 0,
  196.                          Top    = 0,
  197.                          Width    = 0,
  198.                          Height    = 0;
  199.  
  200.         GetWindowInfo(WINDOW_SCREEN,&Left,&Top,&Width,&Height,Window -> Width / 2,Window -> Height / 2);
  201.  
  202.         if(Request = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  203.             ASLSM_Window,            Window,
  204.             ASLSM_InitialDisplayID,        *CurrentMode,
  205.             ASLSM_PrivateIDCMP,        TRUE,
  206.  
  207.             ASL_LeftEdge,            Left,
  208.             ASL_TopEdge,            Top,
  209.             ASL_Width,            Width,
  210.             ASL_Height,            Height,
  211.         TAG_DONE))
  212.         {
  213.             if(AslRequestTags(Request,TAG_DONE))
  214.             {
  215.                 PutWindowInfo(WINDOW_SCREEN,Request -> sm_LeftEdge,Request -> sm_TopEdge,Request -> sm_Width,Request -> sm_Height);
  216.  
  217.                 *CurrentMode = Request -> sm_DisplayID;
  218.  
  219.                 Success = TRUE;
  220.             }
  221.  
  222.             FreeAslRequest(Request);
  223.         }
  224.     }
  225.  
  226.     return(Success);
  227. }
  228.  
  229. BYTE __regargs
  230. CapturePanel(struct Configuration *Config,BYTE *Default)
  231. {
  232.     struct LayoutHandle    *Handle;
  233.     BYTE             Cancel = FALSE;
  234.  
  235.     SaveConfig(Config,PrivateConfig);
  236.  
  237.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  238.         LH_LocaleHook,    &LocaleHook,
  239.     TAG_DONE))
  240.     {
  241.         struct Window    *PanelWindow;
  242.         BYTE         OpenBufferWindow = Config -> CaptureConfig -> OpenBufferWindow & 0xF,
  243.                  OpenBufferScreen = Config -> CaptureConfig -> OpenBufferScreen & 0xF;
  244.         UBYTE         ModeName[DISPLAYNAMELEN + 1];
  245.         ULONG         DisplayMode;
  246.  
  247.         DisplayMode = Config -> CaptureConfig -> BufferScreenMode;
  248.  
  249.         if(ModeNotAvailable(DisplayMode))
  250.         {
  251.             if(Config && Config -> ScreenConfig)
  252.                 DisplayMode = Config -> ScreenConfig -> DisplayMode;
  253.             else
  254.                 DisplayMode = INVALID_ID;
  255.         }
  256.  
  257.         if(ModeNotAvailable(DisplayMode))
  258.         {
  259.             struct Screen *PubScreen = LockPubScreen(NULL);
  260.  
  261.             if(PubScreen)
  262.             {
  263.                 DisplayMode = GetVPModeID(&PubScreen -> ViewPort);
  264.  
  265.                 UnlockPubScreen(NULL,PubScreen);
  266.             }
  267.             else
  268.                 DisplayMode = DEFAULT_MONITOR_ID | HIRES_KEY;
  269.         }
  270.  
  271.         strcpy(ModeName,GetModeName(DisplayMode));
  272.  
  273.         LT_New(Handle,
  274.             LA_Type,    VERTICAL_KIND,
  275.         TAG_DONE);
  276.         {
  277.             LT_New(Handle,
  278.                 LA_Type,    HORIZONTAL_KIND,
  279.             TAG_DONE);
  280.             {
  281.                 LT_New(Handle,
  282.                     LA_Type,    VERTICAL_KIND,
  283.                 TAG_DONE);
  284.                 {
  285.                     LT_New(Handle,
  286.                         LA_Type,    VERTICAL_KIND,
  287.                         LA_LabelID,    MSG_V36_0008,
  288.                     TAG_DONE);
  289.                     {
  290.                         LT_New(Handle,
  291.                             LA_LabelID,    MSG_CAPTUREPANEL_LOG_ACTIONS_GAD,
  292.                             LA_Type,    CHECKBOX_KIND,
  293.                             LA_ID,        GAD_LOGACTIONS,
  294.                             LA_BYTE,    &Config -> CaptureConfig -> LogActions,
  295.                         TAG_DONE);
  296.  
  297.                         LT_New(Handle,
  298.                             LA_LabelID,    MSG_CAPTUREPANEL_LOGFILE_GAD,
  299.                             LA_Type,    STRING_KIND,
  300.                             LA_ID,        GAD_LOGFILE,
  301.                             LA_Chars,    10,
  302.                             LA_STRPTR,    Config -> CaptureConfig -> LogFileName,
  303.                             LAST_Picker,    TRUE,
  304.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  305.                         TAG_DONE);
  306.  
  307.                         LT_New(Handle,
  308.                             LA_LabelID,    MSG_CAPTUREPANEL_LOG_CALLS_GAD,
  309.                             LA_Type,    CHECKBOX_KIND,
  310.                             LA_ID,        GAD_LOGCALLS,
  311.                             LA_BYTE,    &Config -> CaptureConfig -> LogCall,
  312.                         TAG_DONE);
  313.  
  314.                         LT_New(Handle,
  315.                             LA_LabelID,    MSG_CAPTUREPANEL_CALL_LOGFILE_GAD,
  316.                             LA_Type,    STRING_KIND,
  317.                             LA_ID,        GAD_CALL_LOGFILE,
  318.                             LA_STRPTR,    Config -> CaptureConfig -> CallLogFileName,
  319.                             LAST_Picker,    TRUE,
  320.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  321.                         TAG_DONE);
  322.  
  323.                         LT_EndGroup(Handle);
  324.                     }
  325.  
  326.                     LT_New(Handle,
  327.                         LA_Type,    VERTICAL_KIND,
  328.                         LA_LabelID,    MSG_V36_0009,
  329.                     TAG_DONE);
  330.                     {
  331.                         LT_New(Handle,
  332.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_ENABLED_GAD,
  333.                             LA_Type,    CHECKBOX_KIND,
  334.                             LA_ID,        GAD_BUFFER_ENABLED,
  335.                             LA_BYTE,    &Config -> CaptureConfig -> BufferEnabled,
  336.                         TAG_DONE);
  337.  
  338.                         LT_New(Handle,
  339.                             LA_LabelID,        MSG_CAPTUREPANEL_MAX_BUFFER_SIZE_GAD,
  340.                             LA_Type,        INTEGER_KIND,
  341.                             LA_ID,            GAD_MAX_BUFFER_SIZE,
  342.                             LA_LONG,        &Config -> CaptureConfig -> MaxBufferSize,
  343.                             LAIN_UseIncrementers,    TRUE,
  344.                             LAIN_Min,        0,
  345.                         TAG_DONE);
  346.  
  347.                         LT_New(Handle,
  348.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_PATH_GAD,
  349.                             LA_Type,    STRING_KIND,
  350.                             LA_ID,        GAD_BUFFER_PATH,
  351.                             LA_STRPTR,    Config -> CaptureConfig -> BufferPath,
  352.                             LAST_Picker,    TRUE,
  353.                             LA_Chars,    10,
  354.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  355.                         TAG_DONE);
  356.  
  357.                         LT_New(Handle,
  358.                             LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_LINE_WIDTH_GAD,
  359.                             LA_Type,        SLIDER_KIND,
  360.                             LA_ID,            GAD_BUFFERWIDTH,
  361.                             LA_UBYTE,        &Config -> CaptureConfig -> BufferWidth,
  362.                             GTSL_Min,        80,
  363.                             GTSL_Max,        BUFFER_LINE_MAX,
  364.                             GTSL_LevelFormat,    "%3ld",
  365.                         TAG_DONE);
  366.  
  367.                         LT_EndGroup(Handle);
  368.                     }
  369.  
  370.                     LT_New(Handle,
  371.                         LA_Type,    VERTICAL_KIND,
  372.                         LA_LabelID,    MSG_V36_0011,
  373.                     TAG_DONE);
  374.                     {
  375.                         LT_New(Handle,
  376.                             LA_Type,    VERTICAL_KIND,
  377.                         TAG_DONE);
  378.                         {
  379.                             LT_New(Handle,
  380.                                 LA_LabelID,    MSG_CAPTUREPANEL_CONNECT_AUTO_CAPTURE_GAD,
  381.                                 LA_Type,    CHECKBOX_KIND,
  382.                                 LA_ID,        GAD_CONNECT_AUTO_CAPTURE,
  383.                                 LA_BYTE,    &Config -> CaptureConfig -> ConnectAutoCapture,
  384.                             TAG_DONE);
  385.     
  386.                             LT_New(Handle,
  387.                                 LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_FILTER_ENABLED_GAD,
  388.                                 LA_Type,    CHECKBOX_KIND,
  389.                                 LA_ID,        GAD_CAPTURE_FILTER,
  390.                                 LA_BYTE,    &Config -> CaptureConfig -> CaptureFilterMode,
  391.                             TAG_DONE);
  392.  
  393.                             LT_EndGroup(Handle);
  394.                         }
  395.  
  396.                         LT_New(Handle,
  397.                             LA_Type,    VERTICAL_KIND,
  398.                         TAG_DONE);
  399.                         {
  400.                             LT_New(Handle,
  401.                                 LA_LabelID,    MSG_CAPTUREPANEL_CREATION_DATE_GAD,
  402.                                 LA_Type,    CYCLE_KIND,
  403.                                 LA_ID,        GAD_AUTOCAPTURE_DATE,
  404.                                 LA_BYTE,    &Config -> CaptureConfig -> AutoCaptureDate,
  405.                                 LACY_FirstLabel,MSG_CAPTUREPANEL_APPEND_DATE_TXT,
  406.                                 LACY_LastLabel,    MSG_CAPTUREPANEL_WRITE_DATE_TO_FILE_TXT,
  407.                             TAG_DONE);
  408.     
  409.                             LT_New(Handle,
  410.                                 LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_PATH_GAD,
  411.                                 LA_Type,    STRING_KIND,
  412.                                 LA_ID,        GAD_CAPTURE_PATH,
  413.                                 LA_Chars,    10,
  414.                                 LA_STRPTR,    Config -> CaptureConfig -> CapturePath,
  415.                                 LAST_Picker,    TRUE,
  416.                                 GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  417.                             TAG_DONE);
  418.  
  419.                             LT_EndGroup(Handle);
  420.                         }
  421.  
  422.                         LT_EndGroup(Handle);
  423.                     }
  424.  
  425.                     LT_EndGroup(Handle);
  426.                 }
  427.  
  428.                 LT_New(Handle,
  429.                     LA_Type,    VERTICAL_KIND,
  430.                 TAG_DONE);
  431.                 {
  432.                     LT_New(Handle,
  433.                         LA_Type,    VERTICAL_KIND,
  434.                         LA_LabelID,    MSG_V36_0013,
  435.                     TAG_DONE);
  436.                     {
  437.                         LT_New(Handle,
  438.                             LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_WINDOW_GAD,
  439.                             LA_Type,    MX_KIND,
  440.                             LA_ID,        GAD_OPEN_BUFFER_WINDOW,
  441.                             LA_BYTE,    &OpenBufferWindow,
  442.                             LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  443.                             LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  444.                         TAG_DONE);
  445.     
  446.                         LT_New(Handle,
  447.                             LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_WINDOW_GAD,
  448.                             LA_Type,    CHECKBOX_KIND,
  449.                             LA_ID,        GAD_REMEMBER_WINDOW_POS,
  450.                             LA_BYTE,    &Config -> CaptureConfig -> RememberBufferWindow,
  451.                         TAG_DONE);
  452.     
  453.                         LT_EndGroup(Handle);
  454.                     }
  455.     
  456.                     LT_New(Handle,
  457.                         LA_Type,    VERTICAL_KIND,
  458.                         LA_LabelID,    MSG_V36_0014,
  459.                     TAG_DONE);
  460.                     {
  461.                         LT_New(Handle,
  462.                             LA_Type,    VERTICAL_KIND,
  463.                         TAG_DONE);
  464.                         {
  465.                             LT_New(Handle,
  466.                                 LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_SCREEN_GAD,
  467.                                 LA_Type,    MX_KIND,
  468.                                 LA_ID,        GAD_OPEN_BUFFER_SCREEN,
  469.                                 LA_BYTE,    &OpenBufferScreen,
  470.                                 LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  471.                                 LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  472.                             TAG_DONE);
  473.         
  474.                             LT_New(Handle,
  475.                                 LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_SCREEN_GAD,
  476.                                 LA_Type,    CHECKBOX_KIND,
  477.                                 LA_ID,        GAD_REMEMBER_SCREEN_POS,
  478.                                 LA_BYTE,    &Config -> CaptureConfig -> RememberBufferScreen,
  479.                             TAG_DONE);
  480.         
  481.                             LT_New(Handle,
  482.                                 LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_SCREEN_POSITION_GAD,
  483.                                 LA_Type,    MX_KIND,
  484.                                 LA_ID,        GAD_BUFFERSCREEN_POSITION,
  485.                                 LA_BYTE,    &Config -> CaptureConfig -> BufferScreenPosition,
  486.                                 LAMX_FirstLabel,MSG_CAPTUREPANEL_LEFT_TXT,
  487.                                 LAMX_LastLabel,    MSG_CAPTUREPANEL_RIGHT_TXT,
  488.                             TAG_DONE);
  489.  
  490.                             LT_EndGroup(Handle);
  491.                         }
  492.  
  493.                         LT_New(Handle,
  494.                             LA_Type,    VERTICAL_KIND,
  495.                         TAG_DONE);
  496.                         {
  497.                             LT_New(Handle,
  498.                                 LA_Type,    TEXT_KIND,
  499.                                 LA_LabelID,    MSG_SCREENPANEL_CURRENT_DISPLAY_MODE_GAD,
  500.                                 LA_Chars,    15,
  501.                                 LA_ID,        GAD_SCREENMODE,
  502.                                 GTTX_Text,    ModeName,
  503.                                 GTTX_Border,    TRUE,
  504.                                 LATX_Picker,    TRUE,
  505.                             TAG_DONE);
  506.     
  507.                             LT_EndGroup(Handle);
  508.                         }
  509.  
  510.                         LT_EndGroup(Handle);
  511.                     }
  512.     
  513.                     LT_New(Handle,
  514.                         LA_Type,    VERTICAL_KIND,
  515.                         LA_LabelID,    MSG_CAPTUREPANEL_SERVICES_TXT,
  516.                     TAG_DONE);
  517.                     {
  518.                         if(Config -> CaptureConfig -> SearchHistory < 1)
  519.                             Config -> CaptureConfig -> SearchHistory = 10;
  520.  
  521.                         LT_New(Handle,
  522.                             LA_LabelID,        MSG_CAPTUREPANEL_SEARCH_HISTORY_GAD,
  523.                             LA_Type,        INTEGER_KIND,
  524.                             LA_ID,            GAD_SEARCH_HISTORY,
  525.                             LA_Chars,        8,
  526.                             LAIN_UseIncrementers,    TRUE,
  527.                             LAIN_Min,        1,
  528.                             LAIN_Max,        255,
  529.                             LA_BYTE,        &Config -> CaptureConfig -> SearchHistory,
  530.                         TAG_DONE);
  531.     
  532.                         LT_EndGroup(Handle);
  533.                     }
  534.     
  535.                     LT_EndGroup(Handle);
  536.                 }
  537.  
  538.                 LT_EndGroup(Handle);
  539.             }
  540.  
  541.             LT_New(Handle,
  542.                 LA_Type,    VERTICAL_KIND,
  543.             TAG_DONE);
  544.             {
  545.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  546.  
  547.                 LT_EndGroup(Handle);
  548.             }
  549.  
  550.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  551.                 LAGR_SameSize,    TRUE,
  552.                 LAGR_Spread,    TRUE,
  553.             TAG_DONE);
  554.             {
  555.                 LT_New(Handle,
  556.                     LA_Type,    BUTTON_KIND,
  557.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  558.                     LA_ID,        GAD_USE,
  559.                     LABT_ReturnKey,    TRUE,
  560.                     LABT_ExtraFat,    TRUE,
  561.                 TAG_DONE);
  562.  
  563.                 if(Default)
  564.                 {
  565.                     LT_New(Handle,
  566.                         LA_Type,    BUTTON_KIND,
  567.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  568.                         LA_ID,        GAD_DEFAULT,
  569.                         LABT_ExtraFat,    TRUE,
  570.                     TAG_DONE);
  571.                 }
  572.  
  573.                 LT_New(Handle,
  574.                     LA_Type,    BUTTON_KIND,
  575.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  576.                     LA_ID,        GAD_CANCEL,
  577.                     LABT_EscKey,    TRUE,
  578.                     LABT_ExtraFat,    TRUE,
  579.                 TAG_DONE);
  580.  
  581.                 LT_EndGroup(Handle);
  582.             }
  583.  
  584.             LT_EndGroup(Handle);
  585.         }
  586.  
  587.         if(PanelWindow = LT_Layout(Handle,LocaleString(MSG_CAPTUREPANEL_CAPTURE_SETTINGS_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  588.             LAWN_HelpHook,        &GuideHook,
  589.             LAWN_Parent,        Window,
  590.             WA_DepthGadget,        TRUE,
  591.             WA_CloseGadget,        TRUE,
  592.             WA_DragBar,        TRUE,
  593.             WA_RMBTrap,        TRUE,
  594.             WA_Activate,        TRUE,
  595.         TAG_DONE))
  596.         {
  597.             struct IntuiMessage    *Message;
  598.             BOOLEAN             Done = FALSE;
  599.             ULONG             MsgClass,
  600.                          MsgQualifier;
  601.             UWORD             MsgCode;
  602.             struct Gadget        *MsgGadget;
  603.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  604.                         *DummyChar;
  605.             struct FileRequester    *FileRequest;
  606.  
  607.             GuideContext(CONTEXT_CAPTURE);
  608.  
  609.             PushWindow(PanelWindow);
  610.  
  611.             LT_ShowWindow(Handle,TRUE);
  612.  
  613.             do
  614.             {
  615.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  616.                 {
  617.                     SaveConfig(PrivateConfig,Config);
  618.  
  619.                     break;
  620.                 }
  621.  
  622.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  623.                 {
  624.                     MsgClass    = Message -> Class;
  625.                     MsgQualifier    = Message -> Qualifier;
  626.                     MsgCode        = Message -> Code;
  627.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  628.  
  629.                     GT_ReplyIMsg(Message);
  630.  
  631.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  632.  
  633.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  634.                     {
  635.                         SaveConfig(PrivateConfig,Config);
  636.  
  637.                         Done = TRUE;
  638.                     }
  639.  
  640.                     if(MsgClass == IDCMP_GADGETUP)
  641.                     {
  642.                         switch(MsgGadget -> GadgetID)
  643.                         {
  644.                             case GAD_USE:
  645.  
  646.                                 Config -> CaptureConfig -> OpenBufferWindow = OpenBufferWindow;
  647.                                 Config -> CaptureConfig -> OpenBufferScreen = OpenBufferScreen;
  648.                                 Config -> CaptureConfig -> BufferScreenMode = DisplayMode;
  649.  
  650.                                 Done = TRUE;
  651.                                 break;
  652.  
  653.                             case GAD_CANCEL:
  654.  
  655.                                 SaveConfig(PrivateConfig,Config);
  656.  
  657.                                 Cancel = Done = TRUE;
  658.                                 break;
  659.  
  660.                             case GAD_DEFAULT:
  661.  
  662.                                 *Default = TRUE;
  663.  
  664.                                 Done = TRUE;
  665.                                 break;
  666.                         }
  667.                     }
  668.  
  669.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  670.                     {
  671.                         switch(MsgGadget -> GadgetID)
  672.                         {
  673.                             case GAD_LOGFILE:
  674.  
  675.                                 LT_LockWindow(PanelWindow);
  676.  
  677.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  678.  
  679.                                 if(DummyBuffer[0])
  680.                                 {
  681.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  682.                                         DummyBuffer[0] = 0;
  683.                                     else
  684.                                     {
  685.                                         DummyChar = PathPart(DummyBuffer);
  686.  
  687.                                         *DummyChar = 0;
  688.                                     }
  689.  
  690.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  691.                                 }
  692.                                 else
  693.                                     DummyChar = "";
  694.  
  695.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  696.                                 {
  697.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  698.  
  699.                                     FreeAslRequest(FileRequest);
  700.                                 }
  701.  
  702.                                 LT_UnlockWindow(PanelWindow);
  703.                                 break;
  704.  
  705.                             case GAD_CALL_LOGFILE:
  706.  
  707.                                 LT_LockWindow(PanelWindow);
  708.  
  709.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  710.  
  711.                                 if(DummyBuffer[0])
  712.                                 {
  713.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  714.                                         DummyBuffer[0] = 0;
  715.                                     else
  716.                                     {
  717.                                         DummyChar = PathPart(DummyBuffer);
  718.  
  719.                                         *DummyChar = 0;
  720.                                     }
  721.  
  722.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  723.                                 }
  724.                                 else
  725.                                     DummyChar = "";
  726.  
  727.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CALL_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  728.                                 {
  729.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  730.  
  731.                                     FreeAslRequest(FileRequest);
  732.                                 }
  733.  
  734.                                 LT_UnlockWindow(PanelWindow);
  735.                                 break;
  736.  
  737.                             case GAD_BUFFER_PATH:
  738.  
  739.                                 LT_LockWindow(PanelWindow);
  740.  
  741.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  742.  
  743.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_BUFFER_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  744.                                 {
  745.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  746.  
  747.                                     FreeAslRequest(FileRequest);
  748.                                 }
  749.  
  750.                                 LT_UnlockWindow(PanelWindow);
  751.                                 break;
  752.  
  753.                             case GAD_CAPTURE_PATH:
  754.  
  755.                                 LT_LockWindow(PanelWindow);
  756.  
  757.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  758.  
  759.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CAPTURE_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  760.                                 {
  761.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  762.  
  763.                                     FreeAslRequest(FileRequest);
  764.                                 }
  765.  
  766.                                 LT_UnlockWindow(PanelWindow);
  767.                                 break;
  768.  
  769.                             case GAD_SCREENMODE:
  770.  
  771.                                 LT_LockWindow(PanelWindow);
  772.  
  773.                                 if(SelectDisplayMode(PanelWindow,&DisplayMode,Config))
  774.                                 {
  775.                                     strcpy(ModeName,GetModeName(DisplayMode));
  776.  
  777.                                     LT_SetAttributes(Handle,GAD_SCREENMODE,GTTX_Text,ModeName,TAG_DONE);
  778.                                 }
  779.  
  780.                                 LT_UnlockWindow(PanelWindow);
  781.  
  782.                                 LT_ShowWindow(Handle,TRUE);
  783.  
  784.                                 break;
  785.                         }
  786.                     }
  787.                 }
  788.             }
  789.             while(!Done);
  790.  
  791.             PopWindow();
  792.         }
  793.  
  794.         LT_DeleteHandle(Handle);
  795.     }
  796.  
  797.     if(Default)
  798.         return((BYTE)(!Cancel));
  799.     else
  800.         return((BYTE)memcmp(PrivateConfig -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings)));
  801. }
  802.