Esempio n. 1
0
STATIC void getDlgValues( gui_window *gui )
/*****************************************/
{
    OptDIFFormat = GUIIsChecked( gui, CTL_DIF_FMT );
    OptCommaFormat = GUIIsChecked( gui, CTL_COMMA_FMT );
    GUIDlgBuffGetText( gui, CTL_NAME, convertPath, sizeof( convertPath ) );
}
Esempio n. 2
0
static void     GetDlgStatus( gui_window *gui, dlg_search *dlg )
{
    GUIMemFree( dlg->wnd->searchitem );
    dlg->wnd->searchitem = GUIGetText( gui, CTL_SRCH_EDIT );
    if( dlg->wnd->searchitem == NULL )
        dlg->direction = 0;
    dlg->case_ignore = GUIIsChecked( gui, CTL_SRCH_CASE );
    dlg->use_rx = GUIIsChecked( gui, CTL_SRCH_RX );
    if( dlg->history != NULL ) {
        WndSaveToHistory( dlg->history, dlg->wnd->searchitem );
    }
}
Esempio n. 3
0
static void GetDlgStatus( gui_window *gui )
{
    long        tmp;
    unsigned    old;

    old = NewCurrRadix( 10 );
    _SwitchSet( SW_AUTO_SAVE_CONFIG, GUIIsChecked( gui, CTL_OPT_AUTO ) );
    _SwitchSet( SW_BELL, GUIIsChecked( gui, CTL_OPT_BELL ) );
    _SwitchSet( SW_IMPLICIT, GUIIsChecked( gui, CTL_OPT_IMPLICIT ) );
    _SwitchSet( SW_RECURSE_CHECK, GUIIsChecked( gui, CTL_OPT_RECURSE ) );
    _SwitchSet( SW_FLIP, GUIIsChecked( gui, CTL_OPT_FLIP ) );
    _SwitchSet( SW_DONT_EXPAND_HEX, GUIIsChecked( gui, CTL_OPT_NOHEX ) );
    LookCaseSet( !GUIIsChecked( gui, CTL_OPT_CASE ) );
    if( DlgGetLong( gui, CTL_OPT_RADIX, &tmp ) ) {
        DefaultRadixSet( tmp );
        old = NewCurrRadix( 10 );
    }
    if( DlgGetLong( gui, CTL_OPT_DCLICK, &tmp ) ) {
        WndSetDClick( tmp );
    }
    NewCurrRadix( old );

    /* Don't change config if it is just the trap file that does not support the option! */
    if( SupportsExactBreakpoints ) {
        _SwitchSet( SW_BREAK_ON_WRITE, GUIIsChecked( gui, CTL_OPT_BR_ON_WRITE ) );
        CapabilitiesSetExactBreakpointSupport( _IsOn( SW_BREAK_ON_WRITE ) ? TRUE : FALSE );
    }
}
Esempio n. 4
0
static void GetVariableVals( gui_window *gui,
                             a_dialog_header *curr_dialog, bool closing )
