Rename a few parameters and locals named x, y, z
[xonotic/xonotic-data.pk3dir.git] / qcsrc / menu / item / listbox.qc
1 #include "listbox.qh"
2
3         bool ListBox_isScrolling(entity me)
4         {
5                 return me.scrollPos != me.scrollPosTarget;
6         }
7
8         void ListBox_scrollToItem(entity me, int i)
9         {
10                 // scroll doesn't work properly until itemHeight is set to the correct value
11                 // at the first resizeNotify call
12                 if (me.itemHeight == 1)  // initial temporary value of itemHeight is 1
13                 {
14                         me.needScrollToItem = i;
15                         return;
16                 }
17
18                 i = bound(0, i, me.nItems - 1);
19
20                 // scroll the list to make sure the selected item is visible
21                 // (even if the selected item doesn't change).
22                 if (i < me.getFirstFullyVisibleItemAtScrollPos(me, me.scrollPos))
23                 {
24                         // above visible area
25                         me.scrollPosTarget = me.getItemStart(me, i);
26                 }
27                 else if (i > me.getLastFullyVisibleItemAtScrollPos(me, me.scrollPos))
28                 {
29                         // below visible area
30                         if (i == me.nItems - 1) me.scrollPosTarget = me.getTotalHeight(me) - 1;
31                         else me.scrollPosTarget = me.getItemStart(me, i + 1) - 1;
32                 }
33         }
34
35         void ListBox_setSelected(entity me, float i)
36         {
37                 i = bound(0, i, me.nItems - 1);
38                 me.scrollToItem(me, i);
39                 me.selectedItem = i;
40         }
41         void ListBox_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
42         {
43                 SUPER(ListBox).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
44                 me.controlWidth = me.scrollbarWidth / absSize.x;
45         }
46         void ListBox_configureListBox(entity me, float theScrollbarWidth, float theItemHeight)
47         {
48                 me.scrollbarWidth = theScrollbarWidth;
49                 me.itemHeight = theItemHeight;
50         }
51
52         float ListBox_getTotalHeight(entity me)
53         {
54                 return me.nItems * me.itemHeight;
55         }
56         float ListBox_getItemAtPos(entity me, float pos)
57         {
58                 return floor(pos / me.itemHeight);
59         }
60         float ListBox_getItemStart(entity me, float i)
61         {
62                 return me.itemHeight * i;
63         }
64         float ListBox_getItemHeight(entity me, float i)
65         {
66                 return me.itemHeight;
67         }
68
69         float ListBox_getLastFullyVisibleItemAtScrollPos(entity me, float pos)
70         {
71                 return me.getItemAtPos(me, pos + 0.999) - 1;
72         }
73         float ListBox_getFirstFullyVisibleItemAtScrollPos(entity me, float pos)
74         {
75                 return me.getItemAtPos(me, pos + 0.001) + 1;
76         }
77         float ListBox_keyDown(entity me, float key, float ascii, float shift)
78         {
79                 if (key == K_MWHEELUP)
80                 {
81                         me.scrollPosTarget = max(me.scrollPosTarget - 0.5, 0);
82                 }
83                 else if (key == K_MWHEELDOWN)
84                 {
85                         me.scrollPosTarget = min(me.scrollPosTarget + 0.5, max(0, me.getTotalHeight(me) - 1));
86                 }
87                 else if (key == K_PGUP || key == K_KP_PGUP)
88                 {
89                         if (me.selectionDoesntMatter)
90                         {
91                                 me.scrollPosTarget = max(me.scrollPosTarget - 0.5, 0);
92                                 return 1;
93                         }
94
95                         float i = me.selectedItem;
96                         float a = me.getItemHeight(me, i);
97                         for ( ; ; )
98                         {
99                                 --i;
100                                 if (i < 0) break;
101                                 a += me.getItemHeight(me, i);
102                                 if (a >= 1) break;
103                         }
104                         me.setSelected(me, i + 1);
105                 }
106                 else if (key == K_PGDN || key == K_KP_PGDN)
107                 {
108                         if (me.selectionDoesntMatter)
109                         {
110                                 me.scrollPosTarget = min(me.scrollPosTarget + 0.5, me.nItems * me.itemHeight - 1);
111                                 return 1;
112                         }
113
114                         float i = me.selectedItem;
115                         float a = me.getItemHeight(me, i);
116                         for ( ; ; )
117                         {
118                                 ++i;
119                                 if (i >= me.nItems) break;
120                                 a += me.getItemHeight(me, i);
121                                 if (a >= 1) break;
122                         }
123                         me.setSelected(me, i - 1);
124                 }
125                 else if (key == K_UPARROW || key == K_KP_UPARROW)
126                 {
127                         if (me.selectionDoesntMatter)
128                         {
129                                 me.scrollPosTarget = max(me.scrollPosTarget - me.itemHeight, 0);
130                                 return 1;
131                         }
132
133                         me.setSelected(me, me.selectedItem - 1);
134                 }
135                 else if (key == K_DOWNARROW || key == K_KP_DOWNARROW)
136                 {
137                         if (me.selectionDoesntMatter)
138                         {
139                                 me.scrollPosTarget = min(me.scrollPosTarget + me.itemHeight, me.nItems * me.itemHeight - 1);
140                                 return 1;
141                         }
142
143                         me.setSelected(me, me.selectedItem + 1);
144                 }
145                 else if (key == K_HOME || key == K_KP_HOME)
146                 {
147                         me.setSelected(me, 0);
148                 }
149                 else if (key == K_END || key == K_KP_END)
150                 {
151                         me.setSelected(me, me.nItems - 1);
152                 }
153                 else
154                 {
155                         return 0;
156                 }
157                 return 1;
158         }
159         float ListBox_mouseMove(entity me, vector pos)
160         {
161                 me.mouseMoveOffset = -1;
162                 if (pos_x < 0) return 0;
163                 if (pos_y < 0) return 0;
164                 if (pos_x >= 1) return 0;
165                 if (pos_y >= 1) return 0;
166                 if (pos_x < 1 - me.controlWidth)
167                 {
168                         me.mouseMoveOffset = pos.y;
169                 }
170                 else
171                 {
172                         me.setFocusedItem(me, -1);
173                         me.mouseMoveOffset = -1;
174                 }
175                 return 1;
176         }
177         float ListBox_mouseDrag(entity me, vector pos)
178         {
179                 float hit;
180                 me.updateControlTopBottom(me);
181                 me.dragScrollPos = pos;
182                 if (me.pressed == 1)
183                 {
184                         hit = 1;
185                         if (pos.x < 1 - me.controlWidth - me.tolerance.y * me.controlWidth) hit = 0;
186                         if (pos.y < 0 - me.tolerance.x) hit = 0;
187                         if (pos.x >= 1 + me.tolerance.y * me.controlWidth) hit = 0;
188                         if (pos.y >= 1 + me.tolerance.x) hit = 0;
189                         if (hit)
190                         {
191                                 // calculate new pos to v
192                                 float d;
193                                 d = (pos.y - me.pressOffset) / (1 - (me.controlBottom - me.controlTop)) * (me.getTotalHeight(me) - 1);
194                                 me.scrollPosTarget = me.previousValue + d;
195                         }
196                         else
197                         {
198                                 me.scrollPosTarget = me.previousValue;
199                         }
200                         me.scrollPosTarget = min(me.scrollPosTarget, me.getTotalHeight(me) - 1);
201                         me.scrollPosTarget = max(me.scrollPosTarget, 0);
202                 }
203                 else if (me.pressed == 2)
204                 {
205                         me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
206                         me.setFocusedItem(me, me.selectedItem);
207                         me.mouseMoveOffset = -1;
208                 }
209                 return 1;
210         }
211         float ListBox_mousePress(entity me, vector pos)
212         {
213                 if (pos.x < 0) return 0;
214                 if (pos.y < 0) return 0;
215                 if (pos.x >= 1) return 0;
216                 if (pos.y >= 1) return 0;
217                 me.dragScrollPos = pos;
218                 me.updateControlTopBottom(me);
219                 if (pos.x >= 1 - me.controlWidth)
220                 {
221                         // if hit, set me.pressed, otherwise scroll by one page
222                         if (pos.y < me.controlTop)
223                         {
224                                 // page up
225                                 me.scrollPosTarget = max(me.scrollPosTarget - 1, 0);
226                         }
227                         else if (pos.y > me.controlBottom)
228                         {
229                                 // page down
230                                 me.scrollPosTarget = min(me.scrollPosTarget + 1, me.getTotalHeight(me) - 1);
231                         }
232                         else
233                         {
234                                 me.pressed = 1;
235                                 me.pressOffset = pos.y;
236                                 me.previousValue = me.scrollPos;
237                         }
238                 }
239                 else
240                 {
241                         // continue doing that while dragging (even when dragging outside). When releasing, forward the click to the then selected item.
242                         me.pressed = 2;
243                         // an item has been clicked. Select it, ...
244                         me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
245                         me.setFocusedItem(me, me.selectedItem);
246                 }
247                 return 1;
248         }
249         void ListBox_setFocusedItem(entity me, int item)
250         {
251                 float focusedItem_save = me.focusedItem;
252                 me.focusedItem = (item < me.nItems) ? item : -1;
253                 if (focusedItem_save != me.focusedItem)
254                 {
255                         me.focusedItemChangeNotify(me);
256                         if (me.focusedItem >= 0) me.focusedItemAlpha = SKINALPHA_LISTBOX_FOCUSED;
257                 }
258         }
259         float ListBox_mouseRelease(entity me, vector pos)
260         {
261                 if (me.pressed == 1)
262                 {
263                         // slider dragging mode
264                         // in that case, nothing happens on releasing
265                 }
266                 else if (me.pressed == 2)
267                 {
268                         me.pressed = 3;  // do that here, so setSelected can know the mouse has been released
269                         // item dragging mode
270                         // select current one one last time...
271                         me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
272                         me.setFocusedItem(me, me.selectedItem);
273                         // and give it a nice click event
274                         if (me.nItems > 0)
275                         {
276                                 vector where = globalToBox(pos, eY * (me.getItemStart(me, me.selectedItem) - me.scrollPos), eX * (1 - me.controlWidth) + eY * me.getItemHeight(me, me.selectedItem));
277
278                                 if ((me.selectedItem == me.lastClickedItem) && (time < me.lastClickedTime + 0.3)) me.doubleClickListBoxItem(me, me.selectedItem, where);
279                                 else me.clickListBoxItem(me, me.selectedItem, where);
280
281                                 me.lastClickedItem = me.selectedItem;
282                                 me.lastClickedTime = time;
283                         }
284                 }
285                 me.pressed = 0;
286                 return 1;
287         }
288         void ListBox_focusLeave(entity me)
289         {
290                 // Reset the var pressed in case listbox loses focus
291                 // by a mouse click on an item of the list
292                 // for example showing a dialog on right click
293                 me.pressed = 0;
294                 me.setFocusedItem(me, -1);
295                 me.mouseMoveOffset = -1;
296         }
297         void ListBox_updateControlTopBottom(entity me)
298         {
299                 float f;
300                 // scrollPos is in 0..1 and indicates where the "page" currently shown starts.
301                 if (me.getTotalHeight(me) <= 1)
302                 {
303                         // we don't need no stinkin' scrollbar, we don't need no view control...
304                         me.controlTop = 0;
305                         me.controlBottom = 1;
306                         me.scrollPos = 0;
307                 }
308                 else
309                 {
310                         // if scroll pos is below end of list, fix it
311                         me.scrollPos = min(me.scrollPos, me.getTotalHeight(me) - 1);
312                         // if scroll pos is above beginning of list, fix it
313                         me.scrollPos = max(me.scrollPos, 0);
314                         // now that we know where the list is scrolled to, find out where to draw the control
315                         me.controlTop = max(0, me.scrollPos / me.getTotalHeight(me));
316                         me.controlBottom = min((me.scrollPos + 1) / me.getTotalHeight(me), 1);
317
318                         float minfactor;
319                         minfactor = 2 * me.controlWidth / me.size.y * me.size.x;
320                         f = me.controlBottom - me.controlTop;
321                         if (f < minfactor)  // FIXME good default?
322                         {
323                                 // f * X + 1 * (1-X) = minfactor
324                                 // (f - 1) * X + 1 = minfactor
325                                 // (f - 1) * X = minfactor - 1
326                                 // X = (minfactor - 1) / (f - 1)
327                                 f = (minfactor - 1) / (f - 1);
328                                 me.controlTop = me.controlTop * f + 0 * (1 - f);
329                                 me.controlBottom = me.controlBottom * f + 1 * (1 - f);
330                         }
331                 }
332         }
333         AUTOCVAR(menu_scroll_averaging_time, float, 0.16, "smooth scroll averaging time");
334 // scroll faster while dragging the scrollbar
335         AUTOCVAR(menu_scroll_averaging_time_pressed, float, 0.06, "smooth scroll averaging time when dragging the scrollbar");
336         void ListBox_draw(entity me)
337         {
338                 float i;
339                 vector absSize, fillSize = '0 0 0';
340                 vector oldshift, oldscale;
341
342                 // we can't do this in mouseMove as the list can scroll without moving the cursor
343                 if (me.mouseMoveOffset != -1) me.setFocusedItem(me, me.getItemAtPos(me, me.scrollPos + me.mouseMoveOffset));
344
345                 if (me.needScrollToItem >= 0)
346                 {
347                         me.scrollToItem(me, me.needScrollToItem);
348                         me.needScrollToItem = -1;
349                 }
350                 if (me.scrollPos != me.scrollPosTarget)
351                 {
352                         float averaging_time = (me.pressed == 1)
353                             ? autocvar_menu_scroll_averaging_time_pressed
354                                 : autocvar_menu_scroll_averaging_time;
355                         // this formula works with whatever framerate
356                         float f = averaging_time ? exp(-frametime / averaging_time) : 0;
357                         me.scrollPos = me.scrollPos * f + me.scrollPosTarget * (1 - f);
358                         if (fabs(me.scrollPos - me.scrollPosTarget) < 0.001) me.scrollPos = me.scrollPosTarget;
359                 }
360
361                 if (me.pressed == 2) me.mouseDrag(me, me.dragScrollPos);  // simulate mouseDrag event
362                 me.updateControlTopBottom(me);
363                 fillSize.x = (1 - me.controlWidth);
364                 if (me.alphaBG) draw_Fill('0 0 0', '0 1 0' + fillSize, me.colorBG, me.alphaBG);
365                 if (me.controlWidth)
366                 {
367                         draw_VertButtonPicture(eX * (1 - me.controlWidth), strcat(me.src, "_s"), eX * me.controlWidth + eY, me.color2, 1);
368                         if (me.getTotalHeight(me) > 1)
369                         {
370                                 vector o, s;
371                                 o = eX * (1 - me.controlWidth) + eY * me.controlTop;
372                                 s = eX * me.controlWidth + eY * (me.controlBottom - me.controlTop);
373                                 if (me.pressed == 1) draw_VertButtonPicture(o, strcat(me.src, "_c"), s, me.colorC, 1);
374                                 else if (me.focused) draw_VertButtonPicture(o, strcat(me.src, "_f"), s, me.colorF, 1);
375                                 else draw_VertButtonPicture(o, strcat(me.src, "_n"), s, me.color, 1);
376                         }
377                 }
378                 draw_SetClip();
379                 oldshift = draw_shift;
380                 oldscale = draw_scale;
381
382                 i = me.getItemAtPos(me, me.scrollPos);
383                 float j = me.getItemStart(me, i) - me.scrollPos;
384                 for ( ; i < me.nItems && j < 1; ++i)
385                 {
386                         draw_shift = boxToGlobal(eY * j, oldshift, oldscale);
387                         vector relSize = eX * (1 - me.controlWidth) + eY * me.getItemHeight(me, i);
388                         absSize = boxToGlobalSize(relSize, me.size);
389                         draw_scale = boxToGlobalSize(relSize, oldscale);
390                         me.drawListBoxItem(me, i, absSize, (me.selectedItem == i), (me.focusedItem == i));
391                         j += relSize.y;
392                 }
393                 draw_ClearClip();
394
395                 draw_shift = oldshift;
396                 draw_scale = oldscale;
397                 SUPER(ListBox).draw(me);
398         }
399
400         void ListBox_focusedItemChangeNotify(entity me)
401         {}
402
403         void ListBox_clickListBoxItem(entity me, float i, vector where)
404         {
405                 // template method
406         }
407
408         void ListBox_doubleClickListBoxItem(entity me, float i, vector where)
409         {
410                 // template method
411         }
412
413         void ListBox_drawListBoxItem(entity me, int i, vector absSize, bool isSelected, bool isFocused)
414         {
415                 draw_Text('0 0 0', sprintf(_("Item %d"), i), eX * (8 / absSize.x) + eY * (8 / absSize.y), (isSelected ? '0 1 0' : '1 1 1'), 1, 0);
416         }