qcsrc/menu/item/listbox.qc

   1 #ifndef ITEM_LISTBOX_H
   2 #define ITEM_LISTBOX_H
   3 #include "../item.qc"
   4 CLASS(ListBox, Item)
   5         METHOD(ListBox, resizeNotify, void(entity, vector, vector, vector, vector))
   6         METHOD(ListBox, configureListBox, void(entity, float, float))
   7         METHOD(ListBox, draw, void(entity))
   8         METHOD(ListBox, keyDown, float(entity, float, float, float))
   9         METHOD(ListBox, mouseMove, float(entity, vector))
  10         METHOD(ListBox, mousePress, float(entity, vector))
  11         METHOD(ListBox, mouseDrag, float(entity, vector))
  12         METHOD(ListBox, mouseRelease, float(entity, vector))
  13         METHOD(ListBox, focusLeave, void(entity))
  14         ATTRIB(ListBox, focusable, float, 1)
  15         ATTRIB(ListBox, focusedItem, int, -1)
  16         ATTRIB(ListBox, focusedItemAlpha, float, 0.3)
  17         ATTRIB(ListBox, mouseMoveOffset, float, -1) // let know where the cursor is when the list scrolls without moving the cursor
  18         ATTRIB(ListBox, allowFocusSound, float, 1)
  19         ATTRIB(ListBox, selectedItem, int, 0)
  20         ATTRIB(ListBox, size, vector, '0 0 0')
  21         ATTRIB(ListBox, origin, vector, '0 0 0')
  22         ATTRIB(ListBox, scrollPos, float, 0) // measured in window heights, fixed when needed
  23         ATTRIB(ListBox, scrollPosTarget, float, 0)
  24         ATTRIB(ListBox, needScrollToItem, float, -1)
  25         METHOD(ListBox, scrollToItem, void(entity, int))
  26         ATTRIB(ListBox, previousValue, float, 0)
  27         ATTRIB(ListBox, pressed, float, 0) // 0 = normal, 1 = scrollbar dragging, 2 = item dragging, 3 = released
  28         ATTRIB(ListBox, pressOffset, float, 0)
  29
  30         METHOD(ListBox, updateControlTopBottom, void(entity))
  31         ATTRIB(ListBox, controlTop, float, 0)
  32         ATTRIB(ListBox, controlBottom, float, 0)
  33         ATTRIB(ListBox, controlWidth, float, 0)
  34         ATTRIB(ListBox, dragScrollPos, vector, '0 0 0')
  35         ATTRIB(ListBox, selectionDoesntMatter, bool, false) // improves scrolling by keys for lists that don't need to show an active selection
  36
  37         ATTRIB(ListBox, src, string, string_null) // scrollbar
  38         ATTRIB(ListBox, color, vector, '1 1 1')
  39         ATTRIB(ListBox, color2, vector, '1 1 1')
  40         ATTRIB(ListBox, colorC, vector, '1 1 1')
  41         ATTRIB(ListBox, colorF, vector, '1 1 1')
  42         ATTRIB(ListBox, tolerance, vector, '0 0 0') // drag tolerance
  43         ATTRIB(ListBox, scrollbarWidth, float, 0) // pixels
  44         ATTRIB(ListBox, nItems, float, 42)
  45         ATTRIB(ListBox, itemHeight, float, 0)
  46         ATTRIB(ListBox, colorBG, vector, '0 0 0')
  47         ATTRIB(ListBox, alphaBG, float, 0)
  48
  49         ATTRIB(ListBox, lastClickedItem, float, -1)
  50         ATTRIB(ListBox, lastClickedTime, float, 0)
  51
  52         METHOD(ListBox, drawListBoxItem, void(entity, int, vector, bool, bool)) // item number, width/height, isSelected, isFocused
  53         METHOD(ListBox, clickListBoxItem, void(entity, float, vector)) // item number, relative clickpos
  54         METHOD(ListBox, doubleClickListBoxItem, void(entity, float, vector)) // item number, relative clickpos
  55         METHOD(ListBox, setSelected, void(entity, float))
  56
  57         METHOD(ListBox, getLastFullyVisibleItemAtScrollPos, float(entity, float))
  58         METHOD(ListBox, getFirstFullyVisibleItemAtScrollPos, float(entity, float))
  59
  60         // NOTE: override these four methods if you want variable sized list items
  61         METHOD(ListBox, getTotalHeight, float(entity))
  62         METHOD(ListBox, getItemAtPos, float(entity, float))
  63         METHOD(ListBox, getItemStart, float(entity, float))
  64         METHOD(ListBox, getItemHeight, float(entity, float))
  65         // NOTE: if getItemAt* are overridden, it may make sense to cache the
  66         // start and height of the last item returned by getItemAtPos and fast
  67         // track returning their properties for getItemStart and getItemHeight.
  68         // The "hot" code path calls getItemAtPos first, then will query
  69         // getItemStart and getItemHeight on it soon.
  70         // When overriding, the following consistency rules must hold:
  71         // getTotalHeight() == SUM(getItemHeight(i), i, 0, me.nItems-1)
  72         // getItemStart(i+1) == getItemStart(i) + getItemHeight(i)
  73         //   for 0 <= i < me.nItems-1
  74         // getItemStart(0) == 0
  75         // getItemStart(getItemAtPos(p)) <= p
  76         //   if p >= 0
  77         // getItemAtPos(p) == 0
  78         //   if p < 0
  79         // getItemStart(getItemAtPos(p)) + getItemHeight(getItemAtPos(p)) > p
  80         //   if p < getTotalHeigt()
  81         // getItemAtPos(p) == me.nItems - 1
  82         //   if p >= getTotalHeight()
  83 ENDCLASS(ListBox)
  84 #endif
  85
  86 #ifdef IMPLEMENTATION
  87 void ListBox_scrollToItem(entity me, int i)
  88 {
  89         // scroll doesn't work properly until itemHeight is set to the correct value
  90         // at the first resizeNotify call
  91         if(me.itemHeight == 1) // initial temporary value of itemHeight is 1
  92         {
  93                 me.needScrollToItem = i;
  94                 return;
  95         }
  96
  97         i = bound(0, i, me.nItems - 1);
  98
  99         // scroll the list to make sure the selected item is visible
 100         // (even if the selected item doesn't change).
 101         if(i < me.getFirstFullyVisibleItemAtScrollPos(me, me.scrollPos))
 102         {
 103                 // above visible area
 104                 me.scrollPosTarget = me.getItemStart(me, i);
 105         }
 106         else if(i > me.getLastFullyVisibleItemAtScrollPos(me, me.scrollPos))
 107         {
 108                 // below visible area
 109                 if(i == me.nItems - 1)
 110                         me.scrollPosTarget = me.getTotalHeight(me) - 1;
 111                 else
 112                         me.scrollPosTarget = me.getItemStart(me, i + 1) - 1;
 113         }
 114 }
 115
 116 void ListBox_setSelected(entity me, float i)
 117 {
 118         i = bound(0, i, me.nItems - 1);
 119         me.scrollToItem(me, i);
 120         me.selectedItem = i;
 121 }
 122 void ListBox_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
 123 {
 124         SUPER(ListBox).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
 125         me.controlWidth = me.scrollbarWidth / absSize.x;
 126 }
 127 void ListBox_configureListBox(entity me, float theScrollbarWidth, float theItemHeight)
 128 {
 129         me.scrollbarWidth = theScrollbarWidth;
 130         me.itemHeight = theItemHeight;
 131 }
 132
 133 float ListBox_getTotalHeight(entity me)
 134 {
 135         return me.nItems * me.itemHeight;
 136 }
 137 float ListBox_getItemAtPos(entity me, float pos)
 138 {
 139         return floor(pos / me.itemHeight);
 140 }
 141 float ListBox_getItemStart(entity me, float i)
 142 {
 143         return me.itemHeight * i;
 144 }
 145 float ListBox_getItemHeight(entity me, float i)
 146 {
 147         return me.itemHeight;
 148 }
 149
 150 float ListBox_getLastFullyVisibleItemAtScrollPos(entity me, float pos)
 151 {
 152         return me.getItemAtPos(me, pos + 0.999) - 1;
 153 }
 154 float ListBox_getFirstFullyVisibleItemAtScrollPos(entity me, float pos)
 155 {
 156         return me.getItemAtPos(me, pos + 0.001) + 1;
 157 }
 158 float ListBox_keyDown(entity me, float key, float ascii, float shift)
 159 {
 160         if(key == K_MWHEELUP)
 161         {
 162                 me.scrollPosTarget = max(me.scrollPosTarget - 0.5, 0);
 163         }
 164         else if(key == K_MWHEELDOWN)
 165         {
 166                 me.scrollPosTarget = min(me.scrollPosTarget + 0.5, me.getTotalHeight(me) - 1);
 167         }
 168         else if(key == K_PGUP || key == K_KP_PGUP)
 169         {
 170                 if(me.selectionDoesntMatter)
 171                 {
 172                         me.scrollPosTarget = max(me.scrollPosTarget - 0.5, 0);
 173                         return 1;
 174                 }
 175
 176                 float i = me.selectedItem;
 177                 float a = me.getItemHeight(me, i);
 178                 for (;;)
 179                 {
 180                         --i;
 181                         if (i < 0)
 182                                 break;
 183                         a += me.getItemHeight(me, i);
 184                         if (a >= 1)
 185                                 break;
 186                 }
 187                 me.setSelected(me, i + 1);
 188         }
 189         else if(key == K_PGDN || key == K_KP_PGDN)
 190         {
 191                 if(me.selectionDoesntMatter)
 192                 {
 193                         me.scrollPosTarget = min(me.scrollPosTarget + 0.5, me.nItems * me.itemHeight - 1);
 194                         return 1;
 195                 }
 196
 197                 float i = me.selectedItem;
 198                 float a = me.getItemHeight(me, i);
 199                 for (;;)
 200                 {
 201                         ++i;
 202                         if (i >= me.nItems)
 203                                 break;
 204                         a += me.getItemHeight(me, i);
 205                         if (a >= 1)
 206                                 break;
 207                 }
 208                 me.setSelected(me, i - 1);
 209         }
 210         else if(key == K_UPARROW || key == K_KP_UPARROW)
 211         {
 212                 if(me.selectionDoesntMatter)
 213                 {
 214                         me.scrollPosTarget = max(me.scrollPosTarget - me.itemHeight, 0);
 215                         return 1;
 216                 }
 217
 218                 me.setSelected(me, me.selectedItem - 1);
 219         }
 220         else if(key == K_DOWNARROW || key == K_KP_DOWNARROW)
 221         {
 222                 if(me.selectionDoesntMatter)
 223                 {
 224                         me.scrollPosTarget = min(me.scrollPosTarget + me.itemHeight, me.nItems * me.itemHeight - 1);
 225                         return 1;
 226                 }
 227
 228                 me.setSelected(me, me.selectedItem + 1);
 229         }
 230         else if(key == K_HOME || key == K_KP_HOME)
 231                 me.setSelected(me, 0);
 232         else if(key == K_END || key == K_KP_END)
 233                 me.setSelected(me, me.nItems - 1);
 234         else
 235                 return 0;
 236         return 1;
 237 }
 238 float ListBox_mouseMove(entity me, vector pos)
 239 {
 240         me.mouseMoveOffset = -1;
 241         if(pos_x < 0) return 0;
 242         if(pos_y < 0) return 0;
 243         if(pos_x >= 1) return 0;
 244         if(pos_y >= 1) return 0;
 245         if(pos_x < 1 - me.controlWidth)
 246                 me.mouseMoveOffset = pos.y;
 247         else
 248         {
 249                 me.focusedItem = -1;
 250                 me.mouseMoveOffset = -1;
 251         }
 252         return 1;
 253 }
 254 float ListBox_mouseDrag(entity me, vector pos)
 255 {
 256         float hit;
 257         me.updateControlTopBottom(me);
 258         me.dragScrollPos = pos;
 259         if(me.pressed == 1)
 260         {
 261                 hit = 1;
 262                 if(pos.x < 1 - me.controlWidth - me.tolerance.y * me.controlWidth) hit = 0;
 263                 if(pos.y < 0 - me.tolerance.x) hit = 0;
 264                 if(pos.x >= 1 + me.tolerance.y * me.controlWidth) hit = 0;
 265                 if(pos.y >= 1 + me.tolerance.x) hit = 0;
 266                 if(hit)
 267                 {
 268                         // calculate new pos to v
 269                         float d;
 270                         d = (pos.y - me.pressOffset) / (1 - (me.controlBottom - me.controlTop)) * (me.getTotalHeight(me) - 1);
 271                         me.scrollPosTarget = me.previousValue + d;
 272                 }
 273                 else
 274                         me.scrollPosTarget = me.previousValue;
 275                 me.scrollPosTarget = min(me.scrollPosTarget, me.getTotalHeight(me) - 1);
 276                 me.scrollPosTarget = max(me.scrollPosTarget, 0);
 277         }
 278         else if(me.pressed == 2)
 279         {
 280                 me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
 281                 me.focusedItem = me.selectedItem;
 282                 me.mouseMoveOffset = -1;
 283         }
 284         return 1;
 285 }
 286 float ListBox_mousePress(entity me, vector pos)
 287 {
 288         if(pos.x < 0) return 0;
 289         if(pos.y < 0) return 0;
 290         if(pos.x >= 1) return 0;
 291         if(pos.y >= 1) return 0;
 292         me.dragScrollPos = pos;
 293         me.updateControlTopBottom(me);
 294         if(pos.x >= 1 - me.controlWidth)
 295         {
 296                 // if hit, set me.pressed, otherwise scroll by one page
 297                 if(pos.y < me.controlTop)
 298                 {
 299                         // page up
 300                         me.scrollPosTarget = max(me.scrollPosTarget - 1, 0);
 301                 }
 302                 else if(pos.y > me.controlBottom)
 303                 {
 304                         // page down
 305                         me.scrollPosTarget = min(me.scrollPosTarget + 1, me.getTotalHeight(me) - 1);
 306                 }
 307                 else
 308                 {
 309                         me.pressed = 1;
 310                         me.pressOffset = pos.y;
 311                         me.previousValue = me.scrollPos;
 312                 }
 313         }
 314         else
 315         {
 316                 // continue doing that while dragging (even when dragging outside). When releasing, forward the click to the then selected item.
 317                 me.pressed = 2;
 318                 // an item has been clicked. Select it, ...
 319                 me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
 320                 me.focusedItem = me.selectedItem;
 321         }
 322         return 1;
 323 }
 324 float ListBox_mouseRelease(entity me, vector pos)
 325 {
 326         if(me.pressed == 1)
 327         {
 328                 // slider dragging mode
 329                 // in that case, nothing happens on releasing
 330         }
 331         else if(me.pressed == 2)
 332         {
 333                 me.pressed = 3; // do that here, so setSelected can know the mouse has been released
 334                 // item dragging mode
 335                 // select current one one last time...
 336                 me.setSelected(me, me.getItemAtPos(me, me.scrollPos + pos.y));
 337                 me.focusedItem = me.selectedItem;
 338                 // and give it a nice click event
 339                 if(me.nItems > 0)
 340                 {
 341                         vector where = globalToBox(pos, eY * (me.getItemStart(me, me.selectedItem) - me.scrollPos), eX * (1 - me.controlWidth) + eY * me.getItemHeight(me, me.selectedItem));
 342
 343                         if((me.selectedItem == me.lastClickedItem) && (time < me.lastClickedTime + 0.3))
 344                                 me.doubleClickListBoxItem(me, me.selectedItem, where);
 345                         else
 346                                 me.clickListBoxItem(me, me.selectedItem, where);
 347
 348                         me.lastClickedItem = me.selectedItem;
 349                         me.lastClickedTime = time;
 350                 }
 351         }
 352         me.pressed = 0;
 353         return 1;
 354 }
 355 void ListBox_focusLeave(entity me)
 356 {
 357         // Reset the var pressed in case listbox loses focus
 358         // by a mouse click on an item of the list
 359         // for example showing a dialog on right click
 360         me.pressed = 0;
 361         me.focusedItem = -1;
 362         me.mouseMoveOffset = -1;
 363 }
 364 void ListBox_updateControlTopBottom(entity me)
 365 {
 366         float f;
 367         // scrollPos is in 0..1 and indicates where the "page" currently shown starts.
 368         if(me.getTotalHeight(me) <= 1)
 369         {
 370                 // we don't need no stinkin' scrollbar, we don't need no view control...
 371                 me.controlTop = 0;
 372                 me.controlBottom = 1;
 373                 me.scrollPos = 0;
 374         }
 375         else
 376         {
 377                 // if scroll pos is below end of list, fix it
 378                 me.scrollPos = min(me.scrollPos, me.getTotalHeight(me) - 1);
 379                 // if scroll pos is above beginning of list, fix it
 380                 me.scrollPos = max(me.scrollPos, 0);
 381                 // now that we know where the list is scrolled to, find out where to draw the control
 382                 me.controlTop = max(0, me.scrollPos / me.getTotalHeight(me));
 383                 me.controlBottom = min((me.scrollPos + 1) / me.getTotalHeight(me), 1);
 384
 385                 float minfactor;
 386                 minfactor = 2 * me.controlWidth / me.size.y * me.size.x;
 387                 f = me.controlBottom - me.controlTop;
 388                 if(f < minfactor) // FIXME good default?
 389                 {
 390                         // f * X + 1 * (1-X) = minfactor
 391                         // (f - 1) * X + 1 = minfactor
 392                         // (f - 1) * X = minfactor - 1
 393                         // X = (minfactor - 1) / (f - 1)
 394                         f = (minfactor - 1) / (f - 1);
 395                         me.controlTop = me.controlTop * f + 0 * (1 - f);
 396                         me.controlBottom = me.controlBottom * f + 1 * (1 - f);
 397                 }
 398         }
 399 }
 400 void ListBox_draw(entity me)
 401 {
 402         float i;
 403         vector absSize, fillSize = '0 0 0';
 404         vector oldshift, oldscale;
 405
 406         // we can't do this in mouseMove as the list can scroll without moving the cursor
 407         float focusedItem_save = me.focusedItem;
 408         if(me.mouseMoveOffset != -1)
 409                 me.focusedItem = me.getItemAtPos(me, me.scrollPos + me.mouseMoveOffset);
 410         if(me.focusedItem >= 0)
 411         if(focusedItem_save != me.focusedItem)
 412                 me.focusedItemAlpha = SKINALPHA_LISTBOX_FOCUSED;
 413
 414         if(me.needScrollToItem >= 0)
 415         {
 416                 me.scrollToItem(me, me.needScrollToItem);
 417                 me.needScrollToItem = -1;
 418         }
 419         if(me.scrollPos != me.scrollPosTarget)
 420         {
 421                 float averaging_time = 0.16;
 422                 if(me.pressed == 1)
 423                         averaging_time = 0.06; // scroll faster while dragging the scrollbar
 424                 // this formula works with whatever framerate
 425                 float f = exp(-frametime / averaging_time);
 426                 me.scrollPos = me.scrollPos * f + me.scrollPosTarget * (1 - f);
 427                 if(fabs(me.scrollPos - me.scrollPosTarget) < 0.001)
 428                         me.scrollPos = me.scrollPosTarget;
 429         }
 430
 431         if(me.pressed == 2)
 432                 me.mouseDrag(me, me.dragScrollPos); // simulate mouseDrag event
 433         me.updateControlTopBottom(me);
 434         fillSize.x = (1 - me.controlWidth);
 435         if(me.alphaBG)
 436                 draw_Fill('0 0 0', '0 1 0' + fillSize, me.colorBG, me.alphaBG);
 437         if(me.controlWidth)
 438         {
 439                 draw_VertButtonPicture(eX * (1 - me.controlWidth), strcat(me.src, "_s"), eX * me.controlWidth + eY, me.color2, 1);
 440                 if(me.getTotalHeight(me) > 1)
 441                 {
 442                         vector o, s;
 443                         o = eX * (1 - me.controlWidth) + eY * me.controlTop;
 444                         s = eX * me.controlWidth + eY * (me.controlBottom - me.controlTop);
 445                         if(me.pressed == 1)
 446                                 draw_VertButtonPicture(o, strcat(me.src, "_c"), s, me.colorC, 1);
 447                         else if(me.focused)
 448                                 draw_VertButtonPicture(o, strcat(me.src, "_f"), s, me.colorF, 1);
 449                         else
 450                                 draw_VertButtonPicture(o, strcat(me.src, "_n"), s, me.color, 1);
 451                 }
 452         }
 453         draw_SetClip();
 454         oldshift = draw_shift;
 455         oldscale = draw_scale;
 456
 457         float y;
 458         i = me.getItemAtPos(me, me.scrollPos);
 459         y = me.getItemStart(me, i) - me.scrollPos;
 460         for (; i < me.nItems && y < 1; ++i)
 461         {
 462                 draw_shift = boxToGlobal(eY * y, oldshift, oldscale);
 463                 vector relSize = eX * (1 - me.controlWidth) + eY * me.getItemHeight(me, i);
 464                 absSize = boxToGlobalSize(relSize, me.size);
 465                 draw_scale = boxToGlobalSize(relSize, oldscale);
 466                 me.drawListBoxItem(me, i, absSize, (me.selectedItem == i), (me.focusedItem == i));
 467                 y += relSize.y;
 468         }
 469         draw_ClearClip();
 470
 471         draw_shift = oldshift;
 472         draw_scale = oldscale;
 473         SUPER(ListBox).draw(me);
 474 }
 475
 476 void ListBox_clickListBoxItem(entity me, float i, vector where)
 477 {
 478         // template method
 479 }
 480
 481 void ListBox_doubleClickListBoxItem(entity me, float i, vector where)
 482 {
 483         // template method
 484 }
 485
 486 void ListBox_drawListBoxItem(entity me, int i, vector absSize, bool isSelected, bool isFocused)
 487 {
 488         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);
 489 }
 490 #endif