juce/source/src/gui/components/controls/juce_TableHeaderComponent.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_TableHeaderComponent.h"
  31 #include "../../graphics/imaging/juce_Image.h"
  32 #include "../../../text/juce_XmlDocument.h"
  33 #include "../lookandfeel/juce_LookAndFeel.h"
  34 #include "../layout/juce_StretchableObjectResizer.h"
  35
  36
  37 //==============================================================================
  38 class DragOverlayComp   : public Component
  39 {
  40 public:
  41     DragOverlayComp (const Image& image_)
  42         : image (image_)
  43     {
  44         image.duplicateIfShared();
  45         image.multiplyAllAlphas (0.8f);
  46         setAlwaysOnTop (true);
  47     }
  48
  49     void paint (Graphics& g)
  50     {
  51         g.drawImageAt (image, 0, 0);
  52     }
  53
  54 private:
  55     Image image;
  56
  57     JUCE_DECLARE_NON_COPYABLE (DragOverlayComp);
  58 };
  59
  60
  61 //==============================================================================
  62 TableHeaderComponent::TableHeaderComponent()
  63     : columnsChanged (false),
  64       columnsResized (false),
  65       sortChanged (false),
  66       menuActive (true),
  67       stretchToFit (false),
  68       columnIdBeingResized (0),
  69       columnIdBeingDragged (0),
  70       columnIdUnderMouse (0),
  71       lastDeliberateWidth (0)
  72 {
  73 }
  74
  75 TableHeaderComponent::~TableHeaderComponent()
  76 {
  77     dragOverlayComp = nullptr;
  78 }
  79
  80 //==============================================================================
  81 void TableHeaderComponent::setPopupMenuActive (const bool hasMenu)
  82 {
  83     menuActive = hasMenu;
  84 }
  85
  86 bool TableHeaderComponent::isPopupMenuActive() const                    { return menuActive; }
  87
  88
  89 //==============================================================================
  90 int TableHeaderComponent::getNumColumns (const bool onlyCountVisibleColumns) const
  91 {
  92     if (onlyCountVisibleColumns)
  93     {
  94         int num = 0;
  95
  96         for (int i = columns.size(); --i >= 0;)
  97             if (columns.getUnchecked(i)->isVisible())
  98                 ++num;
  99
 100         return num;
 101     }
 102     else
 103     {
 104         return columns.size();
 105     }
 106 }
 107
 108 String TableHeaderComponent::getColumnName (const int columnId) const
 109 {
 110     const ColumnInfo* const ci = getInfoForId (columnId);
 111     return ci != nullptr ? ci->name : String::empty;
 112 }
 113
 114 void TableHeaderComponent::setColumnName (const int columnId, const String& newName)
 115 {
 116     ColumnInfo* const ci = getInfoForId (columnId);
 117
 118     if (ci != nullptr && ci->name != newName)
 119     {
 120         ci->name = newName;
 121         sendColumnsChanged();
 122     }
 123 }
 124
 125 void TableHeaderComponent::addColumn (const String& columnName,
 126                                       const int columnId,
 127                                       const int width,
 128                                       const int minimumWidth,
 129                                       const int maximumWidth,
 130                                       const int propertyFlags,
 131                                       const int insertIndex)
 132 {
 133     // can't have a duplicate or null ID!
 134     jassert (columnId != 0 && getIndexOfColumnId (columnId, false) < 0);
 135     jassert (width > 0);
 136
 137     ColumnInfo* const ci = new ColumnInfo();
 138     ci->name = columnName;
 139     ci->id = columnId;
 140     ci->width = width;
 141     ci->lastDeliberateWidth = width;
 142     ci->minimumWidth = minimumWidth;
 143     ci->maximumWidth = maximumWidth;
 144     if (ci->maximumWidth < 0)
 145         ci->maximumWidth = std::numeric_limits<int>::max();
 146     jassert (ci->maximumWidth >= ci->minimumWidth);
 147     ci->propertyFlags = propertyFlags;
 148
 149     columns.insert (insertIndex, ci);
 150     sendColumnsChanged();
 151 }
 152
 153 void TableHeaderComponent::removeColumn (const int columnIdToRemove)
 154 {
 155     const int index = getIndexOfColumnId (columnIdToRemove, false);
 156
 157     if (index >= 0)
 158     {
 159         columns.remove (index);
 160         sortChanged = true;
 161         sendColumnsChanged();
 162     }
 163 }
 164
 165 void TableHeaderComponent::removeAllColumns()
 166 {
 167     if (columns.size() > 0)
 168     {
 169         columns.clear();
 170         sendColumnsChanged();
 171     }
 172 }
 173
 174 void TableHeaderComponent::moveColumn (const int columnId, int newIndex)
 175 {
 176     const int currentIndex = getIndexOfColumnId (columnId, false);
 177     newIndex = visibleIndexToTotalIndex (newIndex);
 178
 179     if (columns [currentIndex] != 0 && currentIndex != newIndex)
 180     {
 181         columns.move (currentIndex, newIndex);
 182         sendColumnsChanged();
 183     }
 184 }
 185
 186 int TableHeaderComponent::getColumnWidth (const int columnId) const
 187 {
 188     const ColumnInfo* const ci = getInfoForId (columnId);
 189     return ci != nullptr ? ci->width : 0;
 190 }
 191
 192 void TableHeaderComponent::setColumnWidth (const int columnId, const int newWidth)
 193 {
 194     ColumnInfo* const ci = getInfoForId (columnId);
 195
 196     if (ci != nullptr && ci->width != newWidth)
 197     {
 198         const int numColumns = getNumColumns (true);
 199
 200         ci->lastDeliberateWidth = ci->width
 201             = jlimit (ci->minimumWidth, ci->maximumWidth, newWidth);
 202
 203         if (stretchToFit)
 204         {
 205             const int index = getIndexOfColumnId (columnId, true) + 1;
 206
 207             if (isPositiveAndBelow (index, numColumns))
 208             {
 209                 const int x = getColumnPosition (index).getX();
 210
 211                 if (lastDeliberateWidth == 0)
 212                     lastDeliberateWidth = getTotalWidth();
 213
 214                 resizeColumnsToFit (visibleIndexToTotalIndex (index), lastDeliberateWidth - x);
 215             }
 216         }
 217
 218         repaint();
 219         columnsResized = true;
 220         triggerAsyncUpdate();
 221     }
 222 }
 223
 224 //==============================================================================
 225 int TableHeaderComponent::getIndexOfColumnId (const int columnId, const bool onlyCountVisibleColumns) const
 226 {
 227     int n = 0;
 228
 229     for (int i = 0; i < columns.size(); ++i)
 230     {
 231         if ((! onlyCountVisibleColumns) || columns.getUnchecked(i)->isVisible())
 232         {
 233             if (columns.getUnchecked(i)->id == columnId)
 234                 return n;
 235
 236             ++n;
 237         }
 238     }
 239
 240     return -1;
 241 }
 242
 243 int TableHeaderComponent::getColumnIdOfIndex (int index, const bool onlyCountVisibleColumns) const
 244 {
 245     if (onlyCountVisibleColumns)
 246         index = visibleIndexToTotalIndex (index);
 247
 248     const ColumnInfo* const ci = columns [index];
 249     return (ci != nullptr) ? ci->id : 0;
 250 }
 251
 252 const Rectangle<int> TableHeaderComponent::getColumnPosition (const int index) const
 253 {
 254     int x = 0, width = 0, n = 0;
 255
 256     for (int i = 0; i < columns.size(); ++i)
 257     {
 258         x += width;
 259
 260         if (columns.getUnchecked(i)->isVisible())
 261         {
 262             width = columns.getUnchecked(i)->width;
 263
 264             if (n++ == index)
 265                 break;
 266         }
 267         else
 268         {
 269             width = 0;
 270         }
 271     }
 272
 273     return Rectangle<int> (x, 0, width, getHeight());
 274 }
 275
 276 int TableHeaderComponent::getColumnIdAtX (const int xToFind) const
 277 {
 278     if (xToFind >= 0)
 279     {
 280         int x = 0;
 281
 282         for (int i = 0; i < columns.size(); ++i)
 283         {
 284             const ColumnInfo* const ci = columns.getUnchecked(i);
 285
 286             if (ci->isVisible())
 287             {
 288                 x += ci->width;
 289
 290                 if (xToFind < x)
 291                     return ci->id;
 292             }
 293         }
 294     }
 295
 296     return 0;
 297 }
 298
 299 int TableHeaderComponent::getTotalWidth() const
 300 {
 301     int w = 0;
 302
 303     for (int i = columns.size(); --i >= 0;)
 304         if (columns.getUnchecked(i)->isVisible())
 305             w += columns.getUnchecked(i)->width;
 306
 307     return w;
 308 }
 309
 310 void TableHeaderComponent::setStretchToFitActive (const bool shouldStretchToFit)
 311 {
 312     stretchToFit = shouldStretchToFit;
 313     lastDeliberateWidth = getTotalWidth();
 314     resized();
 315 }
 316
 317 bool TableHeaderComponent::isStretchToFitActive() const
 318 {
 319     return stretchToFit;
 320 }
 321
 322 void TableHeaderComponent::resizeAllColumnsToFit (int targetTotalWidth)
 323 {
 324     if (stretchToFit && getWidth() > 0
 325          && columnIdBeingResized == 0 && columnIdBeingDragged == 0)
 326     {
 327         lastDeliberateWidth = targetTotalWidth;
 328         resizeColumnsToFit (0, targetTotalWidth);
 329     }
 330 }
 331
 332 void TableHeaderComponent::resizeColumnsToFit (int firstColumnIndex, int targetTotalWidth)
 333 {
 334     targetTotalWidth = jmax (targetTotalWidth, 0);
 335
 336     StretchableObjectResizer sor;
 337     int i;
 338     for (i = firstColumnIndex; i < columns.size(); ++i)
 339     {
 340         ColumnInfo* const ci = columns.getUnchecked(i);
 341
 342         if (ci->isVisible())
 343             sor.addItem (ci->lastDeliberateWidth, ci->minimumWidth, ci->maximumWidth);
 344     }
 345
 346     sor.resizeToFit (targetTotalWidth);
 347
 348     int visIndex = 0;
 349     for (i = firstColumnIndex; i < columns.size(); ++i)
 350     {
 351         ColumnInfo* const ci = columns.getUnchecked(i);
 352
 353         if (ci->isVisible())
 354         {
 355             const int newWidth = jlimit (ci->minimumWidth, ci->maximumWidth,
 356                                          (int) std::floor (sor.getItemSize (visIndex++)));
 357
 358             if (newWidth != ci->width)
 359             {
 360                 ci->width = newWidth;
 361                 repaint();
 362                 columnsResized = true;
 363                 triggerAsyncUpdate();
 364             }
 365         }
 366     }
 367 }
 368
 369 void TableHeaderComponent::setColumnVisible (const int columnId, const bool shouldBeVisible)
 370 {
 371     ColumnInfo* const ci = getInfoForId (columnId);
 372
 373     if (ci != nullptr && shouldBeVisible != ci->isVisible())
 374     {
 375         if (shouldBeVisible)
 376             ci->propertyFlags |= visible;
 377         else
 378             ci->propertyFlags &= ~visible;
 379
 380         sendColumnsChanged();
 381         resized();
 382     }
 383 }
 384
 385 bool TableHeaderComponent::isColumnVisible (const int columnId) const
 386 {
 387     const ColumnInfo* const ci = getInfoForId (columnId);
 388     return ci != nullptr && ci->isVisible();
 389 }
 390
 391 //==============================================================================
 392 void TableHeaderComponent::setSortColumnId (const int columnId, const bool sortForwards)
 393 {
 394     if (getSortColumnId() != columnId || isSortedForwards() != sortForwards)
 395     {
 396         for (int i = columns.size(); --i >= 0;)
 397             columns.getUnchecked(i)->propertyFlags &= ~(sortedForwards | sortedBackwards);
 398
 399         ColumnInfo* const ci = getInfoForId (columnId);
 400
 401         if (ci != nullptr)
 402             ci->propertyFlags |= (sortForwards ? sortedForwards : sortedBackwards);
 403
 404         reSortTable();
 405     }
 406 }
 407
 408 int TableHeaderComponent::getSortColumnId() const
 409 {
 410     for (int i = columns.size(); --i >= 0;)
 411         if ((columns.getUnchecked(i)->propertyFlags & (sortedForwards | sortedBackwards)) != 0)
 412             return columns.getUnchecked(i)->id;
 413
 414     return 0;
 415 }
 416
 417 bool TableHeaderComponent::isSortedForwards() const
 418 {
 419     for (int i = columns.size(); --i >= 0;)
 420         if ((columns.getUnchecked(i)->propertyFlags & (sortedForwards | sortedBackwards)) != 0)
 421             return (columns.getUnchecked(i)->propertyFlags & sortedForwards) != 0;
 422
 423     return true;
 424 }
 425
 426 void TableHeaderComponent::reSortTable()
 427 {
 428     sortChanged = true;
 429     repaint();
 430     triggerAsyncUpdate();
 431 }
 432
 433 //==============================================================================
 434 String TableHeaderComponent::toString() const
 435 {
 436     String s;
 437
 438     XmlElement doc ("TABLELAYOUT");
 439
 440     doc.setAttribute ("sortedCol", getSortColumnId());
 441     doc.setAttribute ("sortForwards", isSortedForwards());
 442
 443     for (int i = 0; i < columns.size(); ++i)
 444     {
 445         const ColumnInfo* const ci = columns.getUnchecked (i);
 446
 447         XmlElement* const e = doc.createNewChildElement ("COLUMN");
 448         e->setAttribute ("id", ci->id);
 449         e->setAttribute ("visible", ci->isVisible());
 450         e->setAttribute ("width", ci->width);
 451     }
 452
 453     return doc.createDocument (String::empty, true, false);
 454 }
 455
 456 void TableHeaderComponent::restoreFromString (const String& storedVersion)
 457 {
 458     ScopedPointer <XmlElement> storedXml (XmlDocument::parse (storedVersion));
 459     int index = 0;
 460
 461     if (storedXml != nullptr && storedXml->hasTagName ("TABLELAYOUT"))
 462     {
 463         forEachXmlChildElement (*storedXml, col)
 464         {
 465             const int tabId = col->getIntAttribute ("id");
 466
 467             ColumnInfo* const ci = getInfoForId (tabId);
 468
 469             if (ci != nullptr)
 470             {
 471                 columns.move (columns.indexOf (ci), index);
 472                 ci->width = col->getIntAttribute ("width");
 473                 setColumnVisible (tabId, col->getBoolAttribute ("visible"));
 474             }
 475
 476             ++index;
 477         }
 478
 479         columnsResized = true;
 480         sendColumnsChanged();
 481
 482         setSortColumnId (storedXml->getIntAttribute ("sortedCol"),
 483                          storedXml->getBoolAttribute ("sortForwards", true));
 484     }
 485 }
 486
 487 //==============================================================================
 488 void TableHeaderComponent::addListener (Listener* const newListener)
 489 {
 490     listeners.addIfNotAlreadyThere (newListener);
 491 }
 492
 493 void TableHeaderComponent::removeListener (Listener* const listenerToRemove)
 494 {
 495     listeners.removeValue (listenerToRemove);
 496 }
 497
 498 //==============================================================================
 499 void TableHeaderComponent::columnClicked (int columnId, const ModifierKeys& mods)
 500 {
 501     const ColumnInfo* const ci = getInfoForId (columnId);
 502
 503     if (ci != nullptr && (ci->propertyFlags & sortable) != 0 && ! mods.isPopupMenu())
 504         setSortColumnId (columnId, (ci->propertyFlags & sortedForwards) == 0);
 505 }
 506
 507 void TableHeaderComponent::addMenuItems (PopupMenu& menu, const int /*columnIdClicked*/)
 508 {
 509     for (int i = 0; i < columns.size(); ++i)
 510     {
 511         const ColumnInfo* const ci = columns.getUnchecked(i);
 512
 513         if ((ci->propertyFlags & appearsOnColumnMenu) != 0)
 514             menu.addItem (ci->id, ci->name,
 515                           (ci->propertyFlags & (sortedForwards | sortedBackwards)) == 0,
 516                           isColumnVisible (ci->id));
 517     }
 518 }
 519
 520 void TableHeaderComponent::reactToMenuItem (const int menuReturnId, const int /*columnIdClicked*/)
 521 {
 522     if (getIndexOfColumnId (menuReturnId, false) >= 0)
 523         setColumnVisible (menuReturnId, ! isColumnVisible (menuReturnId));
 524 }
 525
 526 void TableHeaderComponent::paint (Graphics& g)
 527 {
 528     LookAndFeel& lf = getLookAndFeel();
 529
 530     lf.drawTableHeaderBackground (g, *this);
 531
 532     const Rectangle<int> clip (g.getClipBounds());
 533
 534     int x = 0;
 535     for (int i = 0; i < columns.size(); ++i)
 536     {
 537         const ColumnInfo* const ci = columns.getUnchecked(i);
 538
 539         if (ci->isVisible())
 540         {
 541             if (x + ci->width > clip.getX()
 542                  && (ci->id != columnIdBeingDragged
 543                       || dragOverlayComp == nullptr
 544                       || ! dragOverlayComp->isVisible()))
 545             {
 546                 Graphics::ScopedSaveState ss (g);
 547
 548                 g.setOrigin (x, 0);
 549                 g.reduceClipRegion (0, 0, ci->width, getHeight());
 550
 551                 lf.drawTableHeaderColumn (g, ci->name, ci->id, ci->width, getHeight(),
 552                                           ci->id == columnIdUnderMouse,
 553                                           ci->id == columnIdUnderMouse && isMouseButtonDown(),
 554                                           ci->propertyFlags);
 555             }
 556
 557             x += ci->width;
 558
 559             if (x >= clip.getRight())
 560                 break;
 561         }
 562     }
 563 }
 564
 565 void TableHeaderComponent::resized()
 566 {
 567 }
 568
 569 void TableHeaderComponent::mouseMove (const MouseEvent& e)
 570 {
 571     updateColumnUnderMouse (e.x, e.y);
 572 }
 573
 574 void TableHeaderComponent::mouseEnter (const MouseEvent& e)
 575 {
 576     updateColumnUnderMouse (e.x, e.y);
 577 }
 578
 579 void TableHeaderComponent::mouseExit (const MouseEvent& e)
 580 {
 581     updateColumnUnderMouse (e.x, e.y);
 582 }
 583
 584 void TableHeaderComponent::mouseDown (const MouseEvent& e)
 585 {
 586     repaint();
 587     columnIdBeingResized = 0;
 588     columnIdBeingDragged = 0;
 589
 590     if (columnIdUnderMouse != 0)
 591     {
 592         draggingColumnOffset = e.x - getColumnPosition (getIndexOfColumnId (columnIdUnderMouse, true)).getX();
 593
 594         if (e.mods.isPopupMenu())
 595             columnClicked (columnIdUnderMouse, e.mods);
 596     }
 597
 598     if (menuActive && e.mods.isPopupMenu())
 599         showColumnChooserMenu (columnIdUnderMouse);
 600 }
 601
 602 void TableHeaderComponent::mouseDrag (const MouseEvent& e)
 603 {
 604     if (columnIdBeingResized == 0
 605          && columnIdBeingDragged == 0
 606          && ! (e.mouseWasClicked() || e.mods.isPopupMenu()))
 607     {
 608         dragOverlayComp = nullptr;
 609
 610         columnIdBeingResized = getResizeDraggerAt (e.getMouseDownX());
 611
 612         if (columnIdBeingResized != 0)
 613         {
 614             const ColumnInfo* const ci = getInfoForId (columnIdBeingResized);
 615             initialColumnWidth = ci->width;
 616         }
 617         else
 618         {
 619             beginDrag (e);
 620         }
 621     }
 622
 623     if (columnIdBeingResized != 0)
 624     {
 625         const ColumnInfo* const ci = getInfoForId (columnIdBeingResized);
 626
 627         if (ci != nullptr)
 628         {
 629             int w = jlimit (ci->minimumWidth, ci->maximumWidth,
 630                             initialColumnWidth + e.getDistanceFromDragStartX());
 631
 632             if (stretchToFit)
 633             {
 634                 // prevent us dragging a column too far right if we're in stretch-to-fit mode
 635                 int minWidthOnRight = 0;
 636                 for (int i = getIndexOfColumnId (columnIdBeingResized, false) + 1; i < columns.size(); ++i)
 637                     if (columns.getUnchecked (i)->isVisible())
 638                         minWidthOnRight += columns.getUnchecked (i)->minimumWidth;
 639
 640                 const Rectangle<int> currentPos (getColumnPosition (getIndexOfColumnId (columnIdBeingResized, true)));
 641                 w = jmax (ci->minimumWidth, jmin (w, getWidth() - minWidthOnRight - currentPos.getX()));
 642             }
 643
 644             setColumnWidth (columnIdBeingResized, w);
 645         }
 646     }
 647     else if (columnIdBeingDragged != 0)
 648     {
 649         if (e.y >= -50 && e.y < getHeight() + 50)
 650         {
 651             if (dragOverlayComp != nullptr)
 652             {
 653                 dragOverlayComp->setVisible (true);
 654                 dragOverlayComp->setBounds (jlimit (0,
 655                                                     jmax (0, getTotalWidth() - dragOverlayComp->getWidth()),
 656                                                     e.x - draggingColumnOffset),
 657                                             0,
 658                                             dragOverlayComp->getWidth(),
 659                                             getHeight());
 660
 661                 for (int i = columns.size(); --i >= 0;)
 662                 {
 663                     const int currentIndex = getIndexOfColumnId (columnIdBeingDragged, true);
 664                     int newIndex = currentIndex;
 665
 666                     if (newIndex > 0)
 667                     {
 668                         // if the previous column isn't draggable, we can't move our column
 669                         // past it, because that'd change the undraggable column's position..
 670                         const ColumnInfo* const previous = columns.getUnchecked (newIndex - 1);
 671
 672                         if ((previous->propertyFlags & draggable) != 0)
 673                         {
 674                             const int leftOfPrevious = getColumnPosition (newIndex - 1).getX();
 675                             const int rightOfCurrent = getColumnPosition (newIndex).getRight();
 676
 677                             if (abs (dragOverlayComp->getX() - leftOfPrevious)
 678                                 < abs (dragOverlayComp->getRight() - rightOfCurrent))
 679                             {
 680                                 --newIndex;
 681                             }
 682                         }
 683                     }
 684
 685                     if (newIndex < columns.size() - 1)
 686                     {
 687                         // if the next column isn't draggable, we can't move our column
 688                         // past it, because that'd change the undraggable column's position..
 689                         const ColumnInfo* const nextCol = columns.getUnchecked (newIndex + 1);
 690
 691                         if ((nextCol->propertyFlags & draggable) != 0)
 692                         {
 693                             const int leftOfCurrent = getColumnPosition (newIndex).getX();
 694                             const int rightOfNext = getColumnPosition (newIndex + 1).getRight();
 695
 696                             if (abs (dragOverlayComp->getX() - leftOfCurrent)
 697                                 > abs (dragOverlayComp->getRight() - rightOfNext))
 698                             {
 699                                 ++newIndex;
 700                             }
 701                         }
 702                     }
 703
 704                     if (newIndex != currentIndex)
 705                         moveColumn (columnIdBeingDragged, newIndex);
 706                     else
 707                         break;
 708                 }
 709             }
 710         }
 711         else
 712         {
 713             endDrag (draggingColumnOriginalIndex);
 714         }
 715     }
 716 }
 717
 718 void TableHeaderComponent::beginDrag (const MouseEvent& e)
 719 {
 720     if (columnIdBeingDragged == 0)
 721     {
 722         columnIdBeingDragged = getColumnIdAtX (e.getMouseDownX());
 723
 724         const ColumnInfo* const ci = getInfoForId (columnIdBeingDragged);
 725
 726         if (ci == nullptr || (ci->propertyFlags & draggable) == 0)
 727         {
 728             columnIdBeingDragged = 0;
 729         }
 730         else
 731         {
 732             draggingColumnOriginalIndex = getIndexOfColumnId (columnIdBeingDragged, true);
 733
 734             const Rectangle<int> columnRect (getColumnPosition (draggingColumnOriginalIndex));
 735
 736             const int temp = columnIdBeingDragged;
 737             columnIdBeingDragged = 0;
 738
 739             addAndMakeVisible (dragOverlayComp = new DragOverlayComp (createComponentSnapshot (columnRect, false)));
 740             columnIdBeingDragged = temp;
 741
 742             dragOverlayComp->setBounds (columnRect);
 743
 744             for (int i = listeners.size(); --i >= 0;)
 745             {
 746                 listeners.getUnchecked(i)->tableColumnDraggingChanged (this, columnIdBeingDragged);
 747                 i = jmin (i, listeners.size() - 1);
 748             }
 749         }
 750     }
 751 }
 752
 753 void TableHeaderComponent::endDrag (const int finalIndex)
 754 {
 755     if (columnIdBeingDragged != 0)
 756     {
 757         moveColumn (columnIdBeingDragged, finalIndex);
 758
 759         columnIdBeingDragged = 0;
 760         repaint();
 761
 762         for (int i = listeners.size(); --i >= 0;)
 763         {
 764             listeners.getUnchecked(i)->tableColumnDraggingChanged (this, 0);
 765             i = jmin (i, listeners.size() - 1);
 766         }
 767     }
 768 }
 769
 770 void TableHeaderComponent::mouseUp (const MouseEvent& e)
 771 {
 772     mouseDrag (e);
 773
 774     for (int i = columns.size(); --i >= 0;)
 775         if (columns.getUnchecked (i)->isVisible())
 776             columns.getUnchecked (i)->lastDeliberateWidth = columns.getUnchecked (i)->width;
 777
 778     columnIdBeingResized = 0;
 779     repaint();
 780
 781     endDrag (getIndexOfColumnId (columnIdBeingDragged, true));
 782
 783     updateColumnUnderMouse (e.x, e.y);
 784
 785     if (columnIdUnderMouse != 0 && e.mouseWasClicked() && ! e.mods.isPopupMenu())
 786         columnClicked (columnIdUnderMouse, e.mods);
 787
 788     dragOverlayComp = nullptr;
 789 }
 790
 791 const MouseCursor TableHeaderComponent::getMouseCursor()
 792 {
 793     if (columnIdBeingResized != 0 || (getResizeDraggerAt (getMouseXYRelative().getX()) != 0 && ! isMouseButtonDown()))
 794         return MouseCursor (MouseCursor::LeftRightResizeCursor);
 795
 796     return Component::getMouseCursor();
 797 }
 798
 799 //==============================================================================
 800 bool TableHeaderComponent::ColumnInfo::isVisible() const
 801 {
 802     return (propertyFlags & TableHeaderComponent::visible) != 0;
 803 }
 804
 805 TableHeaderComponent::ColumnInfo* TableHeaderComponent::getInfoForId (const int id) const
 806 {
 807     for (int i = columns.size(); --i >= 0;)
 808         if (columns.getUnchecked(i)->id == id)
 809             return columns.getUnchecked(i);
 810
 811     return nullptr;
 812 }
 813
 814 int TableHeaderComponent::visibleIndexToTotalIndex (const int visibleIndex) const
 815 {
 816     int n = 0;
 817
 818     for (int i = 0; i < columns.size(); ++i)
 819     {
 820         if (columns.getUnchecked(i)->isVisible())
 821         {
 822             if (n == visibleIndex)
 823                 return i;
 824
 825             ++n;
 826         }
 827     }
 828
 829     return -1;
 830 }
 831
 832 void TableHeaderComponent::sendColumnsChanged()
 833 {
 834     if (stretchToFit && lastDeliberateWidth > 0)
 835         resizeAllColumnsToFit (lastDeliberateWidth);
 836
 837     repaint();
 838     columnsChanged = true;
 839     triggerAsyncUpdate();
 840 }
 841
 842 void TableHeaderComponent::handleAsyncUpdate()
 843 {
 844     const bool changed = columnsChanged || sortChanged;
 845     const bool sized = columnsResized || changed;
 846     const bool sorted = sortChanged;
 847     columnsChanged = false;
 848     columnsResized = false;
 849     sortChanged = false;
 850
 851     if (sorted)
 852     {
 853         for (int i = listeners.size(); --i >= 0;)
 854         {
 855             listeners.getUnchecked(i)->tableSortOrderChanged (this);
 856             i = jmin (i, listeners.size() - 1);
 857         }
 858     }
 859
 860     if (changed)
 861     {
 862         for (int i = listeners.size(); --i >= 0;)
 863         {
 864             listeners.getUnchecked(i)->tableColumnsChanged (this);
 865             i = jmin (i, listeners.size() - 1);
 866         }
 867     }
 868
 869     if (sized)
 870     {
 871         for (int i = listeners.size(); --i >= 0;)
 872         {
 873             listeners.getUnchecked(i)->tableColumnsResized (this);
 874             i = jmin (i, listeners.size() - 1);
 875         }
 876     }
 877 }
 878
 879 int TableHeaderComponent::getResizeDraggerAt (const int mouseX) const
 880 {
 881     if (isPositiveAndBelow (mouseX, getWidth()))
 882     {
 883         const int draggableDistance = 3;
 884         int x = 0;
 885
 886         for (int i = 0; i < columns.size(); ++i)
 887         {
 888             const ColumnInfo* const ci = columns.getUnchecked(i);
 889
 890             if (ci->isVisible())
 891             {
 892                 if (abs (mouseX - (x + ci->width)) <= draggableDistance
 893                      && (ci->propertyFlags & resizable) != 0)
 894                     return ci->id;
 895
 896                 x += ci->width;
 897             }
 898         }
 899     }
 900
 901     return 0;
 902 }
 903
 904 void TableHeaderComponent::updateColumnUnderMouse (int x, int y)
 905 {
 906     const int newCol = (reallyContains (Point<int> (x, y), true) && getResizeDraggerAt (x) == 0)
 907                             ? getColumnIdAtX (x) : 0;
 908
 909     if (newCol != columnIdUnderMouse)
 910     {
 911         columnIdUnderMouse = newCol;
 912         repaint();
 913     }
 914 }
 915
 916 static void tableHeaderMenuCallback (int result, TableHeaderComponent* tableHeader, int columnIdClicked)
 917 {
 918     if (tableHeader != nullptr && result != 0)
 919         tableHeader->reactToMenuItem (result, columnIdClicked);
 920 }
 921
 922 void TableHeaderComponent::showColumnChooserMenu (const int columnIdClicked)
 923 {
 924     PopupMenu m;
 925     addMenuItems (m, columnIdClicked);
 926
 927     if (m.getNumItems() > 0)
 928     {
 929         m.setLookAndFeel (&getLookAndFeel());
 930
 931         m.showMenuAsync (PopupMenu::Options(),
 932                          ModalCallbackFunction::forComponent (tableHeaderMenuCallback, this, columnIdClicked));
 933     }
 934 }
 935
 936 void TableHeaderComponent::Listener::tableColumnDraggingChanged (TableHeaderComponent*, int)
 937 {
 938 }
 939
 940
 941 END_JUCE_NAMESPACE