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;
}
}