/***********************************************************************/
/* Get the input variable values. Decide how to set these */
/* default values based on edit control type. */
{
    char                *text;
    int                 i;
    int                 is_checked;
    gui_control_class   a_control_class;
    vhandle             *pVariable;
    vhandle             var_handle;
    bool                drive_checked;

    drive_checked = FALSE;
    pVariable = curr_dialog->pVariables;
    for( i = 0; pVariable[i] != NO_VAR; i++ ) {
        var_handle = pVariable[i];
        a_control_class = ControlClass( VarGetId( var_handle ), curr_dialog );
        switch( a_control_class ) {
        case GUI_STATIC:
            if( !closing ) {
                SetDynamic( gui, var_handle, &drive_checked );
            }
            break;
        case GUI_RADIO_BUTTON:
        case GUI_CHECK_BOX:
            is_checked = (int)GUIIsChecked( gui, VarGetId( var_handle ) );
            if( is_checked ) {
                if( VarIsRestrictedFalse( var_handle ) ) {
                    if( !closing ) {
                        MsgBox( gui, "IDS_NODISKFOROPTION", GUI_OK );
                        GUISetChecked( gui, VarGetId( var_handle ), 0 );
                        if( var_handle == FullInstall ) {
                            GUISetChecked( gui, VarGetId( SelectiveInstall ), 1 );
                        }
                    }
                    SetVariableByHandle( var_handle, "0" );
                    if( var_handle == FullInstall ) {
                        SetVariableByHandle( SelectiveInstall, "1" );
                    }
                } else {
                    SetVariableByHandle( var_handle, "1" );
                }
            } else {
                SetVariableByHandle( var_handle, "0" );
            }
            break;
        case GUI_EDIT:
            text = GUIGetText( gui, VarGetId( var_handle ) );
            if( text != NULL ) {
                SetVariableByHandle( var_handle, text );
                GUIMemFree( text );
            }
            break;
        default:
            break;
        }
    }
}
Esempio n. 5
0
bool GUISetChecked( gui_window *wnd, gui_ctl_id id, unsigned check )
{
    if( ( check == GUI_CHECKED ) && !( wnd->flags & IS_RES_DIALOG ) ) {
        if( GUIIsChecked( wnd, id ) != GUI_CHECKED ) {
            return( GUIProcessControlNotification( id, BN_CLICKED, wnd ) );
        }
    } else {
        GUISendDlgItemMessage( wnd->hwnd, id, BM_SETCHECK, (WPI_PARAM1)check, (WPI_PARAM2)NULL );
    }

    return( true );
}
Esempio n. 6
0
static  void    GetRXStatus( gui_window *gui )
{
    char        *magic;
    int         i;

    magic = SrchMagicChars;
    for( i = CTL_FIRST_RX; i <= CTL_LAST_RX; ++i ) {
        if( GUIIsChecked( gui, i ) ) {
            *magic++ = MetaChar(i);
        }
    }
    *magic = '\0';
}
Esempio n. 7
0
static void SetFocusCtrl( gui_window *gui, a_dialog_header *curr_dialog )
/*************************************************************************/
/* Set the default variable values. Decide how to set these  */
/* default values based on edit control type. */
{
    int                 i, j;

    for( i = 0; i < curr_dialog->num_controls; i++ ) {
        switch( curr_dialog->controls[i].control_class ) {
        case GUI_EDIT_MLE:
        case GUI_EDIT:
            GUISetFocus( gui, curr_dialog->controls[i].id );
            return;
        case GUI_RADIO_BUTTON:
        case GUI_CHECK_BOX:
            for( j = i;; ++j ) {
                if( curr_dialog->controls[j].control_class != GUI_RADIO_BUTTON &&
                    curr_dialog->controls[j].control_class != GUI_CHECK_BOX ) {
                    break;
                }
                if( GUIIsChecked( gui, curr_dialog->controls[j].id ) ) {
                    GUISetFocus( gui, curr_dialog->controls[j].id );
                    return;
                }
            }
            GUISetFocus( gui, curr_dialog->controls[i].id );
            return;
        default:
            break;
        }
    }
    for( i = 0; i < curr_dialog->num_controls; i++ ) {
        if( curr_dialog->controls[i].control_class == GUI_DEFPUSH_BUTTON ) {
            GUISetFocus( gui, curr_dialog->controls[i].id );
            return;
        }
    }
}
Esempio n. 8
0
WCheckState3 WThreeState::checkState() {
/**************************************/

    return( (WCheckState3) GUIIsChecked( parent()->handle(), controlId() ) );
}
Esempio n. 9
0
static void GetDlgStatus( gui_window *gui )
{
    long        tab;
    unsigned    old;

    old = NewCurrRadix( 10 );
    _SwitchSet( SW_ASM_SOURCE, GUIIsChecked( gui, CTL_WIND_ASM_SOURCE ) );
    _SwitchSet( SW_ASM_HEX, GUIIsChecked( gui, CTL_WIND_ASM_HEX ) );
    _SwitchSet( SW_VAR_WHOLE_EXPR, GUIIsChecked( gui, CTL_WIND_VAR_EXPR ) );
    _SwitchSet( SW_VAR_SHOW_CODE, GUIIsChecked( gui, CTL_WIND_VAR_CODE ) );
    _SwitchSet( SW_VAR_SHOW_INHERIT, GUIIsChecked( gui, CTL_WIND_VAR_INHERIT ) );
    _SwitchSet( SW_VAR_SHOW_COMPILER, GUIIsChecked( gui, CTL_WIND_VAR_COMPILER ) );
    _SwitchSet( SW_VAR_SHOW_MEMBERS, GUIIsChecked( gui, CTL_WIND_VAR_MEMBERS ) );
    _SwitchSet( SW_VAR_SHOW_PRIVATE, GUIIsChecked( gui, CTL_WIND_VAR_PRIVATE ) );
    _SwitchSet( SW_VAR_SHOW_PROTECTED, GUIIsChecked( gui, CTL_WIND_VAR_PROTECTED ) );
    _SwitchSet( SW_VAR_SHOW_STATIC, GUIIsChecked( gui, CTL_WIND_VAR_STATIC ) );
    _SwitchSet( SW_FUNC_D2_ONLY, GUIIsChecked( gui, CTL_WIND_FUNC_TYPED ) );
    _SwitchSet( SW_GLOB_D2_ONLY, GUIIsChecked( gui, CTL_WIND_GLOB_TYPED ) );
    _SwitchSet( SW_MOD_ALL_MODULES, GUIIsChecked( gui, CTL_WIND_MOD_ALL ) );
    if( DlgGetLong( gui, CTL_WIND_FILE_TAB, &tab ) ) {
        TabIntervalSet( tab );
    }
    AsmChangeOptions();
    VarChangeOptions();
    FuncChangeOptions();
    GlobChangeOptions();
    ModChangeOptions();
    NewCurrRadix( old );
}
Esempio n. 10
0
static void UpdateControlVisibility( gui_window *gui, a_dialog_header *curr_dialog, bool init )
/*********************************************************************************************/
// Hide controls which have the optional visibility condition evaluate to false, and show
// the ones that have it evaluate to true. (Controls with no vis. condition are always shown.)
// When a control is hidden, the controls BELOW it move up by the hidden control's height.
// A currently hidden controls that needs to be made visible causes all controls BELOW it
// to move down by the "appearing" control's height so that it can be shown again.
// The dialog window height also gets affected, while the top edge remains fixed on the screen.
//
// NOTE: be careful with RADIO_BUTTONS... making radio buttons appear and disappear because of
// other radio buttons in the same dialog being checked may not work (nor does it make sense anyways)
{
    gui_ord             last_height;
    gui_rect            rect;
    gui_rect            control_rect;
    gui_rect            parent_rect;
    gui_window          *parent;
    int                 i, j, sign;
    unsigned            id_i;
    unsigned            id_j;
    unsigned            checked_radio_id = 0;
    unsigned            new_check_candidate;
    unsigned            focus;
    unsigned            new_focus;
    bool                enabled;
    bool                control_on_new_line[MAX_VARS];
    bool                visible_checked_radiobutton;
    vhandle             var_handle;
//    vhandle             *pVariable;

    if( gui == NULL ) return;
    if( init ) {
        // How much the height of the dialog has changed from its original value
        curr_dialog->height_change = 0;

        // The GUIGetRect below gets the dialog's position so that when it is resized,
        // it can be put back in its original position

        // NOTE that GUIGetRect does not want to give the EXACT location of the dialog,
        // so if you set the position to the coordinates that you got with GUIGetRect,
        // the dialog will MOVE slightly (not pleasing to the eye).
        // The current hack is to get the original coordinates, and go back to them every time
        // the dialog is resized with GUIResizeWindow.
        // This way, the dialog will be off by the same amount from the original
        // every time, and not appear to move.
        GUIGetRect( gui, &curr_dialog->original_rect );

        // Make child windows appear in the correct place, since GUIGetRect() gives back
        // a rect that is tranlsated off by the parent's x and y.
        parent = GUIGetParentWindow( gui );
        if( parent != MainWnd && parent != NULL ) {
            GUIGetRect( parent, &parent_rect );
            curr_dialog->original_rect.x -= parent_rect.x;
            curr_dialog->original_rect.y -= parent_rect.y;
        }

        // Return if there are radio buttons
        // because UpdateControlVisibility is going to be called again anyways after init.
        // Without returning, the visibility conditions having to do with radio buttons
        // would not work sometimes.
        // We do not want to return if there are no radio buttons
        // because UpdateControlVisibility will not be called before showing
        // the dialog in that case.
        for( i = 0; i < curr_dialog->num_controls; i++ ) {
            if( curr_dialog->controls[i].control_class == GUI_RADIO_BUTTON ) {
                return;
            }
        }
    }
    memcpy( &rect, &curr_dialog->original_rect, sizeof( gui_rect ) );
    last_height = rect.height + curr_dialog->height_change;

    control_on_new_line[0] = TRUE;

    GUIGetFocus( gui, &focus );

    // Figure out which controls are on a separate line from the last control
    for( i = 1; i < curr_dialog->num_controls; i++ ) {
        if( curr_dialog->controls[i].rect.y >
            curr_dialog->controls[i - 1].rect.y ) {
            control_on_new_line[i] = TRUE;
        } else {
            control_on_new_line[i] = FALSE;
        }
    }

    // Initialize Variables corresponding to radio buttons and check boxes
    // This needs to be done for the part further below that checks to see if any
    // buttons are checked to work.
    // Also, figure out which radio button is currently checked.

    for( i = 0; i < curr_dialog->num_controls; i++ ) {
        if( curr_dialog->controls[i].control_class == GUI_RADIO_BUTTON ||
            curr_dialog->controls[i].control_class == GUI_CHECK_BOX ) {
//            pVariable = curr_dialog->pVariables;
            var_handle = curr_dialog->controls[i].id;
            if( curr_dialog->controls[i].control_class == GUI_RADIO_BUTTON &&
                GUIIsChecked( gui, VarGetId( var_handle ) ) ) {
                checked_radio_id = var_handle;
            }
            for( j = 0; curr_dialog->pVariables[j] != NO_VAR; j++ ) {
                if( curr_dialog->pVariables[j] == var_handle &&
                    GUIIsChecked( gui, VarGetId( var_handle ) ) ) {
                    SetVariableByHandle( var_handle, "1" );
                }
            }
        }
    }

    // Allow EvalCondition to evaluate conditions with no 'shortcuts'
    // (See GetOptionVarValue() in setupinf.c)
    // Kind of like an on and off (below) switch
    // for special behaviour of GetOptionVarValue()
    // SetVariableByName( "_Visibility_Condition_", "1" );
    VisibilityCondition = 1;

    for( i = 0; i < curr_dialog->num_controls; i++ ) {
    // Figure out which controls to hide and which to show.
    // Move all the controls below any control in transition
    // either up or down.

        if( curr_dialog->pVisibilityConds[i] != NULL ) {
            id_i = curr_dialog->controls[i].id;
            enabled = GUIIsControlEnabled( gui, id_i );
            if( EvalCondition( curr_dialog->pVisibilityConds[i] ) ) {
                if( !enabled ) {
                    GUIEnableControl( gui, id_i, TRUE );
                    sign = 1;
                } else {
                    continue;
                }
            } else if( enabled ) {
                GUIEnableControl( gui, id_i, FALSE );
                GUIHideControl( gui, curr_dialog->controls[i].id );
                sign = -1;
            } else {
                continue;
            }
            if( control_on_new_line[i] ) {
                for( j = i + 1; j < curr_dialog->num_controls &&
                                !control_on_new_line[j]; j++ );
                for( ; j < curr_dialog->num_controls; j++ ) {
                    id_j = curr_dialog->controls[j].id;
                    enabled = GUIIsControlEnabled( gui, id_j );
                    GUIGetControlRect( gui, curr_dialog->controls[j].id, &control_rect );
                    control_rect.y += curr_dialog->controls[i].rect.height * sign;
                    if( enabled ) {
                        GUIHideControl( gui, id_j );
                        // control will be made visible again below
                        // after being moved.
                    }
                    GUIResizeControl( gui, id_j, &control_rect );
                }
                curr_dialog->height_change += curr_dialog->controls[i].rect.height * sign;
            }
        }
    }

    // SetVariableByName( "_Visibility_Condition_", "0" );
    VisibilityCondition = 0;

    visible_checked_radiobutton = FALSE;
    new_check_candidate = 0;

    for( i = 0; i < curr_dialog->num_controls; i++ ) {
        id_i = curr_dialog->controls[i].id;

        // figure out if there are no enabled radio buttons that are checked
        // use this info further down...
        if( curr_dialog->controls[i].control_class == GUI_RADIO_BUTTON &&
            !visible_checked_radiobutton && GUIIsControlEnabled( gui, id_i ) ) {
            if( GUIIsChecked( gui, id_i ) == GUI_CHECKED ) {
                visible_checked_radiobutton = TRUE;
            } else if( new_check_candidate == 0 ) {
                new_check_candidate = id_i;
            }
        }

        // show enabled controls that were hidden for moving only
        if( GUIIsControlEnabled( gui, id_i ) && !GUIIsControlVisible( gui, id_i ) ) {
            GUIShowControl( gui, id_i );
        }
    }

    // Keep the original focus in case it has changed.
    GUIGetFocus( gui, &new_focus );
    if( new_focus != focus && GUIIsControlEnabled( gui, focus ) ) {
        GUISetFocus( gui, focus );
    }

    if( GUIIsControlEnabled( gui, checked_radio_id ) ) {
        GUISetChecked( gui, checked_radio_id, 1 );
    } else if( !visible_checked_radiobutton && new_check_candidate != 0 ) {
        // 'Check' a visible radio button if the currently checked button
        // is invisible.
        GUISetChecked( gui, new_check_candidate, 1 );
    }

    rect.height += curr_dialog->height_change;

    if( rect.height != last_height ) {
        GUIResizeWindow( gui, &rect );
    }
}
Esempio n. 11
0
bool WEXPORT WBoolSwitch::checked() {
/***********************************/

    return( GUIIsChecked( parent()->handle(), controlId() ) != 0 );
}