1#include "hud_config.qh" 2 3#include "hud.qh" 4#include "panel/scoreboard.qh" 5 6#define HUD_Write(s) fputs(fh, s) 7#define HUD_Write_Cvar(cvar) HUD_Write(strcat("seta ", cvar, " \"", cvar_string(cvar), "\"\n")) 8#define HUD_Write_PanelCvar(cvar_suf) HUD_Write_Cvar(strcat("hud_panel_", panel.panel_name, cvar_suf)) 9// Save the config 10void HUD_Panel_ExportCfg(string cfgname) 11{ 12 float fh; 13 string filename = strcat("hud_", autocvar_hud_skin, "_", cfgname, ".cfg"); 14 fh = fopen(filename, FILE_WRITE); 15 if(fh >= 0) 16 { 17 HUD_Write("//title \n"); 18 HUD_Write("//author \n"); 19 HUD_Write("\n"); 20 HUD_Write_Cvar("hud_skin"); 21 HUD_Write_Cvar("hud_panel_bg"); 22 HUD_Write_Cvar("hud_panel_bg_color"); 23 HUD_Write_Cvar("hud_panel_bg_color_team"); 24 HUD_Write_Cvar("hud_panel_bg_alpha"); 25 HUD_Write_Cvar("hud_panel_bg_border"); 26 HUD_Write_Cvar("hud_panel_bg_padding"); 27 HUD_Write_Cvar("hud_panel_fg_alpha"); 28 HUD_Write("\n"); 29 30 HUD_Write_Cvar("hud_dock"); 31 HUD_Write_Cvar("hud_dock_color"); 32 HUD_Write_Cvar("hud_dock_color_team"); 33 HUD_Write_Cvar("hud_dock_alpha"); 34 HUD_Write("\n"); 35 36 HUD_Write_Cvar("hud_progressbar_alpha"); 37 HUD_Write_Cvar("hud_progressbar_strength_color"); 38 HUD_Write_Cvar("hud_progressbar_superweapons_color"); 39 HUD_Write_Cvar("hud_progressbar_shield_color"); 40 HUD_Write_Cvar("hud_progressbar_health_color"); 41 HUD_Write_Cvar("hud_progressbar_armor_color"); 42 HUD_Write_Cvar("hud_progressbar_fuel_color"); 43 HUD_Write_Cvar("hud_progressbar_nexball_color"); 44 HUD_Write_Cvar("hud_progressbar_speed_color"); 45 HUD_Write_Cvar("hud_progressbar_acceleration_color"); 46 HUD_Write_Cvar("hud_progressbar_acceleration_neg_color"); 47 HUD_Write_Cvar("hud_progressbar_vehicles_ammo1_color"); 48 HUD_Write_Cvar("hud_progressbar_vehicles_ammo2_color"); 49 HUD_Write("\n"); 50 51 HUD_Write_Cvar("_hud_panelorder"); 52 HUD_Write("\n"); 53 54 HUD_Write_Cvar("hud_configure_grid"); 55 HUD_Write_Cvar("hud_configure_grid_xsize"); 56 HUD_Write_Cvar("hud_configure_grid_ysize"); 57 HUD_Write("\n"); 58 59 // common cvars for all panels 60 for (int i = 0; i < hud_panels_COUNT; ++i) 61 { 62 panel = hud_panels_from(i); 63 64 HUD_Write_PanelCvar("_pos"); 65 HUD_Write_PanelCvar("_size"); 66 HUD_Write_PanelCvar("_bg"); 67 HUD_Write_PanelCvar("_bg_color"); 68 HUD_Write_PanelCvar("_bg_color_team"); 69 HUD_Write_PanelCvar("_bg_alpha"); 70 HUD_Write_PanelCvar("_bg_border"); 71 HUD_Write_PanelCvar("_bg_padding"); 72 switch(panel) { 73 case HUD_PANEL_WEAPONS: 74 HUD_Write_PanelCvar("_accuracy"); 75 HUD_Write_PanelCvar("_label"); 76 HUD_Write_PanelCvar("_label_scale"); 77 HUD_Write_PanelCvar("_complainbubble"); 78 HUD_Write_PanelCvar("_complainbubble_padding"); 79 HUD_Write_PanelCvar("_complainbubble_time"); 80 HUD_Write_PanelCvar("_complainbubble_fadetime"); 81 HUD_Write_PanelCvar("_complainbubble_color_outofammo"); 82 HUD_Write_PanelCvar("_complainbubble_color_donthave"); 83 HUD_Write_PanelCvar("_complainbubble_color_unavailable"); 84 HUD_Write_PanelCvar("_ammo"); 85 HUD_Write_PanelCvar("_ammo_color"); 86 HUD_Write_PanelCvar("_ammo_alpha"); 87 HUD_Write_PanelCvar("_aspect"); 88 HUD_Write_PanelCvar("_timeout"); 89 HUD_Write_PanelCvar("_timeout_effect"); 90 HUD_Write_PanelCvar("_timeout_fadebgmin"); 91 HUD_Write_PanelCvar("_timeout_fadefgmin"); 92 HUD_Write_PanelCvar("_timeout_speed_in"); 93 HUD_Write_PanelCvar("_timeout_speed_out"); 94 HUD_Write_PanelCvar("_onlyowned"); 95 HUD_Write_PanelCvar("_noncurrent_alpha"); 96 HUD_Write_PanelCvar("_noncurrent_scale"); 97 break; 98 case HUD_PANEL_AMMO: 99 HUD_Write_PanelCvar("_onlycurrent"); 100 HUD_Write_PanelCvar("_noncurrent_alpha"); 101 HUD_Write_PanelCvar("_noncurrent_scale"); 102 HUD_Write_PanelCvar("_iconalign"); 103 HUD_Write_PanelCvar("_progressbar"); 104 HUD_Write_PanelCvar("_progressbar_name"); 105 HUD_Write_PanelCvar("_progressbar_xoffset"); 106 HUD_Write_PanelCvar("_text"); 107 break; 108 case HUD_PANEL_POWERUPS: 109 HUD_Write_PanelCvar("_iconalign"); 110 HUD_Write_PanelCvar("_baralign"); 111 HUD_Write_PanelCvar("_progressbar"); 112 HUD_Write_PanelCvar("_text"); 113 break; 114 case HUD_PANEL_HEALTHARMOR: 115 HUD_Write_PanelCvar("_flip"); 116 HUD_Write_PanelCvar("_iconalign"); 117 HUD_Write_PanelCvar("_baralign"); 118 HUD_Write_PanelCvar("_progressbar"); 119 HUD_Write_PanelCvar("_progressbar_health"); 120 HUD_Write_PanelCvar("_progressbar_armor"); 121 HUD_Write_PanelCvar("_progressbar_gfx"); 122 HUD_Write_PanelCvar("_progressbar_gfx_smooth"); 123 HUD_Write_PanelCvar("_combined"); 124 HUD_Write_PanelCvar("_text"); 125 break; 126 case HUD_PANEL_NOTIFY: 127 HUD_Write_PanelCvar("_flip"); 128 HUD_Write_PanelCvar("_fontsize"); 129 HUD_Write_PanelCvar("_time"); 130 HUD_Write_PanelCvar("_fadetime"); 131 HUD_Write_PanelCvar("_icon_aspect"); 132 break; 133 case HUD_PANEL_TIMER: 134 break; 135 case HUD_PANEL_RADAR: 136 HUD_Write_PanelCvar("_foreground_alpha"); 137 HUD_Write_PanelCvar("_rotation"); 138 HUD_Write_PanelCvar("_zoommode"); 139 HUD_Write_PanelCvar("_scale"); 140 HUD_Write_PanelCvar("_maximized_scale"); 141 HUD_Write_PanelCvar("_maximized_size"); 142 HUD_Write_PanelCvar("_maximized_rotation"); 143 HUD_Write_PanelCvar("_maximized_zoommode"); 144 break; 145 case HUD_PANEL_SCORE: 146 HUD_Write_PanelCvar("_rankings"); 147 break; 148 case HUD_PANEL_VOTE: 149 HUD_Write_PanelCvar("_alreadyvoted_alpha"); 150 break; 151 case HUD_PANEL_MODICONS: 152 HUD_Write_PanelCvar("_ca_layout"); 153 HUD_Write_PanelCvar("_dom_layout"); 154 HUD_Write_PanelCvar("_freezetag_layout"); 155 break; 156 case HUD_PANEL_PRESSEDKEYS: 157 HUD_Write_PanelCvar("_aspect"); 158 HUD_Write_PanelCvar("_attack"); 159 break; 160 case HUD_PANEL_ENGINEINFO: 161 HUD_Write_PanelCvar("_framecounter_time"); 162 HUD_Write_PanelCvar("_framecounter_decimals"); 163 break; 164 case HUD_PANEL_INFOMESSAGES: 165 HUD_Write_PanelCvar("_flip"); 166 break; 167 case HUD_PANEL_PHYSICS: 168 HUD_Write_PanelCvar("_speed_unit_show"); 169 HUD_Write_PanelCvar("_speed_max"); 170 HUD_Write_PanelCvar("_speed_vertical"); 171 HUD_Write_PanelCvar("_topspeed"); 172 HUD_Write_PanelCvar("_topspeed_time"); 173 HUD_Write_PanelCvar("_acceleration_max"); 174 HUD_Write_PanelCvar("_acceleration_vertical"); 175 HUD_Write_PanelCvar("_flip"); 176 HUD_Write_PanelCvar("_baralign"); 177 HUD_Write_PanelCvar("_progressbar"); 178 HUD_Write_PanelCvar("_acceleration_progressbar_mode"); 179 HUD_Write_PanelCvar("_acceleration_progressbar_scale"); 180 HUD_Write_PanelCvar("_acceleration_progressbar_nonlinear"); 181 HUD_Write_PanelCvar("_text"); 182 HUD_Write_PanelCvar("_text_scale"); 183 break; 184 case HUD_PANEL_CENTERPRINT: 185 HUD_Write_PanelCvar("_align"); 186 HUD_Write_PanelCvar("_flip"); 187 HUD_Write_PanelCvar("_fontscale"); 188 HUD_Write_PanelCvar("_time"); 189 HUD_Write_PanelCvar("_fade_in"); 190 HUD_Write_PanelCvar("_fade_out"); 191 HUD_Write_PanelCvar("_fade_subsequent"); 192 HUD_Write_PanelCvar("_fade_subsequent_passone"); 193 HUD_Write_PanelCvar("_fade_subsequent_passone_minalpha"); 194 HUD_Write_PanelCvar("_fade_subsequent_passtwo"); 195 HUD_Write_PanelCvar("_fade_subsequent_passtwo_minalpha"); 196 HUD_Write_PanelCvar("_fade_subsequent_minfontsize"); 197 HUD_Write_PanelCvar("_fade_minfontsize"); 198 break; 199 case HUD_PANEL_ITEMSTIME: 200 HUD_Write_PanelCvar("_iconalign"); 201 HUD_Write_PanelCvar("_progressbar"); 202 HUD_Write_PanelCvar("_progressbar_name"); 203 HUD_Write_PanelCvar("_progressbar_reduced"); 204 HUD_Write_PanelCvar("_text"); 205 HUD_Write_PanelCvar("_ratio"); 206 HUD_Write_PanelCvar("_dynamicsize"); 207 break; 208 case HUD_PANEL_QUICKMENU: 209 HUD_Write_PanelCvar("_align"); 210 break; 211 case HUD_PANEL_SCOREBOARD: 212 HUD_Write_PanelCvar("_fadeinspeed"); 213 HUD_Write_PanelCvar("_fadeoutspeed"); 214 HUD_Write_PanelCvar("_respawntime_decimals"); 215 HUD_Write_PanelCvar("_table_bg_alpha"); 216 HUD_Write_PanelCvar("_table_bg_scale"); 217 HUD_Write_PanelCvar("_table_fg_alpha"); 218 HUD_Write_PanelCvar("_table_fg_alpha_self"); 219 HUD_Write_PanelCvar("_table_highlight"); 220 HUD_Write_PanelCvar("_table_highlight_alpha"); 221 HUD_Write_PanelCvar("_table_highlight_alpha_self"); 222 HUD_Write_PanelCvar("_bg_teams_color_team"); 223 HUD_Write_PanelCvar("_accuracy_doublerows"); 224 HUD_Write_PanelCvar("_accuracy_nocolors"); 225 break; 226 } 227 HUD_Write("\n"); 228 } 229 MUTATOR_CALLHOOK(HUD_WriteCvars, fh); 230 231 HUD_Write("menu_sync\n"); // force the menu to reread the cvars, so that the dialogs are updated 232 233 LOG_INFOF(_("^2Successfully exported to %s! (Note: It's saved in data/data/)\n"), filename); 234 fclose(fh); 235 } 236 else 237 LOG_INFOF(_("^1Couldn't write to %s\n"), filename); 238} 239 240void HUD_Configure_Exit_Force() 241{ 242 if (hud_configure_menu_open) 243 { 244 hud_configure_menu_open = 0; 245 localcmd("togglemenu\n"); 246 } 247 cvar_set("_hud_configure", "0"); 248} 249 250// check if move will result in panel being moved into another panel. If so, return snapped vector, otherwise return the given vector 251vector HUD_Panel_CheckMove(vector myPos, vector mySize) 252{ 253 vector myCenter, targCenter; 254 vector myTarget = myPos; 255 int i; 256 for (i = 0; i < hud_panels_COUNT; ++i) { 257 panel = hud_panels_from(i); 258 if(!(panel.panel_configflags & PANEL_CONFIG_MAIN)) continue; 259 if(panel == highlightedPanel) continue; 260 HUD_Panel_UpdatePosSize(); 261 if(!panel_enabled) continue; 262 263 panel_pos -= '1 1 0' * panel_bg_border; 264 panel_size += '2 2 0' * panel_bg_border; 265 266 if(myPos.y + mySize.y < panel_pos.y) 267 continue; 268 if(myPos.y > panel_pos.y + panel_size.y) 269 continue; 270 271 if(myPos.x + mySize.x < panel_pos.x) 272 continue; 273 if(myPos.x > panel_pos.x + panel_size.x) 274 continue; 275 276 // OK, there IS a collision. 277 278 myCenter.x = myPos.x + 0.5 * mySize.x; 279 myCenter.y = myPos.y + 0.5 * mySize.y; 280 281 targCenter.x = panel_pos.x + 0.5 * panel_size.x; 282 targCenter.y = panel_pos.y + 0.5 * panel_size.y; 283 284 if(myCenter.x < targCenter.x && myCenter.y < targCenter.y) // top left (of the target panel) 285 { 286 if(myPos.x + mySize.x - panel_pos.x < myPos.y + mySize.y - panel_pos.y) // push it to the side 287 myTarget.x = panel_pos.x - mySize.x; 288 else // push it upwards 289 myTarget.y = panel_pos.y - mySize.y; 290 } 291 else if(myCenter.x > targCenter.x && myCenter.y < targCenter.y) // top right 292 { 293 if(panel_pos.x + panel_size.x - myPos.x < myPos.y + mySize.y - panel_pos.y) // push it to the side 294 myTarget.x = panel_pos.x + panel_size.x; 295 else // push it upwards 296 myTarget.y = panel_pos.y - mySize.y; 297 } 298 else if(myCenter.x < targCenter.x && myCenter.y > targCenter.y) // bottom left 299 { 300 if(myPos.x + mySize.x - panel_pos.x < panel_pos.y + panel_size.y - myPos.y) // push it to the side 301 myTarget.x = panel_pos.x - mySize.x; 302 else // push it downwards 303 myTarget.y = panel_pos.y + panel_size.y; 304 } 305 else if(myCenter.x > targCenter.x && myCenter.y > targCenter.y) // bottom right 306 { 307 if(panel_pos.x + panel_size.x - myPos.x < panel_pos.y + panel_size.y - myPos.y) // push it to the side 308 myTarget.x = panel_pos.x + panel_size.x; 309 else // push it downwards 310 myTarget.y = panel_pos.y + panel_size.y; 311 } 312 //if(cvar("hud_configure_checkcollisions_debug")) 313 //drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL); 314 } 315 316 return myTarget; 317} 318 319void HUD_Panel_SetPos(vector pos) 320{ 321 panel = highlightedPanel; 322 HUD_Panel_UpdatePosSize(); 323 vector mySize; 324 mySize = panel_size; 325 326 //if(cvar("hud_configure_checkcollisions_debug")) 327 //drawfill(pos, mySize, '1 1 1', .2, DRAWFLAG_NORMAL); 328 329 if(autocvar_hud_configure_grid) 330 { 331 pos.x = floor((pos.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x; 332 pos.y = floor((pos.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y; 333 } 334 335 if(hud_configure_checkcollisions) 336 pos = HUD_Panel_CheckMove(pos, mySize); 337 338 pos.x = bound(0, pos.x, vid_conwidth - mySize.x); 339 pos.y = bound(0, pos.y, vid_conheight - mySize.y); 340 341 string s; 342 s = strcat(ftos(pos.x/vid_conwidth), " ", ftos(pos.y/vid_conheight)); 343 344 cvar_set(strcat("hud_panel_", highlightedPanel.panel_name, "_pos"), s); 345} 346 347// check if resize will result in panel being moved into another panel. If so, return snapped vector, otherwise return the given vector 348vector HUD_Panel_CheckResize(vector mySize, vector resizeorigin) { 349 vector targEndPos; 350 vector dist; 351 float ratio = mySize.x/mySize.y; 352 int i; 353 for (i = 0; i < hud_panels_COUNT; ++i) { 354 panel = hud_panels_from(i); 355 if(!(panel.panel_configflags & PANEL_CONFIG_MAIN)) continue; 356 if(panel == highlightedPanel) continue; 357 HUD_Panel_UpdatePosSize(); 358 if(!panel_enabled) continue; 359 360 panel_pos -= '1 1 0' * panel_bg_border; 361 panel_size += '2 2 0' * panel_bg_border; 362 363 targEndPos = panel_pos + panel_size; 364 365 // resizeorigin is WITHIN target panel, just abort any collision testing against that particular panel to produce expected behaviour! 366 if(resizeorigin.x > panel_pos.x && resizeorigin.x < targEndPos.x && resizeorigin.y > panel_pos.y && resizeorigin.y < targEndPos.y) 367 continue; 368 369 if (resizeCorner == 1) 370 { 371 // check if this panel is on our way 372 if (resizeorigin.x <= panel_pos.x) 373 continue; 374 if (resizeorigin.y <= panel_pos.y) 375 continue; 376 if (targEndPos.x <= resizeorigin.x - mySize.x) 377 continue; 378 if (targEndPos.y <= resizeorigin.y - mySize.y) 379 continue; 380 381 // there is a collision: 382 // detect which side of the panel we are facing is actually limiting the resizing 383 // (which side the resize direction finds for first) and reduce the size up to there 384 // 385 // dist is the distance between resizeorigin and the "analogous" point of the panel 386 // in this case between resizeorigin (bottom-right point) and the bottom-right point of the panel 387 dist.x = resizeorigin.x - targEndPos.x; 388 dist.y = resizeorigin.y - targEndPos.y; 389 if (dist.y <= 0 || dist.x / dist.y > ratio) 390 mySize.x = min(mySize.x, dist.x); 391 else 392 mySize.y = min(mySize.y, dist.y); 393 } 394 else if (resizeCorner == 2) 395 { 396 if (resizeorigin.x >= targEndPos.x) 397 continue; 398 if (resizeorigin.y <= panel_pos.y) 399 continue; 400 if (panel_pos.x >= resizeorigin.x + mySize.x) 401 continue; 402 if (targEndPos.y <= resizeorigin.y - mySize.y) 403 continue; 404 405 dist.x = panel_pos.x - resizeorigin.x; 406 dist.y = resizeorigin.y - targEndPos.y; 407 if (dist.y <= 0 || dist.x / dist.y > ratio) 408 mySize.x = min(mySize.x, dist.x); 409 else 410 mySize.y = min(mySize.y, dist.y); 411 } 412 else if (resizeCorner == 3) 413 { 414 if (resizeorigin.x <= panel_pos.x) 415 continue; 416 if (resizeorigin.y >= targEndPos.y) 417 continue; 418 if (targEndPos.x <= resizeorigin.x - mySize.x) 419 continue; 420 if (panel_pos.y >= resizeorigin.y + mySize.y) 421 continue; 422 423 dist.x = resizeorigin.x - targEndPos.x; 424 dist.y = panel_pos.y - resizeorigin.y; 425 if (dist.y <= 0 || dist.x / dist.y > ratio) 426 mySize.x = min(mySize.x, dist.x); 427 else 428 mySize.y = min(mySize.y, dist.y); 429 } 430 else if (resizeCorner == 4) 431 { 432 if (resizeorigin.x >= targEndPos.x) 433 continue; 434 if (resizeorigin.y >= targEndPos.y) 435 continue; 436 if (panel_pos.x >= resizeorigin.x + mySize.x) 437 continue; 438 if (panel_pos.y >= resizeorigin.y + mySize.y) 439 continue; 440 441 dist.x = panel_pos.x - resizeorigin.x; 442 dist.y = panel_pos.y - resizeorigin.y; 443 if (dist.y <= 0 || dist.x / dist.y > ratio) 444 mySize.x = min(mySize.x, dist.x); 445 else 446 mySize.y = min(mySize.y, dist.y); 447 } 448 //if(cvar("hud_configure_checkcollisions_debug")) 449 //drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL); 450 } 451 452 return mySize; 453} 454 455void HUD_Panel_SetPosSize(vector mySize) 456{ 457 panel = highlightedPanel; 458 HUD_Panel_UpdatePosSize(); 459 vector resizeorigin = panel_click_resizeorigin; 460 vector myPos; 461 462 // minimum panel size cap 463 mySize.x = max(0.025 * vid_conwidth, mySize.x); 464 mySize.y = max(0.025 * vid_conheight, mySize.y); 465 466 if(highlightedPanel == HUD_PANEL(CHAT)) // some panels have their own restrictions, like the chat panel (which actually only moves the engine chat print around). Looks bad if it's too small. 467 { 468 mySize.x = max(17 * autocvar_con_chatsize, mySize.x); 469 mySize.y = max(2 * autocvar_con_chatsize + 2 * panel_bg_padding, mySize.y); 470 } 471 472 // collision testing| 473 // -----------------+ 474 475 // we need to know pos at this stage, but it might still change later if we hit a screen edge/other panel (?) 476 if(resizeCorner == 1) { 477 myPos.x = resizeorigin.x - mySize.x; 478 myPos.y = resizeorigin.y - mySize.y; 479 } else if(resizeCorner == 2) { 480 myPos.x = resizeorigin.x; 481 myPos.y = resizeorigin.y - mySize.y; 482 } else if(resizeCorner == 3) { 483 myPos.x = resizeorigin.x - mySize.x; 484 myPos.y = resizeorigin.y; 485 } else { // resizeCorner == 4 486 myPos.x = resizeorigin.x; 487 myPos.y = resizeorigin.y; 488 } 489 490 // left/top screen edges 491 if(myPos.x < 0) 492 mySize.x = mySize.x + myPos.x; 493 if(myPos.y < 0) 494 mySize.y = mySize.y + myPos.y; 495 496 // bottom/right screen edges 497 if(myPos.x + mySize.x > vid_conwidth) 498 mySize.x = vid_conwidth - myPos.x; 499 if(myPos.y + mySize.y > vid_conheight) 500 mySize.y = vid_conheight - myPos.y; 501 502 //if(cvar("hud_configure_checkcollisions_debug")) 503 //drawfill(myPos, mySize, '1 1 1', .2, DRAWFLAG_NORMAL); 504 505 // before checkresize, otherwise panel can be snapped partially inside another panel or panel aspect ratio can be broken 506 if(autocvar_hud_configure_grid) 507 { 508 mySize.x = floor((mySize.x/vid_conwidth)/hud_configure_gridSize.x + 0.5) * hud_configure_realGridSize.x; 509 mySize.y = floor((mySize.y/vid_conheight)/hud_configure_gridSize.y + 0.5) * hud_configure_realGridSize.y; 510 } 511 512 if(hud_configure_checkcollisions) 513 mySize = HUD_Panel_CheckResize(mySize, resizeorigin); 514 515 // minimum panel size cap, do this once more so we NEVER EVER EVER have a panel smaller than this, JUST IN CASE above code still makes the panel eg negative (impossible to resize back without changing cvars manually then) 516 mySize.x = max(0.025 * vid_conwidth, mySize.x); 517 mySize.y = max(0.025 * vid_conheight, mySize.y); 518 519 // do another pos check, as size might have changed by now 520 if(resizeCorner == 1) { 521 myPos.x = resizeorigin.x - mySize.x; 522 myPos.y = resizeorigin.y - mySize.y; 523 } else if(resizeCorner == 2) { 524 myPos.x = resizeorigin.x; 525 myPos.y = resizeorigin.y - mySize.y; 526 } else if(resizeCorner == 3) { 527 myPos.x = resizeorigin.x - mySize.x; 528 myPos.y = resizeorigin.y; 529 } else { // resizeCorner == 4 530 myPos.x = resizeorigin.x; 531 myPos.y = resizeorigin.y; 532 } 533 534 //if(cvar("hud_configure_checkcollisions_debug")) 535 //drawfill(myPos, mySize, '0 1 0', .3, DRAWFLAG_NORMAL); 536 537 string s; 538 s = strcat(ftos(mySize.x/vid_conwidth), " ", ftos(mySize.y/vid_conheight)); 539 cvar_set(strcat("hud_panel_", highlightedPanel.panel_name, "_size"), s); 540 541 s = strcat(ftos(myPos.x/vid_conwidth), " ", ftos(myPos.y/vid_conheight)); 542 cvar_set(strcat("hud_panel_", highlightedPanel.panel_name, "_pos"), s); 543} 544 545float pressed_key_time; 546vector highlightedPanel_initial_pos, highlightedPanel_initial_size; 547void HUD_Panel_Arrow_Action(float nPrimary) 548{ 549 if(!highlightedPanel) 550 return; 551 552 hud_configure_checkcollisions = (!(hudShiftState & S_CTRL) && autocvar_hud_configure_checkcollisions); 553 554 float step; 555 if(autocvar_hud_configure_grid) 556 { 557 if (nPrimary == K_UPARROW || nPrimary == K_DOWNARROW) 558 { 559 if (hudShiftState & S_SHIFT) 560 step = hud_configure_realGridSize.y; 561 else 562 step = 2 * hud_configure_realGridSize.y; 563 } 564 else 565 { 566 if (hudShiftState & S_SHIFT) 567 step = hud_configure_realGridSize.x; 568 else 569 step = 2 * hud_configure_realGridSize.x; 570 } 571 } 572 else 573 { 574 if (nPrimary == K_UPARROW || nPrimary == K_DOWNARROW) 575 step = vid_conheight; 576 else 577 step = vid_conwidth; 578 if (hudShiftState & S_SHIFT) 579 step = (step / 256); // more precision 580 else 581 step = (step / 64) * (1 + 2 * (time - pressed_key_time)); 582 } 583 584 panel = highlightedPanel; 585 HUD_Panel_UpdatePosSize(); 586 587 highlightedPanel_initial_pos = panel_pos; 588 highlightedPanel_initial_size = panel_size; 589 590 if (hudShiftState & S_ALT) // resize 591 { 592 if(nPrimary == K_UPARROW) 593 resizeCorner = 1; 594 else if(nPrimary == K_RIGHTARROW) 595 resizeCorner = 2; 596 else if(nPrimary == K_LEFTARROW) 597 resizeCorner = 3; 598 else // if(nPrimary == K_DOWNARROW) 599 resizeCorner = 4; 600 601 // ctrl+arrow reduces the size, instead of increasing it 602 // Note that ctrl disables collisions check too, but it's fine 603 // since we don't collide with anything reducing the size 604 if (hudShiftState & S_CTRL) { 605 step = -step; 606 resizeCorner = 5 - resizeCorner; 607 } 608 609 vector mySize; 610 mySize = panel_size; 611 panel_click_resizeorigin = panel_pos; 612 if(resizeCorner == 1) { 613 panel_click_resizeorigin += mySize; 614 mySize.y += step; 615 } else if(resizeCorner == 2) { 616 panel_click_resizeorigin.y += mySize.y; 617 mySize.x += step; 618 } else if(resizeCorner == 3) { 619 panel_click_resizeorigin.x += mySize.x; 620 mySize.x += step; 621 } else { // resizeCorner == 4 622 mySize.y += step; 623 } 624 HUD_Panel_SetPosSize(mySize); 625 } 626 else // move 627 { 628 vector pos; 629 pos = panel_pos; 630 if(nPrimary == K_UPARROW) 631 pos.y -= step; 632 else if(nPrimary == K_DOWNARROW) 633 pos.y += step; 634 else if(nPrimary == K_LEFTARROW) 635 pos.x -= step; 636 else // if(nPrimary == K_RIGHTARROW) 637 pos.x += step; 638 639 HUD_Panel_SetPos(pos); 640 } 641 642 panel = highlightedPanel; 643 HUD_Panel_UpdatePosSize(); 644 645 if (highlightedPanel_initial_pos != panel_pos || highlightedPanel_initial_size != panel_size) 646 { 647 // backup! 648 panel_pos_backup = highlightedPanel_initial_pos; 649 panel_size_backup = highlightedPanel_initial_size; 650 highlightedPanel_backup = highlightedPanel; 651 } 652} 653 654void HUD_Panel_EnableMenu(); 655entity tab_panels[hud_panels_MAX]; 656entity tab_panel; 657vector tab_panel_pos; 658float tab_backward; 659void HUD_Panel_FirstInDrawQ(float id); 660void reset_tab_panels() 661{ 662 for (int i = 0; i < hud_panels_COUNT; ++i) 663 tab_panels[i] = NULL; 664} 665float HUD_Panel_InputEvent(float bInputType, float nPrimary, float nSecondary) 666{ 667 string s; 668 669 if(bInputType == 2) 670 return false; 671 672 if(!autocvar__hud_configure) 673 return false; 674 675 if(bInputType == 3) 676 { 677 mousepos.x = nPrimary; 678 mousepos.y = nSecondary; 679 return true; 680 } 681 682 // block any input while a menu dialog is fading 683 // don't block mousepos read as it leads to cursor jumps in the interaction with the menu 684 if(autocvar__menu_alpha) 685 { 686 hudShiftState = 0; 687 mouseClicked = 0; 688 return true; 689 } 690 691 // allow console bind to work 692 string con_keys = findkeysforcommand("toggleconsole", 0); 693 int keys = tokenize(con_keys); // findkeysforcommand returns data for this 694 695 bool hit_con_bind = false; 696 int i; 697 for (i = 0; i < keys; ++i) 698 { 699 if(nPrimary == stof(argv(i))) 700 hit_con_bind = true; 701 } 702 703 if(bInputType == 0) { 704 if(nPrimary == K_ALT) hudShiftState |= S_ALT; 705 if(nPrimary == K_CTRL) hudShiftState |= S_CTRL; 706 if(nPrimary == K_SHIFT) hudShiftState |= S_SHIFT; 707 } 708 else if(bInputType == 1) { 709 if(nPrimary == K_ALT) hudShiftState -= (hudShiftState & S_ALT); 710 if(nPrimary == K_CTRL) hudShiftState -= (hudShiftState & S_CTRL); 711 if(nPrimary == K_SHIFT) hudShiftState -= (hudShiftState & S_SHIFT); 712 } 713 714 if(nPrimary == K_CTRL) 715 { 716 if (bInputType == 1) //ctrl has been released 717 { 718 if (tab_panel) 719 { 720 //switch to selected panel 721 highlightedPanel = tab_panel; 722 highlightedAction = 0; 723 HUD_Panel_FirstInDrawQ(highlightedPanel.panel_id); 724 } 725 tab_panel = NULL; 726 reset_tab_panels(); 727 } 728 } 729 730 if(nPrimary == K_MOUSE1) 731 { 732 if(bInputType == 0) // key pressed 733 mouseClicked |= S_MOUSE1; 734 else if(bInputType == 1) // key released 735 mouseClicked -= (mouseClicked & S_MOUSE1); 736 } 737 else if(nPrimary == K_MOUSE2) 738 { 739 if(bInputType == 0) // key pressed 740 mouseClicked |= S_MOUSE2; 741 else if(bInputType == 1) // key released 742 mouseClicked -= (mouseClicked & S_MOUSE2); 743 } 744 else if(nPrimary == K_ESCAPE) 745 { 746 if (bInputType == 1) 747 return true; 748 hud_configure_menu_open = 1; 749 localcmd("menu_showhudexit\n"); 750 } 751 else if(nPrimary == K_BACKSPACE && hudShiftState & S_CTRL) 752 { 753 if (bInputType == 1) 754 return true; 755 if (!hud_configure_menu_open) 756 cvar_set("_hud_configure", "0"); 757 } 758 else if(nPrimary == K_TAB && hudShiftState & S_CTRL) // switch panel 759 { 760 if (bInputType == 1 || mouseClicked) 761 return true; 762 763 // FIXME minor bug: if a panel is highlighted, has the same pos_x and 764 // lays in the same level of another panel then the next consecutive 765 // CTRL TAB presses will reselect once more the highlighted panel 766 767 entity starting_panel; 768 entity old_tab_panel = tab_panel; 769 if (!tab_panel) //first press of TAB 770 { 771 if (highlightedPanel) 772 { 773 panel = highlightedPanel; 774 HUD_Panel_UpdatePosSize(); 775 } 776 else 777 panel_pos = '0 0 0'; 778 starting_panel = highlightedPanel; 779 tab_panel_pos = panel_pos; //to compute level 780 } 781 else 782 { 783 if ( ((!tab_backward) && (hudShiftState & S_SHIFT)) || (tab_backward && !(hudShiftState & S_SHIFT)) ) //tab direction changed? 784 reset_tab_panels(); 785 starting_panel = tab_panel; 786 } 787 tab_backward = (hudShiftState & S_SHIFT); 788 789 float k, level = 0, start_posX; 790 vector candidate_pos = '0 0 0'; 791 const float LEVELS_NUM = 4; 792 float level_height = vid_conheight / LEVELS_NUM; 793LABEL(find_tab_panel) 794 level = floor(tab_panel_pos.y / level_height) * level_height; //starting level 795 candidate_pos.x = (!tab_backward) ? vid_conwidth : 0; 796 start_posX = tab_panel_pos.x; 797 tab_panel = NULL; 798 k=0; 799 while(++k) 800 { 801 for(i = 0; i < hud_panels_COUNT; ++i) 802 { 803 panel = hud_panels_from(i); 804 if(!(panel.panel_configflags & PANEL_CONFIG_MAIN)) 805 continue; 806 if (panel == tab_panels[i] || panel == starting_panel) 807 continue; 808 HUD_Panel_UpdatePosSize(); 809 if (panel_pos.y >= level && (panel_pos.y - level) < level_height) 810 if ( ( !tab_backward && panel_pos.x >= start_posX && (panel_pos.x < candidate_pos.x || (panel_pos.x == candidate_pos.x && panel_pos.y <= candidate_pos.y)) ) 811 || ( tab_backward && panel_pos.x <= start_posX && (panel_pos.x > candidate_pos.x || (panel_pos.x == candidate_pos.x && panel_pos.y >= candidate_pos.y)) ) ) 812 { 813 tab_panel = panel; 814 tab_panel_pos = candidate_pos = panel_pos; 815 } 816 } 817 if (tab_panel) 818 break; 819 if (k == LEVELS_NUM) //tab_panel not found 820 { 821 reset_tab_panels(); 822 if (!old_tab_panel) 823 { 824 tab_panel = NULL; 825 return true; 826 } 827 starting_panel = old_tab_panel; 828 old_tab_panel = NULL; 829 goto find_tab_panel; //u must find tab_panel! 830 } 831 if (!tab_backward) 832 { 833 level = (level + level_height) % vid_conheight; 834 start_posX = 0; 835 candidate_pos.x = vid_conwidth; 836 } 837 else 838 { 839 level = (level - level_height) % vid_conheight; 840 start_posX = vid_conwidth; 841 candidate_pos.x = 0; 842 } 843 } 844 845 tab_panels[tab_panel.panel_id] = tab_panel; 846 } 847 else if(nPrimary == K_SPACE && hudShiftState & S_CTRL) // enable/disable highlighted panel or dock 848 { 849 if (bInputType == 1 || mouseClicked) 850 return true; 851 852 if (highlightedPanel) 853 { 854 if(panel.panel_configflags & PANEL_CONFIG_CANBEOFF) 855 cvar_set(strcat("hud_panel_", highlightedPanel.panel_name), ftos(!cvar(strcat("hud_panel_", highlightedPanel.panel_name)))); 856 } 857 else 858 cvar_set(strcat("hud_dock"), (autocvar_hud_dock == "") ? "dock" : ""); 859 } 860 else if(nPrimary == 'c' && hudShiftState & S_CTRL) // copy highlighted panel size 861 { 862 if (bInputType == 1 || mouseClicked) 863 return true; 864 865 if (highlightedPanel) 866 { 867 panel = highlightedPanel; 868 HUD_Panel_UpdatePosSize(); 869 panel_size_copied = panel_size; 870 } 871 } 872 else if(nPrimary == 'v' && hudShiftState & S_CTRL) // past copied size on the highlighted panel 873 { 874 if (bInputType == 1 || mouseClicked) 875 return true; 876 877 if (panel_size_copied == '0 0 0' || !highlightedPanel) 878 return true; 879 880 panel = highlightedPanel; 881 HUD_Panel_UpdatePosSize(); 882 883 // reduce size if it'd go beyond screen boundaries 884 vector tmp_size = panel_size_copied; 885 if (panel_pos.x + panel_size_copied.x > vid_conwidth) 886 tmp_size.x = vid_conwidth - panel_pos.x; 887 if (panel_pos.y + panel_size_copied.y > vid_conheight) 888 tmp_size.y = vid_conheight - panel_pos.y; 889 890 if (panel_size == tmp_size) 891 return true; 892 893 // backup first! 894 panel_pos_backup = panel_pos; 895 panel_size_backup = panel_size; 896 highlightedPanel_backup = highlightedPanel; 897 898 s = strcat(ftos(tmp_size.x/vid_conwidth), " ", ftos(tmp_size.y/vid_conheight)); 899 cvar_set(strcat("hud_panel_", highlightedPanel.panel_name, "_size"), s); 900 } 901 else if(nPrimary == 'z' && hudShiftState & S_CTRL) // undo last action 902 { 903 if (bInputType == 1 || mouseClicked) 904 return true; 905 //restore previous values 906 if (highlightedPanel_backup) 907 { 908 s = strcat(ftos(panel_pos_backup.x/vid_conwidth), " ", ftos(panel_pos_backup.y/vid_conheight)); 909 cvar_set(strcat("hud_panel_", highlightedPanel_backup.panel_name, "_pos"), s); 910 s = strcat(ftos(panel_size_backup.x/vid_conwidth), " ", ftos(panel_size_backup.y/vid_conheight)); 911 cvar_set(strcat("hud_panel_", highlightedPanel_backup.panel_name, "_size"), s); 912 highlightedPanel_backup = NULL; 913 } 914 } 915 else if(nPrimary == 's' && hudShiftState & S_CTRL) // save config 916 { 917 if (bInputType == 1 || mouseClicked) 918 return true; 919 localcmd("hud save myconfig\n"); 920 } 921 else if(nPrimary == K_UPARROW || nPrimary == K_DOWNARROW || nPrimary == K_LEFTARROW || nPrimary == K_RIGHTARROW) 922 { 923 if (bInputType == 1) 924 { 925 pressed_key_time = 0; 926 return true; 927 } 928 else if (pressed_key_time == 0) 929 pressed_key_time = time; 930 931 if (!mouseClicked) 932 HUD_Panel_Arrow_Action(nPrimary); //move or resize panel 933 } 934 else if(nPrimary == K_ENTER || nPrimary == K_SPACE || nPrimary == K_KP_ENTER) 935 { 936 if (bInputType == 1) 937 return true; 938 if (highlightedPanel) 939 HUD_Panel_EnableMenu(); 940 } 941 else if(hit_con_bind || nPrimary == K_PAUSE) 942 return false; 943 944 return true; 945} 946 947float HUD_Panel_Check_Mouse_Pos(float allow_move) 948{ 949 int i, j = 0; 950 while(j < hud_panels_COUNT) 951 { 952 i = panel_order[j]; 953 j += 1; 954 955 panel = hud_panels_from(i); 956 if(!(panel.panel_configflags & PANEL_CONFIG_MAIN)) continue; 957 HUD_Panel_UpdatePosSize(); 958 959 float border = max(8, panel_bg_border); // FORCED border so a small border size doesn't mean you can't resize 960 961 // move 962 if(allow_move && mousepos.x > panel_pos.x && mousepos.y > panel_pos.y && mousepos.x < panel_pos.x + panel_size.x && mousepos.y < panel_pos.y + panel_size.y) 963 { 964 return 1; 965 } 966 // resize from topleft border 967 else if(mousepos.x >= panel_pos.x - border && mousepos.y >= panel_pos.y - border && mousepos.x <= panel_pos.x + 0.5 * panel_size.x && mousepos.y <= panel_pos.y + 0.5 * panel_size.y) 968 { 969 return 2; 970 } 971 // resize from topright border 972 else if(mousepos.x >= panel_pos.x + 0.5 * panel_size.x && mousepos.y >= panel_pos.y - border && mousepos.x <= panel_pos.x + panel_size.x + border && mousepos.y <= panel_pos.y + 0.5 * panel_size.y) 973 { 974 return 3; 975 } 976 // resize from bottomleft border 977 else if(mousepos.x >= panel_pos.x - border && mousepos.y >= panel_pos.y + 0.5 * panel_size.y && mousepos.x <= panel_pos.x + 0.5 * panel_size.x && mousepos.y <= panel_pos.y + panel_size.y + border) 978 { 979 return 3; 980 } 981 // resize from bottomright border 982 else if(mousepos.x >= panel_pos.x + 0.5 * panel_size.x && mousepos.y >= panel_pos.y + 0.5 * panel_size.y && mousepos.x <= panel_pos.x + panel_size.x + border && mousepos.y <= panel_pos.y + panel_size.y + border) 983 { 984 return 2; 985 } 986 } 987 return 0; 988} 989 990// move a panel to the beginning of the panel order array (which means it gets drawn last, on top of everything else) 991void HUD_Panel_FirstInDrawQ(float id) 992{ 993 int i; 994 int place = -1; 995 // find out where in the array our current id is, save into place 996 for(i = 0; i < hud_panels_COUNT; ++i) 997 { 998 if(panel_order[i] == id) 999 { 1000 place = i; 1001 break; 1002 } 1003 } 1004 // place last if we didn't find a place for it yet (probably new panel, or screwed up cvar) 1005 if(place == -1) 1006 place = hud_panels_COUNT - 1; 1007 1008 // move all ids up by one step in the array until "place" 1009 for(i = place; i > 0; --i) 1010 { 1011 panel_order[i] = panel_order[i-1]; 1012 } 1013 // now save the new top id 1014 panel_order[0] = id; 1015 1016 // let's save them into the cvar by some strcat trickery 1017 string s = ""; 1018 for(i = 0; i < hud_panels_COUNT; ++i) 1019 { 1020 s = strcat(s, ftos(panel_order[i]), " "); 1021 } 1022 cvar_set("_hud_panelorder", s); 1023 if(hud_panelorder_prev) 1024 strunzone(hud_panelorder_prev); 1025 hud_panelorder_prev = strzone(autocvar__hud_panelorder); // prevent HUD_Main from doing useless update, we already updated here 1026} 1027 1028void HUD_Panel_Highlight(float allow_move) 1029{ 1030 int i, j = 0; 1031 1032 while(j < hud_panels_COUNT) 1033 { 1034 i = panel_order[j]; 1035 j += 1; 1036 1037 panel = hud_panels_from(i); 1038 if(!(panel.panel_configflags & PANEL_CONFIG_MAIN)) 1039 continue; 1040 HUD_Panel_UpdatePosSize(); 1041 1042 float border = max(8, panel_bg_border); // FORCED border so a small border size doesn't mean you can't resize 1043 1044 // move 1045 if(allow_move && mousepos.x > panel_pos.x && mousepos.y > panel_pos.y && mousepos.x < panel_pos.x + panel_size.x && mousepos.y < panel_pos.y + panel_size.y) 1046 { 1047 highlightedPanel = hud_panels_from(i); 1048 HUD_Panel_FirstInDrawQ(i); 1049 highlightedAction = 1; 1050 panel_click_distance = mousepos - panel_pos; 1051 return; 1052 } 1053 // resize from topleft border 1054 else if(mousepos.x >= panel_pos.x - border && mousepos.y >= panel_pos.y - border && mousepos.x <= panel_pos.x + 0.5 * panel_size.x && mousepos.y <= panel_pos.y + 0.5 * panel_size.y) 1055 { 1056 highlightedPanel = hud_panels_from(i); 1057 HUD_Panel_FirstInDrawQ(i); 1058 highlightedAction = 2; 1059 resizeCorner = 1; 1060 panel_click_distance = mousepos - panel_pos; 1061 panel_click_resizeorigin = panel_pos + panel_size; 1062 return; 1063 } 1064 // resize from topright border 1065 else if(mousepos.x >= panel_pos.x + 0.5 * panel_size.x && mousepos.y >= panel_pos.y - border && mousepos.x <= panel_pos.x + panel_size.x + border && mousepos.y <= panel_pos.y + 0.5 * panel_size.y) 1066 { 1067 highlightedPanel = hud_panels_from(i); 1068 HUD_Panel_FirstInDrawQ(i); 1069 highlightedAction = 2; 1070 resizeCorner = 2; 1071 panel_click_distance.x = panel_size.x - mousepos.x + panel_pos.x; 1072 panel_click_distance.y = mousepos.y - panel_pos.y; 1073 panel_click_resizeorigin = panel_pos + eY * panel_size.y; 1074 return; 1075 } 1076 // resize from bottomleft border 1077 else if(mousepos.x >= panel_pos.x - border && mousepos.y >= panel_pos.y + 0.5 * panel_size.y && mousepos.x <= panel_pos.x + 0.5 * panel_size.x && mousepos.y <= panel_pos.y + panel_size.y + border) 1078 { 1079 highlightedPanel = hud_panels_from(i); 1080 HUD_Panel_FirstInDrawQ(i); 1081 highlightedAction = 2; 1082 resizeCorner = 3; 1083 panel_click_distance.x = mousepos.x - panel_pos.x; 1084 panel_click_distance.y = panel_size.y - mousepos.y + panel_pos.y; 1085 panel_click_resizeorigin = panel_pos + eX * panel_size.x; 1086 return; 1087 } 1088 // resize from bottomright border 1089 else if(mousepos.x >= panel_pos.x + 0.5 * panel_size.x && mousepos.y >= panel_pos.y + 0.5 * panel_size.y && mousepos.x <= panel_pos.x + panel_size.x + border && mousepos.y <= panel_pos.y + panel_size.y + border) 1090 { 1091 highlightedPanel = hud_panels_from(i); 1092 HUD_Panel_FirstInDrawQ(i); 1093 highlightedAction = 2; 1094 resizeCorner = 4; 1095 panel_click_distance = panel_size - mousepos + panel_pos; 1096 panel_click_resizeorigin = panel_pos; 1097 return; 1098 } 1099 } 1100 highlightedPanel = NULL; 1101 highlightedAction = 0; 1102} 1103 1104void HUD_Panel_EnableMenu() 1105{ 1106 hud_configure_menu_open = 2; 1107 localcmd("menu_showhudoptions ", highlightedPanel.panel_name, "\n"); 1108} 1109float mouse_over_panel; 1110void HUD_Panel_Mouse() 1111{ 1112 if(autocvar__menu_alpha == 1) 1113 return; 1114 1115 if (!autocvar_hud_cursormode) 1116 update_mousepos(); 1117 1118 if(mouseClicked) 1119 { 1120 if(prevMouseClicked == 0) 1121 { 1122 if (tab_panel) 1123 { 1124 //stop ctrl-tab selection 1125 tab_panel = NULL; 1126 reset_tab_panels(); 1127 } 1128 HUD_Panel_Highlight(mouseClicked & S_MOUSE1); // sets highlightedPanel, highlightedAction, panel_click_distance, panel_click_resizeorigin 1129 // and calls HUD_Panel_UpdatePosSize() for the highlighted panel 1130 if (highlightedPanel) 1131 { 1132 highlightedPanel_initial_pos = panel_pos; 1133 highlightedPanel_initial_size = panel_size; 1134 } 1135 // doubleclick check 1136 if ((mouseClicked & S_MOUSE1) && time - prevMouseClickedTime < 0.4 && highlightedPanel && prevMouseClickedPos == mousepos) 1137 { 1138 mouseClicked = 0; // to prevent spam, I guess. 1139 HUD_Panel_EnableMenu(); 1140 } 1141 else 1142 { 1143 if (mouseClicked & S_MOUSE1) 1144 { 1145 prevMouseClickedTime = time; 1146 prevMouseClickedPos = mousepos; 1147 } 1148 mouse_over_panel = HUD_Panel_Check_Mouse_Pos(mouseClicked & S_MOUSE1); 1149 } 1150 } 1151 else 1152 { 1153 panel = highlightedPanel; 1154 HUD_Panel_UpdatePosSize(); 1155 } 1156 1157 if (highlightedPanel) 1158 { 1159 drawfill(panel_pos - '1 1 0' * panel_bg_border, panel_size + '2 2 0' * panel_bg_border, '1 1 1', .1, DRAWFLAG_NORMAL); 1160 if (highlightedPanel_initial_pos != panel_pos || highlightedPanel_initial_size != panel_size) 1161 { 1162 hud_configure_checkcollisions = (!(hudShiftState & S_CTRL) && autocvar_hud_configure_checkcollisions); 1163 // backup! 1164 panel_pos_backup = highlightedPanel_initial_pos; 1165 panel_size_backup = highlightedPanel_initial_size; 1166 highlightedPanel_backup = highlightedPanel; 1167 } 1168 else 1169 // in case the clicked panel is inside another panel and we aren't 1170 // moving it, avoid the immediate "fix" of its position/size 1171 // (often unwanted and hateful) by disabling collisions check 1172 hud_configure_checkcollisions = false; 1173 } 1174 1175 if(highlightedAction == 1) 1176 HUD_Panel_SetPos(mousepos - panel_click_distance); 1177 else if(highlightedAction == 2) 1178 { 1179 vector mySize = '0 0 0'; 1180 if(resizeCorner == 1) { 1181 mySize.x = panel_click_resizeorigin.x - (mousepos.x - panel_click_distance.x); 1182 mySize.y = panel_click_resizeorigin.y - (mousepos.y - panel_click_distance.y); 1183 } else if(resizeCorner == 2) { 1184 mySize.x = mousepos.x + panel_click_distance.x - panel_click_resizeorigin.x; 1185 mySize.y = panel_click_distance.y + panel_click_resizeorigin.y - mousepos.y; 1186 } else if(resizeCorner == 3) { 1187 mySize.x = panel_click_resizeorigin.x + panel_click_distance.x - mousepos.x; 1188 mySize.y = mousepos.y + panel_click_distance.y - panel_click_resizeorigin.y; 1189 } else { // resizeCorner == 4 1190 mySize.x = mousepos.x - (panel_click_resizeorigin.x - panel_click_distance.x); 1191 mySize.y = mousepos.y - (panel_click_resizeorigin.y - panel_click_distance.y); 1192 } 1193 HUD_Panel_SetPosSize(mySize); 1194 } 1195 } 1196 else 1197 { 1198 if(prevMouseClicked) 1199 highlightedAction = 0; 1200 if(hud_configure_menu_open == 2) 1201 mouse_over_panel = 0; 1202 else 1203 mouse_over_panel = HUD_Panel_Check_Mouse_Pos(true); 1204 if (mouse_over_panel && !tab_panel) 1205 drawfill(panel_pos - '1 1 0' * panel_bg_border, panel_size + '2 2 0' * panel_bg_border, '1 1 1', .1, DRAWFLAG_NORMAL); 1206 } 1207 // draw cursor after performing move/resize to have the panel pos/size updated before mouse_over_panel 1208 float cursor_alpha = 1 - autocvar__menu_alpha; 1209 1210 if(!mouse_over_panel) 1211 draw_cursor_normal(mousepos, '1 1 1', cursor_alpha); 1212 else if(mouse_over_panel == 1) 1213 draw_cursor(mousepos, '0.5 0.5 0', "/cursor_move", '1 1 1', cursor_alpha); 1214 else if(mouse_over_panel == 2) 1215 draw_cursor(mousepos, '0.5 0.5 0', "/cursor_resize", '1 1 1', cursor_alpha); 1216 else 1217 draw_cursor(mousepos, '0.5 0.5 0', "/cursor_resize2", '1 1 1', cursor_alpha); 1218 1219 prevMouseClicked = mouseClicked; 1220} 1221void HUD_Configure_DrawGrid() 1222{ 1223 float i; 1224 if(autocvar_hud_configure_grid && autocvar_hud_configure_grid_alpha) 1225 { 1226 hud_configure_gridSize.x = bound(0.005, cvar("hud_configure_grid_xsize"), 0.2); 1227 hud_configure_gridSize.y = bound(0.005, cvar("hud_configure_grid_ysize"), 0.2); 1228 hud_configure_realGridSize.x = hud_configure_gridSize.x * vid_conwidth; 1229 hud_configure_realGridSize.y = hud_configure_gridSize.y * vid_conheight; 1230 vector s; 1231 // x-axis 1232 s = eX + eY * vid_conheight; 1233 for(i = 1; i < 1/hud_configure_gridSize.x; ++i) 1234 drawfill(eX * i * hud_configure_realGridSize.x, s, '0.5 0.5 0.5', autocvar_hud_configure_grid_alpha, DRAWFLAG_NORMAL); 1235 // y-axis 1236 s = eY + eX * vid_conwidth; 1237 for(i = 1; i < 1/hud_configure_gridSize.y; ++i) 1238 drawfill(eY * i * hud_configure_realGridSize.y, s, '0.5 0.5 0.5', autocvar_hud_configure_grid_alpha, DRAWFLAG_NORMAL); 1239 } 1240} 1241 1242float _menu_alpha_prev; 1243void HUD_Configure_Frame() 1244{ 1245 int i; 1246 if(autocvar__hud_configure) 1247 { 1248 if(isdemo() || intermission == 2 || scoreboard_active) 1249 { 1250 HUD_Configure_Exit_Force(); 1251 return; 1252 } 1253 1254 if(!hud_configure_prev) 1255 { 1256 if(autocvar_hud_cursormode) 1257 setcursormode(1); 1258 hudShiftState = 0; 1259 for(i = hud_panels_COUNT - 1; i >= 0; --i) 1260 hud_panels_from(panel_order[i]).update_time = time; 1261 } 1262 1263 // NOTE this check is necessary because _menu_alpha isn't updated the frame the menu gets enabled 1264 if(autocvar__menu_alpha != _menu_alpha_prev) 1265 { 1266 if(autocvar__menu_alpha == 0) 1267 hud_configure_menu_open = 0; 1268 _menu_alpha_prev = autocvar__menu_alpha; 1269 } 1270 1271 HUD_Configure_DrawGrid(); 1272 } 1273 else if(hud_configure_prev) 1274 { 1275 if(hud_configure_menu_open) 1276 hud_configure_menu_open = 0; 1277 if(autocvar_hud_cursormode) 1278 setcursormode(0); 1279 hud_dynamic_shake_factor = -1; 1280 } 1281} 1282 1283const float hlBorderSize = 2; 1284const string hlBorder = "gfx/hud/default/border_highlighted"; 1285const string hlBorder2 = "gfx/hud/default/border_highlighted2"; 1286void HUD_Panel_HlBorder(float myBorder, vector color, float theAlpha) 1287{ 1288 drawfill(panel_pos - '1 1 0' * myBorder, panel_size + '2 2 0' * myBorder, '0 0.5 1', .5 * theAlpha, DRAWFLAG_NORMAL); 1289 drawpic_tiled(panel_pos - '1 1 0' * myBorder, hlBorder, '8 1 0' * hlBorderSize, eX * (panel_size.x + 2 * myBorder) + eY * hlBorderSize, color, theAlpha, DRAWFLAG_NORMAL); 1290 drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * (panel_size.y + 2 * myBorder - hlBorderSize), hlBorder, '8 1 0' * hlBorderSize, eX * (panel_size.x + 2 * myBorder) + eY * hlBorderSize, color, theAlpha, DRAWFLAG_NORMAL); 1291 drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * hlBorderSize, hlBorder2, '1 8 0' * hlBorderSize, eY * (panel_size.y + 2 * myBorder - 2 * hlBorderSize) + eX * hlBorderSize, color, theAlpha, DRAWFLAG_NORMAL); 1292 drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * hlBorderSize + eX * (panel_size.x + 2 * myBorder - hlBorderSize), hlBorder2, '1 8 0' * hlBorderSize, eY * (panel_size.y + 2 * myBorder - 2 * hlBorderSize) + eX * hlBorderSize, color, theAlpha, DRAWFLAG_NORMAL); 1293} 1294 1295void HUD_Configure_PostDraw() 1296{ 1297 if(autocvar__hud_configure) 1298 { 1299 if(tab_panel) 1300 { 1301 panel = tab_panel; 1302 HUD_Panel_UpdatePosSize(); 1303 drawfill(panel_pos - '1 1 0' * panel_bg_border, panel_size + '2 2 0' * panel_bg_border, '1 1 1', .2, DRAWFLAG_NORMAL); 1304 } 1305 if(highlightedPanel) 1306 { 1307 panel = highlightedPanel; 1308 HUD_Panel_UpdatePosSize(); 1309 HUD_Panel_HlBorder(panel_bg_border * hlBorderSize, '0 0.5 1', 0.4 * (1 - autocvar__menu_alpha)); 1310 } 1311 } 1312} 1313