gui_window *FindNextMDIMenuWindowNotInArray( gui_window *wnd, gui_window *avoid ) { gui_window *start, *next, *parent; bool done; done = false; start = next = wnd; parent = GUIGetParentWindow( wnd ); while( !done ) { next = GUIGetNextWindow( next ); if( next == NULL ) { next = GUIGetFirstSibling( start ); } if( parent != GUIGetParentWindow( next ) ) { continue; } if( next == start ) { break; } if( ( next != avoid ) && GetIndex( next ) == -1 ) { done = true; } } if( done ) { return( next ); } else { return( NULL ); } }
bool GUIIsParentADialog( gui_window *wnd ) { wnd = GUIGetParentWindow( wnd ); while( wnd ) { if( wnd->flags & IS_DIALOG ) { return( true ); } wnd = GUIGetParentWindow( wnd ); } return( false ); }
void InitMDI( gui_window *wnd, gui_create_info *dlg_info ) { gui_window *root; root = GUIGetRootWindow(); AddMenu( wnd, dlg_info->parent, dlg_info->num_menus, dlg_info->menu ); if( GUIXInitMDI( wnd ) ) { if( dlg_info->parent && ( GUIGetParentWindow( dlg_info->parent ) != NULL ) ) { return; } if( CurrMDIWindow != -1 ) { GUICheckMenuItem( root, MDIWIN2ID( CurrMDIWindow ), false, false ); } NumMDIWindows++; if( NumMDIWindows == 1 ) { EnableMDIMenus( root, true ); } CurrMDIWindow = NumMDIWindows - 1; if( NumMDIWindows > MAX_NUM_MDI_WINDOWS ) { if( NumMDIWindows == MAX_NUM_MDI_WINDOWS + 1 ) { if( GUIMDIMenuID != NO_SELECT ) { MDIMoreMenu[0].label = LIT( XMore_Windows ); MDIMoreMenu[0].hinttext = LIT( More_Windows_Hint ); GUIAppendMenuToPopup( root, GUIMDIMenuID, MDIMoreMenu, false ); } } } else { MDIWindows[CurrMDIWindow] = wnd; InsertMenuForWindow( root, CurrMDIWindow, -1 ); } } else if( Root == NULL ) { Root = wnd; } }
void ActivateNC( gui_window *wnd, bool activate ) { gui_window *current; bool found; if( wnd == NULL ) { return; } found = false; current = wnd; while( current ) { if( current->flags & HAS_CAPTION ) { found = true; break; } current = GUIGetParentWindow( current ); } if( found ) { GUISendMessage( current->hwnd_frame, WM_NCACTIVATE, (WPI_PARAM1)activate, 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 ); } }
void MDIDelete( gui_window *wnd ) { gui_window *root; int index, offset; int i, num_menu_windows; if( wnd == Root ) { Root = NULL; } if( Root == NULL ) { return; } root = GUIGetRootWindow(); // This check will make sure that windows that are not children of // the root window are ignored if( GUIGetParentWindow( wnd ) != root ) { return; } index = GetIndex( wnd ); if( NumMDIWindows == ( MAX_NUM_MDI_WINDOWS + 1 ) ) { GUIDeleteMenuItem( root, GUI_MDI_MORE_WINDOWS, false ); } NumMDIWindows--; if( index != -1 ) { if( index == NumMDIWindows ) { GUIDeleteMenuItem( root, MDIWIN2ID( index ), false ); MDIWindows[index] = NULL; } else { // delete all MDI menu items from this index on num_menu_windows = NumMDIWindows; if( num_menu_windows > MAX_NUM_MDI_WINDOWS - 1 ) num_menu_windows = MAX_NUM_MDI_WINDOWS - 1; for( i = index; i < num_menu_windows; i++ ) { GUIDeleteMenuItem( root, MDIWIN2ID( i ), false ); MDIWindows[i] = MDIWindows[i + 1]; } GUIDeleteMenuItem( root, MDIWIN2ID( num_menu_windows ), false ); MDIWindows[num_menu_windows] = NULL; // re-add all menu items from index on offset = GUIGetMenuPopupCount ( root, GUIMDIMenuID ); if( NumMDIWindows > MAX_NUM_MDI_WINDOWS ) { offset--; } for( i = index; i < num_menu_windows; i++ ) { InsertMenuForWindow( root, i, offset + i - index ); if( CurrMDIWindow == i ) { CurrMDIWindow--; if( CurrMDIWindow < 0 ) { CurrMDIWindow = -1; } else { GUICheckMenuItem( root, MDIWIN2ID( CurrMDIWindow ), true, false ); } } } // Fill in the last spot in the MDIWindows array and insert it // after the 8th element if( NumMDIWindows >= MAX_NUM_MDI_WINDOWS ) { MDIWindows[MAX_NUM_MDI_WINDOWS - 1] = FindNextMDIMenuWindowNotInArray( MDIWindows[MAX_NUM_MDI_WINDOWS - 2], wnd ); if( MDIWindows[MAX_NUM_MDI_WINDOWS - 1] != NULL ) { offset = GUIGetMenuPopupCount( root, GUIMDIMenuID ) - 1; if( NumMDIWindows > MAX_NUM_MDI_WINDOWS ) { offset--; } InsertMenuForWindow( root, MAX_NUM_MDI_WINDOWS - 1, offset ); } } } } if( NumMDIWindows <= 0 ) { EnableMDIMenus( root, false ); CurrMDIWindow = -1; } }