Merge branch 'terencehill/menu_remove_tab_title' into 'master'
[xonotic/xonotic-data.pk3dir.git] / qcsrc / menu / menu.qc
1 #include "menu.qh"
2 #include "oo/classes.qc"
3 #include "xonotic/util.qh"
4
5 #include "../common/weapons/all.qh"
6 #include "../common/mapinfo.qh"
7
8 ///////////////////////////////////////////////
9 // Menu Source File
10 ///////////////////////
11 // This file belongs to dpmod/darkplaces
12 // AK contains all menu functions (especially the required ones)
13 ///////////////////////////////////////////////
14
15 float mouseButtonsPressed;
16 vector menuMousePos;
17 int menuShiftState;
18 float menuPrevTime;
19 float menuAlpha;
20 float menuLogoAlpha;
21 float prevMenuAlpha;
22 float menuInitialized;
23 float menuNotTheFirstFrame;
24 float menuMouseMode;
25
26 float conwidth_s, conheight_s, vidwidth_s, vidheight_s, vidpixelheight_s,
27       realconwidth, realconheight;
28
29 void m_sync()
30 {
31         updateCompression();
32         vidwidth_s = vidheight_s = vidpixelheight_s = 0;  // Force updateConwidths on next draw.
33
34         loadAllCvars(main);
35 }
36
37 void m_gamestatus()
38 {
39         gamestatus = 0;
40         if(isserver())
41                 gamestatus = gamestatus | GAME_ISSERVER;
42         if(clientstate() == CS_CONNECTED || isdemo())
43                 gamestatus = gamestatus | GAME_CONNECTED;
44         if(cvar("developer"))
45                 gamestatus = gamestatus | GAME_DEVELOPER;
46 }
47
48 void m_init()
49 {
50         float restarting = 0;
51         cvar_set("_menu_alpha", "0");
52         prvm_language = cvar_string("prvm_language");
53         if(prvm_language == "")
54         {
55                 prvm_language = "en";
56                 cvar_set("prvm_language", prvm_language);
57                 localcmd("\nmenu_restart\n");
58                 restarting = 1;
59         }
60         prvm_language = strzone(prvm_language);
61         cvar_set("_menu_prvm_language", prvm_language);
62
63 #ifdef WATERMARK
64         dprintf("^4MQC Build information: ^1%s\n", WATERMARK);
65 #endif
66
67         // list all game dirs (TEST)
68         if(cvar("developer"))
69         {
70                 float i;
71                 string s;
72                 for(i = 0; ; ++i)
73                 {
74                         s = getgamedirinfo(i, GETGAMEDIRINFO_NAME);
75                         if (!s)
76                                 break;
77                         dprint(s, ": ", getgamedirinfo(i, GETGAMEDIRINFO_DESCRIPTION));
78                 }
79         }
80
81         // needs to be done so early because of the constants they create
82         CALL_ACCUMULATED_FUNCTION(RegisterWeapons);
83         CALL_ACCUMULATED_FUNCTION(RegisterGametypes);
84
85         RegisterSLCategories();
86
87         float ddsload = cvar("r_texture_dds_load");
88         float texcomp = cvar("gl_texturecompression");
89         updateCompression();
90         if(ddsload != cvar("r_texture_dds_load") || texcomp != cvar("gl_texturecompression"))
91                 localcmd("\nr_restart\n");
92
93         if(!restarting)
94         {
95                 if(cvar("_menu_initialized")) // always show menu after menu_restart
96                         m_display();
97                 else
98                         m_hide();
99                 cvar_set("_menu_initialized", "1");
100         }
101
102 }
103
104 const float MENU_ASPECT = 1.25; // 1280x1024
105
106 void draw_reset_cropped()
107 {
108         draw_reset(conwidth, conheight, 0.5 * (realconwidth - conwidth), 0.5 * (realconheight - conheight));
109 }
110 void draw_reset_full()
111 {
112         draw_reset(realconwidth, realconheight, 0, 0);
113 }
114
115 void UpdateConWidthHeight(float w, float h, float p)
116 {
117         if (w != vidwidth_s || h != vidheight_s || p != vidpixelheight_s)
118         {
119                 if (updateConwidths(w, h, p))
120                         localcmd(sprintf("\nexec %s\n", cvar_string("menu_font_cfg")));
121                 vidwidth_s = w;
122                 vidheight_s = h;
123                 vidpixelheight_s = p;
124         }
125         conwidth_s = conwidth;
126         conheight_s = conheight;
127         realconwidth = cvar("vid_conwidth");
128         realconheight = cvar("vid_conheight");
129         if(realconwidth / realconheight > MENU_ASPECT)
130         {
131                 // widescreen
132                 conwidth = realconheight * MENU_ASPECT;
133                 conheight = realconheight;
134         }
135         else
136         {
137                 // squarescreen
138                 conwidth = realconwidth;
139                 conheight = realconwidth / MENU_ASPECT;
140         }
141         if(main)
142         {
143                 if(conwidth_s != conwidth || conheight_s != conheight)
144                 {
145                         draw_reset_cropped();
146                         main.resizeNotify(main, '0 0 0', eX * conwidth + eY * conheight, '0 0 0', eX * conwidth + eY * conheight);
147                 }
148         }
149         else
150         {
151                 vidwidth_s = vidheight_s = vidpixelheight_s = 0; // retry next frame
152         }
153 }
154
155 string m_goto_buffer;
156 void m_init_delayed()
157 {
158         float fh, glob, n, i;
159         string s;
160
161         draw_reset_cropped();
162
163         menuInitialized = 0;
164         if(!preMenuInit())
165                 return;
166         menuInitialized = 1;
167
168         fh = -1;
169         if(cvar_string("menu_skin") != "")
170         {
171                 draw_currentSkin = strcat("gfx/menu/", cvar_string("menu_skin"));
172                 fh = fopen(language_filename(strcat(draw_currentSkin, "/skinvalues.txt")), FILE_READ);
173         }
174         if(fh < 0)
175         if(cvar_defstring("menu_skin") != "")
176         {
177                 cvar_set("menu_skin", cvar_defstring("menu_skin"));
178                 draw_currentSkin = strcat("gfx/menu/", cvar_string("menu_skin"));
179                 fh = fopen(language_filename(strcat(draw_currentSkin, "/skinvalues.txt")), FILE_READ);
180         }
181         if(fh < 0)
182         {
183                 draw_currentSkin = "gfx/menu/default";
184                 fh = fopen(language_filename(strcat(draw_currentSkin, "/skinvalues.txt")), FILE_READ);
185         }
186         if(fh < 0)
187         {
188                 error("cannot load any menu skin\n");
189         }
190         draw_currentSkin = strzone(draw_currentSkin);
191         while((s = fgets(fh)))
192         {
193                 // these two are handled by skinlist.qc
194                 if(substring(s, 0, 6) == "title ")
195                         continue;
196                 if(substring(s, 0, 7) == "author ")
197                         continue;
198                 n = tokenize_console(s);
199                 if(n >= 2)
200                         Skin_ApplySetting(argv(0), substring(s, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)));
201         }
202         fclose(fh);
203
204         glob = search_begin(strcat(draw_currentSkin, "/*.tga"), true, true);
205         if(glob >= 0)
206         {
207                 n = search_getsize(glob);
208                 for(i = 0; i < n; ++i)
209                         precache_pic(search_getfilename(glob, i));
210                 search_end(glob);
211         }
212
213         draw_setMousePointer(SKINGFX_CURSOR, SKINSIZE_CURSOR, SKINOFFSET_CURSOR);
214
215         loadTooltips();
216         anim = NEW(AnimHost);
217         main = NEW(MainWindow); main.configureMainWindow(main);
218         unloadTooltips();
219
220         main.resizeNotify(main, '0 0 0', eX * conwidth + eY * conheight, '0 0 0', eX * conwidth + eY * conheight);
221         main.focused = 1;
222         menuShiftState = 0;
223         menuMousePos = '0.5 0.5 0';
224
225         m_sync();
226
227         if(m_goto_buffer)
228         {
229                 m_goto(m_goto_buffer);
230                 strunzone(m_goto_buffer);
231                 m_goto_buffer = string_null;
232         }
233
234         if(Menu_Active)
235                 m_display(); // delayed menu display
236 }
237
238 void m_keyup (float key, float ascii)
239 {
240         if(!menuInitialized)
241                 return;
242         if(!Menu_Active)
243                 return;
244         draw_reset_cropped();
245         main.keyUp(main, key, ascii, menuShiftState);
246         if(key >= K_MOUSE1 && key <= K_MOUSE3)
247         {
248                 --mouseButtonsPressed;
249                 if(!mouseButtonsPressed)
250                         main.mouseRelease(main, menuMousePos);
251                 if(mouseButtonsPressed < 0)
252                 {
253                         mouseButtonsPressed = 0;
254                         dprint("Warning: released an already released button\n");
255                 }
256         }
257         if(key == K_ALT) menuShiftState -= (menuShiftState & S_ALT);
258         if(key == K_CTRL) menuShiftState -= (menuShiftState & S_CTRL);
259         if(key == K_SHIFT) menuShiftState -= (menuShiftState & S_SHIFT);
260 }
261
262 void m_keydown(float key, float ascii)
263 {
264         if(!menuInitialized)
265                 return;
266         if(!Menu_Active)
267                 return;
268
269         if(menuMouseMode)
270         if(key >= K_MOUSE1 && key <= K_MOUSE3)
271         {
272                 // detect a click outside of the game window
273                 vector p = getmousepos();
274                 if(p.x < 0 || p.x > realconwidth || p.y < 0 || p.y > realconheight)
275                 {
276                         ++mouseButtonsPressed;
277                         return;
278                 }
279         }
280
281         if(keyGrabber)
282         {
283                 entity e;
284                 e = keyGrabber;
285                 keyGrabber = NULL;
286                 e.keyGrabbed(e, key, ascii);
287         }
288         else
289         {
290                 draw_reset_cropped();
291                 if(key >= K_MOUSE1 && key <= K_MOUSE3)
292                         if(!mouseButtonsPressed)
293                                 main.mousePress(main, menuMousePos);
294                 if(!main.keyDown(main, key, ascii, menuShiftState))
295                         if(key == K_ESCAPE)
296                                 if(gamestatus & (GAME_ISSERVER | GAME_CONNECTED)) // don't back out to console only
297                                         m_hide(); // disable menu on unhandled ESC
298         }
299         if(key >= K_MOUSE1 && key <= K_MOUSE3)
300         {
301                 ++mouseButtonsPressed;
302                 if(mouseButtonsPressed > 10)
303                 {
304                         mouseButtonsPressed = 10;
305                         dprint("Warning: pressed an already pressed button\n");
306                 }
307         }
308         if(key == K_ALT) menuShiftState |= S_ALT;
309         if(key == K_CTRL) menuShiftState |= S_CTRL;
310         if(key == K_SHIFT) menuShiftState |= S_SHIFT;
311 }
312
313 const float SCALEMODE_CROP = 0;
314 const float SCALEMODE_LETTERBOX = 1;
315 const float SCALEMODE_WIDTH = 2;
316 const float SCALEMODE_HEIGHT = 3;
317 const float SCALEMODE_STRETCH = 4;
318 void draw_Picture_Aligned(vector algn, float scalemode, string img, float a)
319 {
320         vector sz, org, isz, isz_w, isz_h;
321         float width_is_larger;
322
323         sz = draw_PictureSize(img);
324         width_is_larger = (sz.x * draw_scale.y >= sz.y * draw_scale.x);
325         isz_w = '1 0 0' + '0 1 0' * ((sz.y / sz.x) * (draw_scale.x / draw_scale.y));
326         isz_h = '0 1 0' + '1 0 0' * ((sz.x / sz.y) * (draw_scale.y / draw_scale.x));
327
328         switch(scalemode)
329         {
330                 default:
331                 case SCALEMODE_CROP:
332                         isz = (width_is_larger ? isz_h : isz_w);
333                         break;
334                 case SCALEMODE_LETTERBOX:
335                         isz = (width_is_larger ? isz_w : isz_h);
336                         break;
337                 case SCALEMODE_WIDTH:
338                         isz = isz_w;
339                         break;
340                 case SCALEMODE_HEIGHT:
341                         isz = isz_h;
342                         break;
343                 case SCALEMODE_STRETCH:
344                         isz = '1 1 0';
345                         break;
346         }
347
348         org = eX * (algn.x * (1 - isz.x)) + eY * (algn.y * (1 - isz.y));
349         draw_Picture(org, img, isz, '1 1 1', a);
350 }
351
352 void drawBackground(string img, float a, string algn, float force1)
353 {
354         if(main.mainNexposee.ModalController_state == 0)
355                 return;
356
357         vector v;
358         float i, l;
359         string c;
360         float scalemode;
361
362         v.z = 0;
363
364         scalemode = SCALEMODE_CROP;
365
366         l = 0;
367         for(i = 0; i < strlen(algn); ++i)
368         {
369                 c = substring(algn, i, 1);
370                 switch(c)
371                 {
372                         case "c": scalemode = SCALEMODE_CROP; goto nopic;
373                         case "l": scalemode = SCALEMODE_LETTERBOX; goto nopic;
374                         case "h": scalemode = SCALEMODE_HEIGHT; goto nopic;
375                         case "w": scalemode = SCALEMODE_WIDTH; goto nopic;
376                         case "s": scalemode = SCALEMODE_STRETCH; goto nopic;
377                         case "1": case "4": case "7": v.x = 0.0; break;
378                         case "2": case "5": case "8": v.x = 0.5; break;
379                         case "3": case "6": case "9": v.x = 1.0; break;
380                         default: v.x = random(); break;
381                 }
382                 switch(c)
383                 {
384                         case "7": case "8": case "9": v.y = 0.0; break;
385                         case "4": case "5": case "6": v.y = 0.5; break;
386                         case "1": case "2": case "3": v.y = 1.0; break;
387                         default: v.y = random(); break;
388                 }
389                 if(l == 0)
390                         draw_Picture_Aligned(v, scalemode, img, a);
391                 else if(force1)
392                         // force all secondary layers to use alpha 1. Prevents ugly issues
393                         // with overlap. It's a flag because it cannot be used for the
394                         // ingame background
395                         draw_Picture_Aligned(v, scalemode, strcat(img, "_l", ftos(l+1)), 1);
396                 else
397                         draw_Picture_Aligned(v, scalemode, strcat(img, "_l", ftos(l+1)), a);
398                 ++l;
399 :nopic
400         }
401 }
402
403 float menu_tooltips;
404 float menu_tooltips_old;
405 vector menuTooltipAveragedMousePos;
406 entity menuTooltipItem;
407 vector menuTooltipOrigin;
408 vector menuTooltipSize;
409 float menuTooltipAlpha;
410 string menuTooltipText;
411 float menuTooltipState; // 0: static, 1: fading in, 2: fading out
412 float m_testmousetooltipbox(vector pos)
413 {
414         if(pos.x >= menuTooltipOrigin.x && pos.x < menuTooltipOrigin.x + menuTooltipSize.x)
415         if(pos.y >= menuTooltipOrigin.y && pos.y < menuTooltipOrigin.y + menuTooltipSize.y)
416                 return false;
417         return true;
418 }
419 float m_testtooltipbox(vector tooltippos)
420 {
421         if(tooltippos.x < 0)
422                 return false;
423         if(tooltippos.y < 0)
424                 return false;
425         if(tooltippos.x + menuTooltipSize.x > 1)
426                 return false;
427         if(tooltippos.y + menuTooltipSize.y > 1)
428                 return false;
429         menuTooltipOrigin = tooltippos;
430         return true;
431 }
432 float m_allocatetooltipbox(vector pos)
433 {
434         vector avoidplus, avoidminus;
435         vector v;
436
437         avoidplus.x = (SKINAVOID_TOOLTIP_x + SKINSIZE_CURSOR_x - SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth;
438         avoidplus.y = (SKINAVOID_TOOLTIP_y + SKINSIZE_CURSOR_y - SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight;
439         avoidplus.z = 0;
440
441         avoidminus.x = (SKINAVOID_TOOLTIP_x + SKINOFFSET_CURSOR_x * SKINSIZE_CURSOR_x) / conwidth + menuTooltipSize.x;
442         avoidminus.y = (SKINAVOID_TOOLTIP_y + SKINOFFSET_CURSOR_y * SKINSIZE_CURSOR_y) / conheight + menuTooltipSize.y;
443         avoidminus.z = 0;
444
445         // bottom right
446         v = pos + avoidplus;
447         if(m_testtooltipbox(v))
448                 return true;
449
450         // bottom center
451         v.x = pos.x - menuTooltipSize.x * 0.5;
452         if(m_testtooltipbox(v))
453                 return true;
454
455         // bottom left
456         v.x = pos.x - avoidminus.x;
457         if(m_testtooltipbox(v))
458                 return true;
459
460         // top left
461         v.y = pos.y - avoidminus.y;
462         if(m_testtooltipbox(v))
463                 return true;
464
465         // top center
466         v.x = pos.x - menuTooltipSize.x * 0.5;
467         if(m_testtooltipbox(v))
468                 return true;
469
470         // top right
471         v.x = pos.x + avoidplus.x;
472         if(m_testtooltipbox(v))
473                 return true;
474
475         return false;
476 }
477 entity m_findtooltipitem(entity root, vector pos)
478 {
479         entity it;
480         entity best;
481
482         best = world;
483         it = root;
484
485         while(it.instanceOfContainer)
486         {
487                 while(it.instanceOfNexposee && it.focusedChild)
488                 {
489                         it = it.focusedChild;
490                         pos = globalToBox(pos, it.Container_origin, it.Container_size);
491                 }
492                 if(it.instanceOfNexposee)
493                 {
494                         it = it.itemFromPoint(it, pos);
495                         if(it.tooltip)
496                                 best = it;
497                         else if(menu_tooltips == 2 && (it.cvarName || it.onClickCommand))
498                                 best = it;
499                         it = world;
500                 }
501                 else if(it.instanceOfModalController)
502                         it = it.focusedChild;
503                 else
504                         it = it.itemFromPoint(it, pos);
505                 if(!it)
506                         break;
507                 if(it.tooltip)
508                         best = it;
509                 else if(menu_tooltips == 2 && (it.cvarName || it.onClickCommand))
510                         best = it;
511                 pos = globalToBox(pos, it.Container_origin, it.Container_size);
512         }
513
514         return best;
515 }
516 string gettooltip()
517 {
518         if (menu_tooltips == 2)
519         {
520                 string s;
521                 if (menuTooltipItem.cvarName)
522                 {
523                         if (getCvarsMulti(menuTooltipItem))
524                                 s = strcat("[", menuTooltipItem.cvarName, " ", getCvarsMulti(menuTooltipItem), "]");
525                         else
526                                 s = strcat("[", menuTooltipItem.cvarName, "]");
527                 }
528                 else if (menuTooltipItem.onClickCommand)
529                         s = strcat("<", menuTooltipItem.onClickCommand, ">");
530                 else
531                         return menuTooltipItem.tooltip;
532                 if (menuTooltipItem.tooltip)
533                         return strcat(menuTooltipItem.tooltip, " ", s);
534                 return s;
535         }
536         return menuTooltipItem.tooltip;
537 }
538 void m_tooltip(vector pos)
539 {
540         float f, i, w;
541         entity it;
542         vector fontsize, p;
543         string s;
544
545         menu_tooltips = cvar("menu_tooltips");
546         if (!menu_tooltips)
547         {
548                 // don't return immediately, fade out the active tooltip first
549                 if (menuTooltipItem == world)
550                         return;
551                 it = world;
552                 menu_tooltips_old = menu_tooltips;
553         }
554         else
555         {
556                 f = bound(0, frametime * 2, 1);
557                 menuTooltipAveragedMousePos = menuTooltipAveragedMousePos * (1 - f) + pos * f;
558                 f = vlen(pos - menuTooltipAveragedMousePos);
559                 if(f < 0.01)
560                         it = m_findtooltipitem(main, pos);
561                 else
562                         it = world;
563         }
564         fontsize = '1 0 0' * (SKINFONTSIZE_TOOLTIP / conwidth) + '0 1 0' * (SKINFONTSIZE_TOOLTIP / conheight);
565
566         // float menuTooltipState; // 0: static, 1: fading in, 2: fading out
567         if(it != menuTooltipItem)
568         {
569                 switch(menuTooltipState)
570                 {
571                         case 0:
572                                 if(menuTooltipItem)
573                                 {
574                                         // another item: fade out first
575                                         menuTooltipState = 2;
576                                 }
577                                 else
578                                 {
579                                         // new item: fade in
580                                         menuTooltipState = 1;
581                                         menuTooltipItem = it;
582
583                                         menuTooltipOrigin.x = -1; // unallocated
584
585                                         if (menuTooltipText)
586                                                 strunzone(menuTooltipText);
587                                         menuTooltipText = strzone(gettooltip());
588
589                                         i = 0;
590                                         w = 0;
591                                         getWrappedLine_remaining = menuTooltipText;
592                                         while(getWrappedLine_remaining)
593                                         {
594                                                 s = getWrappedLine(SKINWIDTH_TOOLTIP, fontsize, draw_TextWidth_WithoutColors);
595                                                 ++i;
596                                                 f = draw_TextWidth(s, false, fontsize);
597                                                 if(f > w)
598                                                         w = f;
599                                         }
600                                         menuTooltipSize.x = w + 2 * (SKINMARGIN_TOOLTIP_x / conwidth);
601                                         menuTooltipSize.y = i * fontsize.y + 2 * (SKINMARGIN_TOOLTIP_y / conheight);
602                                         menuTooltipSize.z = 0;
603                                 }
604                                 break;
605                         case 1:
606                                 // changing item while fading in: fade out first
607                                 menuTooltipState = 2;
608                                 break;
609                         case 2:
610                                 // changing item while fading out: can't
611                                 break;
612                 }
613         }
614         else if(menuTooltipState == 2) // re-fade in?
615                 menuTooltipState = 1;
616
617         if(menuTooltipItem)
618                 if(!m_testmousetooltipbox(pos))
619                         menuTooltipState = 2; // fade out if mouse touches it
620
621         switch(menuTooltipState)
622         {
623                 case 1:
624                         menuTooltipAlpha = bound(0, menuTooltipAlpha + 5 * frametime, 1);
625                         if(menuTooltipAlpha == 1)
626                                 menuTooltipState = 0;
627                         break;
628                 case 2:
629                         menuTooltipAlpha = bound(0, menuTooltipAlpha - 2 * frametime, 1);
630                         if(menuTooltipAlpha == 0)
631                         {
632                                 menuTooltipState = 0;
633                                 menuTooltipItem = world;
634                         }
635                         break;
636         }
637
638         if(menuTooltipItem == world)
639         {
640                 if (menuTooltipText)
641                 {
642                         strunzone(menuTooltipText);
643                         menuTooltipText = string_null;
644                 }
645                 return;
646         }
647         else
648         {
649                 if(menu_tooltips != menu_tooltips_old)
650                 {
651                         if (menu_tooltips != 0 && menu_tooltips_old != 0)
652                                 menuTooltipItem = world; // reload tooltip next frame
653                         menu_tooltips_old = menu_tooltips;
654                 }
655                 else if(menuTooltipOrigin.x < 0) // unallocated?
656                         m_allocatetooltipbox(pos);
657
658                 if(menuTooltipOrigin.x >= 0)
659                 {
660                         // draw the tooltip!
661                         p = SKINBORDER_TOOLTIP;
662                         p.x *= 1 / conwidth;
663                         p.y *= 1 / conheight;
664                         draw_BorderPicture(menuTooltipOrigin, SKINGFX_TOOLTIP, menuTooltipSize, '1 1 1', menuTooltipAlpha, p);
665                         p = menuTooltipOrigin;
666                         p.x += SKINMARGIN_TOOLTIP_x / conwidth;
667                         p.y += SKINMARGIN_TOOLTIP_y / conheight;
668                         getWrappedLine_remaining = menuTooltipText;
669                         while(getWrappedLine_remaining)
670                         {
671                                 s = getWrappedLine(SKINWIDTH_TOOLTIP, fontsize, draw_TextWidth_WithoutColors);
672                                 draw_Text(p, s, fontsize, SKINCOLOR_TOOLTIP, SKINALPHA_TOOLTIP * menuTooltipAlpha, false);
673                                 p.y += fontsize.y;
674                         }
675                 }
676         }
677 }
678
679 void m_draw(float width, float height)
680 {
681         float t;
682         float realFrametime;
683
684         m_gamestatus();
685
686         execute_next_frame();
687
688         menuMouseMode = cvar("menu_mouse_absolute");
689
690         if (anim)
691                 anim.tickAll(anim);
692
693         UpdateConWidthHeight(width, height, cvar("vid_pixelheight"));
694
695         if(!menuInitialized)
696         {
697                 // TODO draw an info image about this situation
698                 m_init_delayed();
699                 return;
700         }
701         if(!menuNotTheFirstFrame)
702         {
703                 menuNotTheFirstFrame = 1;
704                 if(Menu_Active)
705                 if(!cvar("menu_video_played"))
706                 {
707                         localcmd("cd loop $menu_cdtrack; play sound/announcer/default/welcome.wav\n");
708                         menuLogoAlpha = -0.8; // no idea why, but when I start this at zero, it jumps instead of fading FIXME
709                 }
710                 // ALWAYS set this cvar; if we start but menu is not active, this means we want no background music!
711                 localcmd("set menu_video_played 1\n");
712         }
713
714         t = gettime();
715         realFrametime = frametime = min(0.2, t - menuPrevTime);
716         menuPrevTime = t;
717         time += frametime;
718
719         t = cvar("menu_slowmo");
720         if(t)
721         {
722                 frametime *= t;
723                 realFrametime *= t;
724         }
725         else
726                 t = 1;
727
728         if(Menu_Active)
729         {
730                 if(getmousetarget() == (menuMouseMode ? MT_CLIENT : MT_MENU) && (getkeydest() == KEY_MENU || getkeydest() == KEY_MENU_GRABBED))
731                         setkeydest(keyGrabber ? KEY_MENU_GRABBED : KEY_MENU);
732                 else
733                         m_hide();
734         }
735
736         if(cvar("cl_capturevideo"))
737                 frametime = t / cvar("cl_capturevideo_fps"); // make capturevideo work smoothly
738
739         prevMenuAlpha = menuAlpha;
740         if(Menu_Active)
741         {
742                 if(menuAlpha == 0 && menuLogoAlpha < 2)
743                 {
744                         menuLogoAlpha = menuLogoAlpha + frametime * 2;
745                 }
746                 else
747                 {
748                         menuAlpha = min(1, menuAlpha + frametime * 5);
749                         menuLogoAlpha = 2;
750                 }
751         }
752         else
753         {
754                 menuAlpha = max(0, menuAlpha - frametime * 5);
755                 menuLogoAlpha = 2;
756         }
757
758         draw_reset_cropped();
759
760         if(!(gamestatus & (GAME_CONNECTED | GAME_ISSERVER)))
761         {
762                 if(menuLogoAlpha > 0)
763                 {
764                         draw_reset_full();
765                         draw_Fill('0 0 0', '1 1 0', SKINCOLOR_BACKGROUND, 1);
766                         drawBackground(SKINGFX_BACKGROUND, bound(0, menuLogoAlpha, 1), SKINALIGN_BACKGROUND, true);
767                         draw_reset_cropped();
768                         if(menuAlpha <= 0 && SKINALPHA_CURSOR_INTRO > 0)
769                         {
770                                 draw_alpha = SKINALPHA_CURSOR_INTRO * bound(0, menuLogoAlpha, 1);
771                                 draw_drawMousePointer(menuMousePos);
772                                 draw_alpha = 1;
773                         }
774                 }
775         }
776         else if(SKINALPHA_BACKGROUND_INGAME)
777         {
778                 if(menuAlpha > 0)
779                 {
780                         draw_reset_full();
781                         drawBackground(SKINGFX_BACKGROUND_INGAME, menuAlpha * SKINALPHA_BACKGROUND_INGAME, SKINALIGN_BACKGROUND_INGAME, false);
782                         draw_reset_cropped();
783                 }
784         }
785
786         if(menuAlpha != prevMenuAlpha)
787                 cvar_set("_menu_alpha", ftos(menuAlpha));
788
789         draw_reset_cropped();
790         preMenuDraw();
791         draw_reset_cropped();
792
793         if(menuAlpha <= 0)
794         {
795                 if(prevMenuAlpha > 0)
796                         main.initializeDialog(main, main.firstChild);
797                 draw_reset_cropped();
798                 postMenuDraw();
799                 return;
800         }
801
802         draw_alpha *= menuAlpha;
803
804         if(!Menu_Active)
805         {
806                 // do not update mouse position
807                 // it prevents mouse jumping to '0 0 0' when menu is fading out
808         }
809         else if(menuMouseMode)
810         {
811                 vector newMouse;
812                 newMouse = globalToBox(getmousepos(), draw_shift, draw_scale);
813                 if(newMouse != '0 0 0')
814                         if(newMouse != menuMousePos)
815                         {
816                                 menuMousePos = newMouse;
817                                 if(mouseButtonsPressed)
818                                         main.mouseDrag(main, menuMousePos);
819                                 else
820                                         main.mouseMove(main, menuMousePos);
821                         }
822         }
823         else
824         {
825                 if(frametime > 0)
826                 {
827                         vector dMouse, minpos, maxpos;
828                         dMouse = getmousepos() * (frametime / realFrametime); // for capturevideo
829                         if(dMouse != '0 0 0')
830                         {
831                                 minpos = globalToBox('0 0 0', draw_shift, draw_scale);
832                                 maxpos = globalToBox(eX * (realconwidth - 1) + eY * (realconheight - 1), draw_shift, draw_scale);
833                                 dMouse = globalToBoxSize(dMouse, draw_scale);
834                                 menuMousePos += dMouse * cvar("menu_mouse_speed");
835                                 menuMousePos.x = bound(minpos.x, menuMousePos.x, maxpos.x);
836                                 menuMousePos.y = bound(minpos.y, menuMousePos.y, maxpos.y);
837                                 if(mouseButtonsPressed)
838                                         main.mouseDrag(main, menuMousePos);
839                                 else
840                                         main.mouseMove(main, menuMousePos);
841                         }
842                 }
843         }
844         main.draw(main);
845
846         m_tooltip(menuMousePos);
847
848         draw_alpha = max(draw_alpha, SKINALPHA_CURSOR_INTRO * bound(0, menuLogoAlpha, 1));
849
850         draw_drawMousePointer(menuMousePos);
851
852         draw_reset_cropped();
853         postMenuDraw();
854
855         frametime = 0;
856 }
857
858 void m_display()
859 {
860         Menu_Active = true;
861         setkeydest(KEY_MENU);
862         setmousetarget((menuMouseMode ? MT_CLIENT : MT_MENU));
863
864         if(!menuInitialized)
865                 return;
866
867         if(mouseButtonsPressed)
868                 main.mouseRelease(main, menuMousePos);
869         mouseButtonsPressed = 0;
870
871         main.focusEnter(main);
872         main.showNotify(main);
873 }
874
875 void m_hide()
876 {
877         Menu_Active = false;
878         setkeydest(KEY_GAME);
879         setmousetarget(MT_CLIENT);
880
881         if(!menuInitialized)
882                 return;
883
884         main.focusLeave(main);
885         main.hideNotify(main);
886 }
887
888 void m_toggle(float mode)
889 {
890         if(Menu_Active)
891         {
892                 if (mode == 1)
893                         return;
894                 m_hide();
895         }
896         else
897         {
898                 if (mode == 0)
899                         return;
900                 m_display();
901         }
902 }
903
904 void Shutdown()
905 {
906         entity e;
907
908         m_hide();
909         for(e = NULL; (e = nextent(e)) != NULL; )
910         {
911                 if(e.classname != "vtbl")
912                         if(e.destroy)
913                                 e.destroy(e);
914         }
915 }
916
917 void m_focus_item_chain(entity outermost, entity innermost)
918 {
919         if(innermost.parent != outermost)
920                 m_focus_item_chain(outermost, innermost.parent);
921         innermost.parent.setFocus(innermost.parent, innermost);
922 }
923
924 void m_activate_window(entity wnd)
925 {
926         entity par;
927         par = wnd.parent;
928         if(par)
929                 m_activate_window(par);
930
931         if(par.instanceOfModalController)
932         {
933                 if(wnd.tabSelectingButton)
934                         // tabs
935                         TabButton_Click(wnd.tabSelectingButton, wnd);
936                 else
937                         // root
938                         par.initializeDialog(par, wnd);
939         }
940         else if(par.instanceOfNexposee)
941         {
942                 // nexposee (sorry for violating abstraction here)
943                 par.selectedChild = wnd;
944                 par.animationState = 1;
945                 Container_setFocus(par, NULL);
946         }
947         else if(par.instanceOfContainer)
948         {
949                 // other containers
950                 if(par.focused)
951                         par.setFocus(par, wnd);
952         }
953 }
954
955 void m_setpointerfocus(entity wnd)
956 {
957         if(wnd.instanceOfContainer)
958         {
959                 entity focus = wnd.preferredFocusedGrandChild(wnd);
960                 if(focus)
961                 {
962                         menuMousePos = focus.origin + 0.5 * focus.size;
963                         menuMousePos.x *= 1 / conwidth;
964                         menuMousePos.y *= 1 / conheight;
965                         entity par = wnd.parent;
966                         if(par.focused)
967                                 par.setFocus(par, wnd);
968                         if(wnd.focused)
969                                 m_focus_item_chain(wnd, focus);
970                 }
971         }
972 }
973
974 void m_goto(string itemname)
975 {
976         entity e;
977         if(!menuInitialized)
978         {
979                 if(m_goto_buffer)
980                         strunzone(m_goto_buffer);
981                 m_goto_buffer = strzone(itemname);
982                 return;
983         }
984         if(itemname == "") // this can be called by GameCommand
985         {
986                 if(gamestatus & (GAME_ISSERVER | GAME_CONNECTED))
987                 {
988                         m_hide();
989                 }
990                 else
991                 {
992                         m_activate_window(main.mainNexposee);
993                         m_display();
994                 }
995         }
996         else
997         {
998                 for(e = NULL; (e = find(e, name, itemname)); )
999                         if(e.classname != "vtbl")
1000                                 break;
1001
1002                 if((e) && (!e.requiresConnection || (gamestatus & (GAME_ISSERVER | GAME_CONNECTED))))
1003                 {
1004                         m_hide();
1005                         m_activate_window(e);
1006                         m_setpointerfocus(e);
1007                         m_display();
1008                 }
1009         }
1010 }
1011
1012 float menuLastFocusSoundTime;
1013 void m_play_focus_sound()
1014 {
1015         if(cvar("menu_sounds") > 1)
1016                 if(time - menuLastFocusSoundTime > 0.25)
1017                 {
1018                         localsound(MENU_SOUND_FOCUS);
1019                         menuLastFocusSoundTime = time;
1020                 }
1021 }
1022
1023 void m_play_click_sound(string soundfile)
1024 {
1025         if(cvar("menu_sounds"))
1026                 localsound(soundfile);
1027 }