void do_object_window() { object *obj=&Objects[Cur_object_index]; if ( MattWindow == NULL ) return; //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MattWindow); if ( QuitButton->pressed || (last_keypress==KEY_ESC)) { if (InitialMode[0]->flag) obj->movement_type = MT_NONE; if (InitialMode[1]->flag) obj->movement_type = MT_SPINNING; obj->mtype.spin_rate.x = fl2f(atof(Xtext->text)); obj->mtype.spin_rate.y = fl2f(atof(Ytext->text)); obj->mtype.spin_rate.z = fl2f(atof(Ztext->text)); object_close_window(); return; } old_object = Cur_object_index; }
int GetKeyCode(char * text) { UI_WINDOW * wnd; UI_GADGET_BUTTON * DoneButton; char temp_text[100]; text = text; wnd = ui_open_window( 200, 200, 400, 200, WIN_DIALOG ); DoneButton = ui_add_gadget_button( wnd, 170, 165, 60, 25, "Ok", NULL ); ui_gadget_calc_keys(wnd); //key_flush(); wnd->keyboard_focus_gadget = (UI_GADGET *)DoneButton; while(1) { ui_mega_process(); ui_window_do_gadgets(wnd); if (last_keypress > 0) { GetKeyDescription( temp_text, last_keypress ); ui_wprintf_at( wnd, 10, 100, "%s ", temp_text ); } if (DoneButton->pressed) break; } ui_close_window(wnd); return 0; }
void do_robot_window() { int i; fix DeltaTime, Temp; int first_object_index; if ( MainWindow == NULL ) return; first_object_index = Cur_object_index; while (!is_legal_type_for_this_window(Cur_object_index)) { LocalObjectSelectNextinMine(); if (first_object_index == Cur_object_index) { break; } } //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MainWindow); //------------------------------------------------------------ // If we change objects, we need to reset the ui code for all // of the radio buttons that control the ai mode. Also makes // the current AI mode button be flagged as pressed down. //------------------------------------------------------------ if (old_object != Cur_object_index ) { for ( i=0; i < NUM_BOXES; i++ ) { InitialMode[i]->flag = 0; // Tells ui that this button isn't checked InitialMode[i]->status = 1; // Tells ui to redraw button } if ( Cur_object_index > -1 ) { int behavior = Objects[Cur_object_index].ctype.ai_info.behavior; if ( !((behavior >= MIN_BEHAVIOR) && (behavior <= MAX_BEHAVIOR))) { Objects[Cur_object_index].ctype.ai_info.behavior = AIB_NORMAL; behavior = AIB_NORMAL; } InitialMode[behavior - MIN_BEHAVIOR]->flag = 1; // Mark this button as checked } } //------------------------------------------------------------ // If any of the radio buttons that control the mode are set, then // update the cooresponding AI state. //------------------------------------------------------------ for ( i=0; i < NUM_BOXES; i++ ) { if ( InitialMode[i]->flag == 1 ) if (Objects[Cur_object_index].ctype.ai_info.behavior != MIN_BEHAVIOR+i) { Objects[Cur_object_index].ctype.ai_info.behavior = MIN_BEHAVIOR+i; // Set the ai_state to the cooresponding radio button call_init_ai_object(&Objects[Cur_object_index], MIN_BEHAVIOR+i); } } //------------------------------------------------------------ // A simple frame time counter for spinning the objects... //------------------------------------------------------------ Temp = timer_get_fixed_seconds(); DeltaTime = Temp - Time; Time = Temp; //------------------------------------------------------------ // Redraw the object in the little 64x64 box //------------------------------------------------------------ if (Cur_object_index > -1 ) { int id; gr_set_current_canvas( RobotViewBox->canvas ); id = get_object_id(&Objects[Cur_object_index]); if ( id > -1 ) draw_robot_picture(id, &angles, -1 ); else gr_clear_canvas( CGREY ); angles.h += fixmul(0x1000, DeltaTime ); } else { // no object, so just blank out gr_set_current_canvas( RobotViewBox->canvas ); gr_clear_canvas( CGREY ); // LocalObjectSelectNextInMine(); } //------------------------------------------------------------ // Redraw the contained object in the other little box //------------------------------------------------------------ if ((Cur_object_index > -1 ) && (Cur_goody_count > 0)) { int id; gr_set_current_canvas( ContainsViewBox->canvas ); id = Cur_goody_id; if ( id > -1 ) { int ol_type=0; if (Cur_goody_type == OBJ_ROBOT) ol_type = OL_ROBOT; else if (Cur_goody_type == OBJ_POWERUP) ol_type = OL_POWERUP; else Int3(); // Error? Unknown goody type! draw_robot_picture(id, &goody_angles, ol_type ); } else gr_clear_canvas( CGREY ); goody_angles.h += fixmul(0x1000, DeltaTime ); } else { // no object, so just blank out gr_set_current_canvas( ContainsViewBox->canvas ); gr_clear_canvas( CGREY ); // LocalObjectSelectNextInMine(); } //------------------------------------------------------------ // If anything changes in the ui system, redraw all the text that // identifies this robot. //------------------------------------------------------------ if (ui_button_any_drawn || (old_object != Cur_object_index) ) { int i; char type_text[STRING_LENGTH+1],id_text[STRING_LENGTH+1]; if (Cur_object_index != -1) { Cur_goody_type = Objects[Cur_object_index].contains_type; Cur_goody_id = Objects[Cur_object_index].contains_id; if (Objects[Cur_object_index].contains_count < 0) Objects[Cur_object_index].contains_count = 0; Cur_goody_count = Objects[Cur_object_index].contains_count; } ui_wprintf_at( MainWindow, GOODY_X, GOODY_Y, " Type:"); ui_wprintf_at( MainWindow, GOODY_X, GOODY_Y+24, " ID:"); ui_wprintf_at( MainWindow, GOODY_X, GOODY_Y+48, "Count:"); for (i=0; i<STRING_LENGTH; i++) id_text[i] = ' '; id_text[i] = 0; switch (Cur_goody_type) { case OBJ_ROBOT: strcpy(type_text, "Robot "); strncpy(id_text, Robot_names[Cur_goody_id], strlen(Robot_names[Cur_goody_id])); break; case OBJ_POWERUP: strcpy(type_text, "Powerup"); strncpy(id_text, Powerup_names[Cur_goody_id], strlen(Powerup_names[Cur_goody_id])); break; default: editor_status("Illegal contained object type (%i), changing to powerup.", Cur_goody_type); Cur_goody_type = OBJ_POWERUP; Cur_goody_id = 0; strcpy(type_text, "Powerup"); strncpy(id_text, Powerup_names[Cur_goody_id], strlen(Powerup_names[Cur_goody_id])); break; } ui_wprintf_at( MainWindow, GOODY_X+108, GOODY_Y, type_text); ui_wprintf_at( MainWindow, GOODY_X+108, GOODY_Y+24, id_text); ui_wprintf_at( MainWindow, GOODY_X+108, GOODY_Y+48, "%i", Cur_goody_count); if ( Cur_object_index > -1 ) { int id = Objects[Cur_object_index].id; char id_text[12]; int i; for (i=0; i<STRING_LENGTH; i++) id_text[i] = ' '; id_text[i] = 0; strncpy(id_text, Robot_names[id], strlen(Robot_names[id])); ui_wprintf_at( MainWindow, 12, 6, "Robot: %3d ", Cur_object_index ); ui_wprintf_at( MainWindow, 12, 22, " Id: %3d", id); ui_wprintf_at( MainWindow, 12, 38, " Name: %8s", id_text); } else { ui_wprintf_at( MainWindow, 12, 6, "Robot: none" ); ui_wprintf_at( MainWindow, 12, 22, " Type: ? " ); ui_wprintf_at( MainWindow, 12, 38, " Name: ________" ); } Update_flags |= UF_WORLD_CHANGED; } if ( QuitButton->pressed || (last_keypress==KEY_ESC)) { robot_close_window(); return; } old_object = Cur_object_index; }
void do_hostage_window() { fix DeltaTime, Temp; if ( MainWindow == NULL ) return; SelectClosestHostage(); //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MainWindow); //------------------------------------------------------------ // If we change objects, we need to reset the ui code for all // of the radio buttons that control the ai mode. Also makes // the current AI mode button be flagged as pressed down. //------------------------------------------------------------ if (LastHostageIndex != CurrentHostageIndex ) { if ( CurrentHostageIndex > -1 ) strcpy( HostageText->text, Hostages[CurrentHostageIndex].text ); else strcpy(HostageText->text, " " ); HostageText->position = strlen(HostageText->text); HostageText->oldposition = HostageText->position; HostageText->status=1; HostageText->first_time = 1; } //------------------------------------------------------------ // If any of the radio buttons that control the mode are set, then // update the cooresponding AI state. //------------------------------------------------------------ if ( CurrentHostageIndex > -1 ) strcpy( Hostages[CurrentHostageIndex].text, HostageText->text ); //------------------------------------------------------------ // A simple frame time counter for spinning the objects... //------------------------------------------------------------ Temp = timer_get_fixed_seconds(); DeltaTime = Temp - Time; Time = Temp; //------------------------------------------------------------ // Redraw the object in the little 64x64 box //------------------------------------------------------------ if (CurrentHostageIndex > -1 ) { int vclip_num; vclip_num = Hostages[CurrentHostageIndex].vclip_num; Assert(vclip_num != -1); gr_set_current_canvas( HostageViewBox->canvas ); if ( vclip_num > -1 ) { vclip_play( &Hostage_face_clip[vclip_num], DeltaTime ); } else { gr_clear_canvas( CGREY ); } } else { // no hostage, so just blank out gr_set_current_canvas( HostageViewBox->canvas ); gr_clear_canvas( CGREY ); } //------------------------------------------------------------ // If anything changes in the ui system, redraw all the text that // identifies this robot. //------------------------------------------------------------ if (ui_button_any_drawn || (LastHostageIndex != CurrentHostageIndex) ) { if ( CurrentHostageIndex > -1 ) { ui_wprintf_at( MainWindow, 10, 15, "Hostage: %d Object: %d", CurrentHostageIndex, Hostages[CurrentHostageIndex].objnum ); //@@ui_wprintf_at( MainWindow, 10, 73, "Type: %d Sound: %d ", Hostages[CurrentHostageIndex].type, Hostages[CurrentHostageIndex].sound_num ); ui_wprintf_at( MainWindow, 10, 73, "Face: %d ", Hostages[CurrentHostageIndex].vclip_num); } else { ui_wprintf_at( MainWindow, 10, 15, "Hostage: none " ); //@@ui_wprintf_at( MainWindow, 10, 73, "Type: Sound: " ); ui_wprintf_at( MainWindow, 10, 73, "Face: " ); } Update_flags |= UF_WORLD_CHANGED; } if ( QuitButton->pressed || (last_keypress==KEY_ESC)) { hostage_close_window(); return; } LastHostageIndex = CurrentHostageIndex; }
// --------------------------------------------------------------------------------------------------- //this function is the editor. called when editor mode selected. runs until //game mode or exit selected void editor(void) { int w,h; grsBitmap * savedbitmap; editorView *new_cv; static int padnum=0; vmsMatrix MouseRotMat,tempm; //@@short camera_objnum; //a camera for viewing init_editor(); InitCurve(); RestoreEffectBitmapIcons(); if (!SetScreenMode(SCREEN_EDITOR)) { SetScreenMode(SCREEN_GAME); gameStates.app.nFunctionMode=FMODE_GAME; //force back into game return; } GrSetCurrentCanvas( NULL ); GrSetCurFont(editor_font); //Editor renders into full (320x200) game screen SetWarnFunc(med_show_warning); gameStates.input.keys.bRepeat = 1; // Allow repeat in editor // _MARK_("start of editor");//Nuked to compile -KRB ui_mouse_hide(); ui_reset_idleSeconds(); gameData.objs.viewer = gameData.objs.console; slew_init(gameData.objs.console); UpdateFlags = UF_ALL; medlisp_update_screen(); //set the wire-frame window to be the current view currentView = &LargeView; if (faded_in==0) { faded_in = 1; //gr_pal_fade_in( grdCurScreen->pal ); } w = GameViewBox->canvas->cvBitmap.bmProps.w; h = GameViewBox->canvas->cvBitmap.bmProps.h; savedbitmap = GrCreateBitmap(w, h ); GrBmUBitBlt( w, h, 0, 0, 0, 0, &GameViewBox->canvas->cvBitmap, savedbitmap ); GrSetCurrentCanvas( GameViewBox->canvas ); GrSetCurFont(editor_font); //GrSetColor( CBLACK ); //gr_deaccent_canvas(); //gr_grey_canvas(); ui_mouse_show(); GrSetCurFont(editor_font); ui_pad_goto(padnum); gamestate_restore_check(); while (gameStates.app.nFunctionMode == FMODE_EDITOR) { GrSetCurFont(editor_font); info_display_all(EditorWindow); ModeFlag = 0; // Update the windows // Only update if there is no key waiting and we're not in // fast play mode. if (!KeyPeekKey()) //-- && (MacroStatus != UI_STATUS_FASTPLAY)) medlisp_update_screen(); //do editor stuff GrSetCurFont(editor_font); ui_mega_process(); last_keypress &= ~KEYDBGGED; // mask off delete key bit which has no function in editor. ui_window_do_gadgets(EditorWindow); doRobot_window(); doObject_window(); do_wall_window(); do_trigger_window(); do_hostage_window(); do_centers_window(); check_wall_validity(); Assert(gameData.walls.nWalls>=0); if (Gameview_lockstep) { static tSegment *old_cursegp=NULL; static int old_curside=-1; if (old_cursegp!=Cursegp || old_curside!=Curside) { SetPlayerFromCursegMinusOne(); old_cursegp = Cursegp; old_curside = Curside; } } if ( ui_get_idleSeconds() > COMPRESS_INTERVAL ) { med_compress_mine(); ui_reset_idleSeconds(); } // Commented out because it occupies about 25% of time in twirling the mine. // Removes some Asserts.... // med_check_all_vertices(); clear_editor_status(); // if enough time elapsed, clear editor status message TimedAutosave(mine_filename); set_editorTime_of_day(); GrSetCurrentCanvas( GameViewBox->canvas ); // Remove keys used for slew switch(last_keypress) { case KEY_PAD9: case KEY_PAD7: case KEY_PADPLUS: case KEY_PADMINUS: case KEY_PAD8: case KEY_PAD2: case KEY_LBRACKET: case KEY_RBRACKET: case KEY_PAD1: case KEY_PAD3: case KEY_PAD6: case KEY_PAD4: last_keypress = 0; } if ((last_keypress&0xff)==KEY_LSHIFT) last_keypress=0; if ((last_keypress&0xff)==KEY_RSHIFT) last_keypress=0; if ((last_keypress&0xff)==KEY_LCTRL) last_keypress=0; if ((last_keypress&0xff)==KEY_RCTRL) last_keypress=0; // if ((last_keypress&0xff)==KEY_LALT) last_keypress=0; // if ((last_keypress&0xff)==KEY_RALT) last_keypress=0; GrSetCurFont(editor_font); menubar_do( last_keypress ); //=================== DO FUNCTIONS ==================== if ( KeyFunction[ last_keypress ] != NULL ) { KeyFunction[last_keypress](); last_keypress = 0; } switch (last_keypress) { case 0: case KEY_Z: case KEY_G: case KEY_LALT: case KEY_RALT: case KEY_LCTRL: case KEY_RCTRL: case KEY_LSHIFT: case KEY_RSHIFT: case KEY_LAPOSTRO: break; case KEY_SHIFTED + KEY_L: ToggleLighting(); break; case KEY_F1: render_3d_in_big_window = !render_3d_in_big_window; UpdateFlags |= UF_ALL; break; default: { char kdesc[100]; GetKeyDescription( kdesc, last_keypress ); editor_status("Error: %s isn't bound to anything.", kdesc ); } } //================================================================ if (ModeFlag==1) { close_editor_screen(); gameStates.app.nFunctionMode=FMODE_EXIT; GrFreeBitmap( savedbitmap ); break; } if (ModeFlag==2) //-- && MacroStatus==UI_STATUS_NORMAL ) { ui_mouse_hide(); gameStates.app.nFunctionMode = FMODE_GAME; GrBmUBitBlt( w, h, 0, 0, 0, 0, savedbitmap, &GameViewBox->canvas->cvBitmap); GrFreeBitmap( savedbitmap ); break; } if (ModeFlag==3) //-- && MacroStatus==UI_STATUS_NORMAL ) { // med_compress_mine(); //will be called anyways before game. close_editor_screen(); gameStates.app.nFunctionMode=FMODE_GAME; //force back into game SetScreenMode(SCREEN_GAME); //put up game screen GrFreeBitmap( savedbitmap ); break; } // if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)GameViewBox) currentView=NULL; // if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)GroupViewBox) currentView=NULL; new_cv = currentView ; #if ORTHO_VIEWS if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)LargeViewBox) new_cv=&LargeView; if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)TopViewBox) new_cv=&TopView; if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)FrontViewBox) new_cv=&FrontView; if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)RightViewBox) new_cv=&RightView; #endif if (new_cv != currentView ) { currentView->ev_changed = 1; new_cv->ev_changed = 1; currentView = new_cv; } CalcFrameTime(); if (slew_frame(0)) { //do movement and check keys UpdateFlags |= UF_GAME_VIEW_CHANGED; if (Gameview_lockstep) { Cursegp = &gameData.segs.segments[gameData.objs.console->nSegment]; med_create_new_segment_from_cursegp(); UpdateFlags |= UF_ED_STATE_CHANGED; } } // DO TEXTURE STUFF texpage_do(); objpage_do(); // Process selection of Cursegp using mouse. if (LargeViewBox->mouse_onme && LargeViewBox->b1_clicked && !render_3d_in_big_window) { int xcrd,ycrd; xcrd = LargeViewBox->b1_drag_x1; ycrd = LargeViewBox->b1_drag_y1; find_segments(xcrd,ycrd,LargeViewBox->canvas,&LargeView,Cursegp,Big_depth); // Sets globals N_found_segs, Found_segs // If shift is down, then add tSegment to found list if (gameStates.input.keys.pressed[ KEY_LSHIFT ] || gameStates.input.keys.pressed[ KEY_RSHIFT ]) subtract_found_segments_from_selected_list(); else add_found_segments_to_selected_list(); Found_seg_index = 0; if (N_found_segs > 0) { sort_seg_list(N_found_segs,Found_segs,&gameData.objs.console->position.vPos); Cursegp = &gameData.segs.segments[Found_segs[0]]; med_create_new_segment_from_cursegp(); if (LockView_to_cursegp) setView_target_from_segment(Cursegp); } UpdateFlags |= UF_ED_STATE_CHANGED | UF_VIEWPOINT_MOVED; } if (GameViewBox->mouse_onme && GameViewBox->b1_dragging) { int x, y; x = GameViewBox->b1_drag_x2; y = GameViewBox->b1_drag_y2; ui_mouse_hide(); GrSetCurrentCanvas( GameViewBox->canvas ); GrSetColor( 15 ); GrRect( x-1, y-1, x+1, y+1 ); ui_mouse_show(); } // Set current tSegment and tSide by clicking on a polygon in game window. // If ctrl pressed, also assign current texture map to that tSide. //if (GameViewBox->mouse_onme && (GameViewBox->b1_done_dragging || GameViewBox->b1_clicked)) { if ((GameViewBox->mouse_onme && GameViewBox->b1_clicked && !render_3d_in_big_window) || (LargeViewBox->mouse_onme && LargeViewBox->b1_clicked && render_3d_in_big_window)) { int xcrd,ycrd; int seg,tSide,face,poly,tmap; if (render_3d_in_big_window) { xcrd = LargeViewBox->b1_drag_x1; ycrd = LargeViewBox->b1_drag_y1; } else { xcrd = GameViewBox->b1_drag_x1; ycrd = GameViewBox->b1_drag_y1; } //Int3(); if (FindSegSideFace(xcrd,ycrd,&seg,&tSide,&face,&poly)) { if (seg<0) { //found an tObject CurObject_index = -seg-1; editor_status("Object %d selected.",CurObject_index); UpdateFlags |= UF_ED_STATE_CHANGED; } else { // See if either shift key is down and, if so, assign texture map if (gameStates.input.keys.pressed[KEY_LSHIFT] || gameStates.input.keys.pressed[KEY_RSHIFT]) { Cursegp = &gameData.segs.segments[seg]; Curside = tSide; AssignTexture(); med_create_new_segment_from_cursegp(); editor_status("Texture assigned"); } else if (gameStates.input.keys.pressed[KEY_G]) { tmap = gameData.segs.segments[seg].sides[tSide].nBaseTex; texpage_grab_current(tmap); editor_status( "Texture grabbed." ); } else if (gameStates.input.keys.pressed[ KEY_LAPOSTRO] ) { ui_mouse_hide(); moveObject_to_mouse_click(); } else { Cursegp = &gameData.segs.segments[seg]; Curside = tSide; med_create_new_segment_from_cursegp(); editor_status("Curseg and curside selected"); } } UpdateFlags |= UF_ED_STATE_CHANGED; } else editor_status("Click on non-texture ingored"); } // Allow specification of LargeView using mouse if (gameStates.input.keys.pressed[ KEY_LCTRL ] || gameStates.input.keys.pressed[ KEY_RCTRL ]) { ui_mouse_hide(); if ( (Mouse.dx!=0) && (Mouse.dy!=0) ) { GetMouseRotation( Mouse.dx, Mouse.dy, &MouseRotMat ); VmMatMul(&tempm,&LargeView.ev_matrix,&MouseRotMat); LargeView.ev_matrix = tempm; LargeView.ev_changed = 1; LargeView_index = -1; // say not one of the orthogonal views } } else { ui_mouse_show(); } if ( gameStates.input.keys.pressed[ KEY_Z ] ) { ui_mouse_hide(); if ( Mouse.dy!=0 ) { currentView->evDist += Mouse.dy*10000; currentView->ev_changed = 1; } } else { ui_mouse_show(); } } // _MARK_("end of editor");//Nuked to compile -KRB ClearWarnFunc(med_show_warning); //kill our camera tObject gameData.objs.viewer = gameData.objs.console; //reset viewer //@@ReleaseObject(camera_objnum); padnum = ui_pad_get_current(); close_editor(); ui_close(); }
int PopupMenu( int NumButtons, char * text[] ) { UI_WINDOW * wnd; UI_GADGET_BUTTON * ButtonG[10]; short SavedMouseX, SavedMouseY; char * Button[10]; int button_width, button_height, width, height; short i, x, y; short w, h; int choice; ui_mouse_flip_buttons(); //ui_mouse_process(); if ( B1_RELEASED ) { ui_mouse_flip_buttons(); return -1; } if ((NumButtons < 1) || (NumButtons>10)) { ui_mouse_flip_buttons(); return -1; } SavedMouseX = Mouse.x; SavedMouseY = Mouse.y; button_width = button_height = 0; gr_set_current_canvas( &grd_curscreen->sc_canvas ); for (i=0; i<NumButtons; i++ ) { Button[i] = text[i]; ui_get_button_size( Button[i], &width, &height ); if ( width > button_width ) button_width = width; if ( height > button_height ) button_height = height; } width = button_width + 2*(MENU_BORDER+3); height = (button_height*NumButtons) + (MENU_VERT_SPACING*(NumButtons-1)) ; height += (MENU_BORDER+3) * 2; x = Mouse.x - width/2; y = Mouse.y - (MENU_BORDER+3) - button_height/2; w = grd_curscreen->sc_w; h = grd_curscreen->sc_h; if (x < 0 ) { x = 0; Mouse.x = x + width / 2; } if ( (x+width-1) >= w ) { x = w - width; Mouse.x = x + width / 2; } if (y < 0 ) { y = 0; Mouse.y = y + (MENU_BORDER+3) + button_height/2; } if ( (y+height-1) >= h ) { y = h - height; Mouse.y = y + (MENU_BORDER+3) + button_height/2; } wnd = ui_open_window( x, y, width, height, WIN_DIALOG ); mouse_set_pos( Mouse.x, Mouse.y ); x = MENU_BORDER+3; y = MENU_BORDER+3; for (i=0; i<NumButtons; i++ ) { ButtonG[i] = ui_add_gadget_button( wnd, x, y, button_width, button_height, Button[i], NULL ); y += button_height+MENU_VERT_SPACING; } choice = 0; while(choice==0) { ui_mega_process(); ui_window_do_gadgets(wnd); for (i=0; i<NumButtons; i++ ) { if (ButtonG[i]->pressed) { choice = i+1; break; } } if ( (choice==0) && B1_JUST_RELEASED ) { choice = -1; break; } } ui_close_window(wnd); ui_mouse_flip_buttons(); return choice; }
void do_wall_window() { int i; sbyte type; fix DeltaTime, Temp; if ( MainWindow == NULL ) return; //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MainWindow); //------------------------------------------------------------ // If we change walls, we need to reset the ui code for all // of the checkboxes that control the wall flags. //------------------------------------------------------------ if (old_wall_num != Cursegp->sides[Curside].wall_num) { for ( i=0; i < 3; i++ ) { DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked DoorFlag[i]->status = 1; // Tells ui to redraw button } for ( i=0; i < 4; i++ ) { KeyFlag[i]->flag = 0; // Tells ui that this button isn't checked KeyFlag[i]->status = 1; // Tells ui to redraw button } if ( Cursegp->sides[Curside].wall_num != -1) { if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_DOOR_LOCKED) DoorFlag[0]->flag = 1; // Mark this button as checked if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_DOOR_AUTO) DoorFlag[1]->flag = 1; // Mark this button as checked if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_ILLUSION_OFF) DoorFlag[2]->flag = 1; // Mark this button as checked if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_NONE) KeyFlag[0]->flag = 1; if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_BLUE) KeyFlag[1]->flag = 1; if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_RED) KeyFlag[2]->flag = 1; if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_GOLD) KeyFlag[3]->flag = 1; } } //------------------------------------------------------------ // If any of the checkboxes that control the wallflags are set, then // update the corresponding wall flag. //------------------------------------------------------------ if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_DOOR) { if ( DoorFlag[0]->flag == 1 ) Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_LOCKED; else Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_LOCKED; if ( DoorFlag[1]->flag == 1 ) Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_AUTO; else Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_AUTO; //------------------------------------------------------------ // If any of the radio buttons that control the mode are set, then // update the corresponding key. //------------------------------------------------------------ for ( i=0; i < 4; i++ ) { if ( KeyFlag[i]->flag == 1 ) { Walls[Cursegp->sides[Curside].wall_num].keys = 1<<i; // Set the ai_state to the cooresponding radio button } } } else { for ( i=0; i < 2; i++ ) if (DoorFlag[i]->flag == 1) { DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked DoorFlag[i]->status = 1; // Tells ui to redraw button } for ( i=0; i < 4; i++ ) { if ( KeyFlag[i]->flag == 1 ) { KeyFlag[i]->flag = 0; KeyFlag[i]->status = 1; } } } if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_ILLUSION) { if ( DoorFlag[2]->flag == 1 ) Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_ILLUSION_OFF; else Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_ILLUSION_OFF; } else for ( i=2; i < 3; i++ ) if (DoorFlag[i]->flag == 1) { DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked DoorFlag[i]->status = 1; // Tells ui to redraw button } //------------------------------------------------------------ // A simple frame time counter for animating the walls... //------------------------------------------------------------ Temp = timer_get_fixed_seconds(); DeltaTime = Temp - Time; //------------------------------------------------------------ // Draw the wall in the little 64x64 box //------------------------------------------------------------ gr_set_current_canvas( WallViewBox->canvas ); if (Cursegp->sides[Curside].wall_num != -1) { type = Walls[Cursegp->sides[Curside].wall_num].type; if ((type == WALL_DOOR) || (type == WALL_BLASTABLE)) { if (DeltaTime > ((F1_0*200)/1000)) { framenum++; Time = Temp; } if (framenum >= WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].num_frames) framenum=0; PIGGY_PAGE_IN(Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[framenum]]); gr_ubitmap(0,0, &GameBitmaps[Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[framenum]].index]); } else { if (type == WALL_OPEN) gr_clear_canvas( CBLACK ); else { if (Cursegp->sides[Curside].tmap_num2 > 0) gr_ubitmap(0,0, texmerge_get_cached_bitmap( Cursegp->sides[Curside].tmap_num, Cursegp->sides[Curside].tmap_num2)); else { PIGGY_PAGE_IN(Textures[Cursegp->sides[Curside].tmap_num]); gr_ubitmap(0,0, &GameBitmaps[Textures[Cursegp->sides[Curside].tmap_num].index]); } } } } else gr_clear_canvas( CGREY ); //------------------------------------------------------------ // If anything changes in the ui system, redraw all the text that // identifies this wall. //------------------------------------------------------------ if (ui_button_any_drawn || (old_wall_num != Cursegp->sides[Curside].wall_num) ) { if ( Cursegp->sides[Curside].wall_num > -1 ) { ui_wprintf_at( MainWindow, 12, 6, "Wall: %d ", Cursegp->sides[Curside].wall_num); switch (Walls[Cursegp->sides[Curside].wall_num].type) { case WALL_NORMAL: ui_wprintf_at( MainWindow, 12, 23, " Type: Normal " ); break; case WALL_BLASTABLE: ui_wprintf_at( MainWindow, 12, 23, " Type: Blastable" ); break; case WALL_DOOR: ui_wprintf_at( MainWindow, 12, 23, " Type: Door " ); ui_wprintf_at( MainWindow, 223, 6, "%s", WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].filename); break; case WALL_ILLUSION: ui_wprintf_at( MainWindow, 12, 23, " Type: Illusion " ); break; case WALL_OPEN: ui_wprintf_at( MainWindow, 12, 23, " Type: Open " ); break; case WALL_CLOSED: ui_wprintf_at( MainWindow, 12, 23, " Type: Closed " ); break; default: ui_wprintf_at( MainWindow, 12, 23, " Type: Unknown " ); break; } if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR) ui_wprintf_at( MainWindow, 223, 6, " " ); ui_wprintf_at( MainWindow, 12, 40, " Clip: %d ", Walls[Cursegp->sides[Curside].wall_num].clip_num ); ui_wprintf_at( MainWindow, 12, 57, " Trigger: %d ", Walls[Cursegp->sides[Curside].wall_num].trigger ); } else { ui_wprintf_at( MainWindow, 12, 6, "Wall: none "); ui_wprintf_at( MainWindow, 12, 23, " Type: none "); ui_wprintf_at( MainWindow, 12, 40, " Clip: none "); ui_wprintf_at( MainWindow, 12, 57, " Trigger: none "); } Update_flags |= UF_WORLD_CHANGED; } if ( QuitButton->pressed || (last_keypress==KEY_ESC) ) { close_wall_window(); return; } old_wall_num = Cursegp->sides[Curside].wall_num; }
void do_centers_window() { int i; // int robot_flags; int redraw_window; if ( MainWindow == NULL ) return; //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MainWindow); //------------------------------------------------------------ // If we change walls, we need to reset the ui code for all // of the checkboxes that control the wall flags. //------------------------------------------------------------ if (old_seg_num != Cursegp-Segments) { for ( i=0; i < MAX_CENTER_TYPES; i++ ) { CenterFlag[i]->flag = 0; // Tells ui that this button isn't checked CenterFlag[i]->status = 1; // Tells ui to redraw button } Assert(Cursegp->special < MAX_CENTER_TYPES); CenterFlag[Cursegp->special]->flag = 1; mprintf((0, "Cursegp->matcen_num = %i\n", Cursegp->matcen_num)); // Read materialization center robot bit flags for ( i=0; i < N_robot_types; i++ ) { RobotMatFlag[i]->status = 1; // Tells ui to redraw button if (RobotCenters[Cursegp->matcen_num].robot_flags & (1 << i)) RobotMatFlag[i]->flag = 1; // Tells ui that this button is checked else RobotMatFlag[i]->flag = 0; // Tells ui that this button is not checked } } //------------------------------------------------------------ // If any of the radio buttons that control the mode are set, then // update the corresponding center. //------------------------------------------------------------ redraw_window=0; for ( i=0; i < MAX_CENTER_TYPES; i++ ) { if ( CenterFlag[i]->flag == 1 ) if ( i == 0) fuelcen_delete(Cursegp); else if ( Cursegp->special != i ) { fuelcen_delete(Cursegp); redraw_window = 1; fuelcen_activate( Cursegp, i ); } } for ( i=0; i < N_robot_types; i++ ) { if ( RobotMatFlag[i]->flag == 1 ) { if (!(RobotCenters[Cursegp->matcen_num].robot_flags & (1<<i) )) { RobotCenters[Cursegp->matcen_num].robot_flags |= (1<<i); mprintf((0,"Segment %i, matcen = %i, Robot_flags %d\n", Cursegp-Segments, Cursegp->matcen_num, RobotCenters[Cursegp->matcen_num].robot_flags)); } } else if (RobotCenters[Cursegp->matcen_num].robot_flags & 1<<i) { RobotCenters[Cursegp->matcen_num].robot_flags &= ~(1<<i); mprintf((0,"Segment %i, matcen = %i, Robot_flags %d\n", Cursegp-Segments, Cursegp->matcen_num, RobotCenters[Cursegp->matcen_num].robot_flags)); } } //------------------------------------------------------------ // If anything changes in the ui system, redraw all the text that // identifies this wall. //------------------------------------------------------------ if (redraw_window || (old_seg_num != Cursegp-Segments ) ) { // int i; // char temp_text[CENTER_STRING_LENGTH]; ui_wprintf_at( MainWindow, 12, 6, "Seg: %3d", Cursegp-Segments ); // for (i=0; i<CENTER_STRING_LENGTH; i++) // temp_text[i] = ' '; // temp_text[i] = 0; // Assert(Cursegp->special < MAX_CENTER_TYPES); // strncpy(temp_text, Center_names[Cursegp->special], strlen(Center_names[Cursegp->special])); // ui_wprintf_at( MainWindow, 12, 23, " Type: %s", temp_text ); Update_flags |= UF_WORLD_CHANGED; } if ( QuitButton->pressed || (last_keypress==KEY_ESC) ) { close_centers_window(); return; } old_seg_num = Cursegp-Segments; }
int MenuX( int x, int y, int NumButtons, char * text[] ) { UI_WINDOW * wnd; UI_GADGET_BUTTON ** ButtonG; char ** Button; int button_width, button_height, width, height; int i; int w, h; int choice; ButtonG = (UI_GADGET_BUTTON **)malloc( sizeof(UI_GADGET_BUTTON *)*NumButtons ); Button = (char **)malloc( sizeof(char *)*NumButtons ); button_width = button_height = 0; for (i=0; i<NumButtons; i++ ) { Button[i] = text[i]; ui_get_button_size( Button[i], &width, &height ); if ( width > button_width ) button_width = width; if ( height > button_height ) button_height = height; } width = button_width + 2*(MENU_BORDER+3); height = (button_height*NumButtons) + (MENU_VERT_SPACING*(NumButtons-1)) ; height += (MENU_BORDER+3) * 2; w = grd_curscreen->sc_w; h = grd_curscreen->sc_h; if ( x == -1 ) x = Mouse.x - width/2; if ( y == -1 ) y = Mouse.y; if (x < 0 ) { x = 0; } if ( (x+width-1) >= w ) { x = w - width; } if (y < 0 ) { y = 0; } if ( (y+height-1) >= h ) { y = h - height; } wnd = ui_open_window( x, y, width, height, WIN_FILLED | WIN_SAVE_BG ); x = MENU_BORDER+3; y = MENU_BORDER+3; for (i=0; i<NumButtons; i++ ) { ButtonG[i] = ui_add_gadget_button( wnd, x, y, button_width, button_height, Button[i], NULL ); y += button_height+MENU_VERT_SPACING; } choice = 0; while(choice==0) { ui_mega_process(); ui_window_do_gadgets(wnd); for (i=0; i<NumButtons; i++ ) { if (ButtonG[i]->pressed) { choice = i+1; break; } } if ( (choice==0) && B1_JUST_RELEASED ) { choice = -1; break; } } ui_close_window(wnd); free(Button); free(ButtonG); return choice; }
void do_trigger_window() { int i; short Markedwall, trigger_num; if ( MainWindow == NULL ) return; if (!Markedsegp) { close_trigger_window(); return; } //------------------------------------------------------------ // Call the ui code.. //------------------------------------------------------------ ui_button_any_drawn = 0; ui_window_do_gadgets(MainWindow); //------------------------------------------------------------ // If we change walls, we need to reset the ui code for all // of the checkboxes that control the wall flags. //------------------------------------------------------------ Markedwall = Markedsegp->sides[Markedside].wall_num; if (Markedwall != -1) trigger_num = Walls[Markedwall].trigger; else trigger_num = -1; if (old_trigger_num != trigger_num ) { for ( i=0; i < NUM_TRIGGER_FLAGS; i++ ) { TriggerFlag[i]->flag = 0; // Tells ui that this button isn't checked TriggerFlag[i]->status = 1; // Tells ui to redraw button } if (trigger_num != -1) { if (Triggers[trigger_num].flags & TRIGGER_CONTROL_DOORS) TriggerFlag[0]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_SHIELD_DAMAGE) TriggerFlag[1]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_ENERGY_DRAIN) TriggerFlag[2]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_EXIT) TriggerFlag[3]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_ONE_SHOT) TriggerFlag[4]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_ON) TriggerFlag[5]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_OFF) TriggerFlag[6]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_ON) TriggerFlag[7]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_MATCEN) TriggerFlag[8]->flag = 1; if (Triggers[trigger_num].flags & TRIGGER_SECRET_EXIT) TriggerFlag[9]->flag = 1; } } //------------------------------------------------------------ // If any of the checkboxes that control the wallflags are set, then // update the cooresponding wall flag. //------------------------------------------------------------ if (IS_CHILD(Markedsegp->children[Markedside])) { if (TriggerFlag[0]->flag == 1) trigger_add_to_Markedside(TRIGGER_CONTROL_DOORS); else trigger_remove_flag_from_Markedside(TRIGGER_CONTROL_DOORS); if (TriggerFlag[1]->flag == 1) trigger_add_to_Markedside(TRIGGER_SHIELD_DAMAGE); else trigger_remove_flag_from_Markedside(TRIGGER_SHIELD_DAMAGE); if (TriggerFlag[2]->flag == 1) trigger_add_to_Markedside(TRIGGER_ENERGY_DRAIN); else trigger_remove_flag_from_Markedside(TRIGGER_ENERGY_DRAIN); if (TriggerFlag[3]->flag == 1) trigger_add_to_Markedside(TRIGGER_EXIT); else trigger_remove_flag_from_Markedside(TRIGGER_EXIT); if (TriggerFlag[4]->flag == 1) trigger_add_to_Markedside(TRIGGER_ONE_SHOT); else trigger_remove_flag_from_Markedside(TRIGGER_ONE_SHOT); if (TriggerFlag[5]->flag == 1) trigger_add_to_Markedside(TRIGGER_ILLUSION_ON); else trigger_remove_flag_from_Markedside(TRIGGER_ILLUSION_ON); if (TriggerFlag[6]->flag == 1) trigger_add_to_Markedside(TRIGGER_ILLUSION_OFF); else trigger_remove_flag_from_Markedside(TRIGGER_ILLUSION_OFF); if (TriggerFlag[7]->flag == 1) trigger_add_to_Markedside(TRIGGER_ON); else trigger_remove_flag_from_Markedside(TRIGGER_ON); if (TriggerFlag[8]->flag == 1) trigger_add_to_Markedside(TRIGGER_MATCEN); else trigger_remove_flag_from_Markedside(TRIGGER_MATCEN); if (TriggerFlag[9]->flag == 1) trigger_add_to_Markedside(TRIGGER_SECRET_EXIT); else trigger_remove_flag_from_Markedside(TRIGGER_SECRET_EXIT); } else for ( i=0; i < NUM_TRIGGER_FLAGS; i++ ) if (TriggerFlag[i]->flag == 1) { TriggerFlag[i]->flag = 0; // Tells ui that this button isn't checked TriggerFlag[i]->status = 1; // Tells ui to redraw button } //------------------------------------------------------------ // Draw the wall in the little 64x64 box //------------------------------------------------------------ gr_set_current_canvas( WallViewBox->canvas ); if ((Markedsegp->sides[Markedside].wall_num == -1) || (Walls[Markedsegp->sides[Markedside].wall_num].trigger) == -1) gr_clear_canvas( CBLACK ); else { if (Markedsegp->sides[Markedside].tmap_num2 > 0) { gr_ubitmap(0,0, texmerge_get_cached_bitmap( Markedsegp->sides[Markedside].tmap_num, Markedsegp->sides[Markedside].tmap_num2)); } else { if (Markedsegp->sides[Markedside].tmap_num > 0) { PIGGY_PAGE_IN(Textures[Markedsegp->sides[Markedside].tmap_num]); gr_ubitmap(0,0, &GameBitmaps[Textures[Markedsegp->sides[Markedside].tmap_num].index]); } else gr_clear_canvas( CGREY ); } } //------------------------------------------------------------ // If anything changes in the ui system, redraw all the text that // identifies this robot. //------------------------------------------------------------ if (ui_button_any_drawn || (old_trigger_num != trigger_num) ) { if ( Markedsegp->sides[Markedside].wall_num > -1 ) { ui_wprintf_at( MainWindow, 12, 6, "Trigger: %d ", trigger_num); } else { ui_wprintf_at( MainWindow, 12, 6, "Trigger: none "); } Update_flags |= UF_WORLD_CHANGED; } if ( QuitButton->pressed || (last_keypress==KEY_ESC)) { close_trigger_window(); return; } old_trigger_num = trigger_num; }
int ui_get_filename( char * filename, char * Filespec, char * message ) { char ViewDir[PATH_MAX]; char InputText[PATH_MAX]; char *p; PHYSFS_file *TempFile; int NumFiles, NumDirs,i; char **filename_list; char **directory_list; char Spaces[35]; UI_WINDOW *wnd; UI_GADGET_BUTTON *Button1, *Button2, *HelpButton; UI_GADGET_LISTBOX *ListBox1; UI_GADGET_LISTBOX *ListBox2; UI_GADGET_INPUTBOX *UserFile; int new_listboxes; if ((p = strrchr(filename, '/'))) { *p++ = 0; strcpy(ViewDir, filename); strcpy(InputText, p); } else { strcpy(ViewDir, ""); strcpy(InputText, filename); } filename_list = file_getfilelist(&NumFiles, Filespec, ViewDir); directory_list = file_getdirlist(&NumDirs, ViewDir); // Running out of memory may become likely in the future if (!filename_list && !directory_list) return 0; if (!filename_list) { PHYSFS_freeList(directory_list); return 0; } if (!directory_list) { PHYSFS_freeList(filename_list); return 0; } //ui_messagebox( -2,-2, 1,"DEBUG:0", "Ok" ); for (i=0; i<35; i++) Spaces[i] = ' '; Spaces[34] = 0; wnd = ui_open_window( 200, 100, 400, 370, WIN_DIALOG ); ui_wprintf_at( wnd, 10, 5, message ); ui_wprintf_at( wnd, 20, 32,"N&ame" ); UserFile = ui_add_gadget_inputbox( wnd, 60, 30, PATH_MAX, 40, InputText ); ui_wprintf_at( wnd, 20, 86,"&Files" ); ui_wprintf_at( wnd, 210, 86,"&Dirs" ); ListBox1 = ui_add_gadget_listbox(wnd, 20, 110, 125, 200, NumFiles, filename_list); ListBox2 = ui_add_gadget_listbox(wnd, 210, 110, 100, 200, NumDirs, directory_list); Button1 = ui_add_gadget_button( wnd, 20, 330, 60, 25, "Ok", NULL ); Button2 = ui_add_gadget_button( wnd, 100, 330, 60, 25, "Cancel", NULL ); HelpButton = ui_add_gadget_button( wnd, 180, 330, 60, 25, "Help", NULL ); wnd->keyboard_focus_gadget = (UI_GADGET *)UserFile; Button1->hotkey = KEY_CTRLED + KEY_ENTER; Button2->hotkey = KEY_ESC; HelpButton->hotkey = KEY_F1; ListBox1->hotkey = KEY_ALTED + KEY_F; ListBox2->hotkey = KEY_ALTED + KEY_D; UserFile->hotkey = KEY_ALTED + KEY_A; ui_gadget_calc_keys(wnd); ui_wprintf_at( wnd, 20, 60, "%s", Spaces ); ui_wprintf_at( wnd, 20, 60, "%s", ViewDir ); new_listboxes = 0; while( 1 ) { ui_mega_process(); ui_window_do_gadgets(wnd); if ( Button2->pressed ) { PHYSFS_freeList(filename_list); PHYSFS_freeList(directory_list); ui_close_window(wnd); return 0; } if ( HelpButton->pressed ) ui_messagebox( -1, -1, 1, "Sorry, no help is available!", "Ok" ); if (ListBox1->moved || new_listboxes) { if (ListBox1->current_item >= 0 ) ui_inputbox_set_text(UserFile, filename_list[ListBox1->current_item]); } if (ListBox2->moved || new_listboxes) { if (ListBox2->current_item >= 0 ) ui_inputbox_set_text(UserFile, directory_list[ListBox2->current_item]); } new_listboxes = 0; if (Button1->pressed || UserFile->pressed || (ListBox1->selected_item > -1 ) || (ListBox2->selected_item > -1 )) { ui_mouse_hide(); if (ListBox2->selected_item > -1 ) strcpy(UserFile->text, directory_list[ListBox2->selected_item]); strncpy(filename, ViewDir, PATH_MAX); p = UserFile->text; while (!strncmp(p, "..", 2)) // shorten the path manually { char *sep = strrchr(filename, '/'); if (sep) *sep = 0; else *filename = 0; // look directly in search paths p += 2; if (*p == '/') p++; } if (*filename && *p) strncat(filename, "/", PATH_MAX - strlen(filename)); strncat(filename, p, PATH_MAX - strlen(filename)); if (!PHYSFS_isDirectory(filename)) { TempFile = PHYSFS_openRead(filename); if (TempFile) { // Looks like a valid filename that already exists! PHYSFS_close(TempFile); break; } // File doesn't exist, but can we create it? TempFile = PHYSFS_openWrite(filename); if (TempFile) { // Looks like a valid filename! PHYSFS_close(TempFile); PHYSFS_delete(filename); break; } } else { if (filename[strlen(filename) - 1] == '/') // user typed a separator on the end filename[strlen(filename) - 1] = 0; strcpy(ViewDir, filename); //mprintf( 0, "----------------------------\n" ); //mprintf( 0, "Full dir: '%s'\n", ViewDir ); PHYSFS_freeList(filename_list); filename_list = file_getfilelist(&NumFiles, Filespec, ViewDir); if (!filename_list) { PHYSFS_freeList(directory_list); return 0; } ui_inputbox_set_text(UserFile, Filespec); PHYSFS_freeList(directory_list); directory_list = file_getdirlist(&NumDirs, ViewDir); if (!directory_list) { PHYSFS_freeList(filename_list); return 0; } ui_listbox_change(wnd, ListBox1, NumFiles, filename_list); ui_listbox_change(wnd, ListBox2, NumDirs, directory_list); new_listboxes = 0; ui_wprintf_at( wnd, 20, 60, "%s", Spaces ); ui_wprintf_at( wnd, 20, 60, "%s", ViewDir ); //i = TICKER; //while ( TICKER < i+2 ); } ui_mouse_show(); } vid_update(); } //key_flush(); ui_close_window(wnd); if (filename_list) PHYSFS_freeList(filename_list); if (directory_list) PHYSFS_freeList(directory_list); return 1; }
double ui_input_number( short xc, short yc, char * text, double OrgNumber ) { UI_WINDOW * wnd; UI_GADGET_INPUTBOX * InputBox; int text_width, text_height, avg; short box_width, box_height, width, height, x, y; short w, h; char string[100]; sprintf( string, "%f", OrgNumber ); box_width = box_height = 0; gr_set_current_canvas( &grd_curscreen->sc_canvas ); box_width = 8*20; box_height = 20; gr_get_string_size(text, &text_width, &text_height, &avg ); width = box_width + 50; text_width += avg*6; text_width += 10; if (text_width > width ) width = text_width; height = text_height; height += box_height; height += 4*5; // Center X and Y w = grd_curscreen->sc_w; h = grd_curscreen->sc_h; if ( xc == -1 ) xc = Mouse.x; if ( yc == -1 ) yc = Mouse.y - box_height/2; if ( xc == -2 ) xc = w/2; if ( yc == -2 ) yc = h/2; x = xc - width/2; y = yc - height/2; // Make sure that we're onscreen if (x < 0 ) x = 0; if ( (x+width-1) >= w ) x = w - width; if (y < 0 ) y = 0; if ( (y+height-1) >= h ) y = h - height; wnd = ui_open_window( x, y, width, height, WIN_DIALOG ); y = TEXT_EXTRA_HEIGHT + text_height/2 - 1; ui_string_centered( width/2, y, text ); y = 2*TEXT_EXTRA_HEIGHT + text_height; y = height - TEXT_EXTRA_HEIGHT - box_height-10; InputBox = ui_add_gadget_inputbox( wnd, 10, y, 20, 20, string ); ui_gadget_calc_keys(wnd); //key_flush(); wnd->keyboard_focus_gadget = (UI_GADGET *)InputBox; while(1) { ui_mega_process(); ui_window_do_gadgets(wnd); if (InputBox->pressed) break; } ui_close_window(wnd); OrgNumber = atof(InputBox->text); return OrgNumber; }