void selectRow (const int row, const int rowHeight, const bool dontScroll,
const int lastRowSelected, const int totalItems, const bool isMouseClick)
{
hasUpdated = false;
if (row < firstWholeIndex && ! dontScroll)
{
setViewPosition (getViewPositionX(), row * rowHeight);
}
else if (row >= lastWholeIndex && ! dontScroll)
{
const int rowsOnScreen = lastWholeIndex - firstWholeIndex;
if (row >= lastRowSelected + rowsOnScreen
&& rowsOnScreen < totalItems - 1
&& ! isMouseClick)
{
setViewPosition (getViewPositionX(),
jlimit (0, jmax (0, totalItems - rowsOnScreen), row) * rowHeight);
}
else
{
setViewPosition (getViewPositionX(),
jmax (0, (row + 1) * rowHeight - getMaximumVisibleHeight()));
}
}
if (! hasUpdated)
updateContents();
}
void updateVisibleArea (const bool makeSureItUpdatesContent)
{
hasUpdated = false;
const int newX = getViewedComponent()->getX();
int newY = getViewedComponent()->getY();
const int newW = jmax (owner.minimumRowWidth, getMaximumVisibleWidth());
const int newH = owner.totalItems * owner.getRowHeight();
if (newY + newH < getMaximumVisibleHeight() && newH > getMaximumVisibleHeight())
newY = getMaximumVisibleHeight() - newH;
getViewedComponent()->setBounds (newX, newY, newW, newH);
if (makeSureItUpdatesContent && ! hasUpdated)
updateContents();
}
void updateContents()
{
hasUpdated = true;
const int rowHeight = owner.getRowHeight();
if (rowHeight > 0)
{
const int y = getViewPositionY();
const int w = getViewedComponent()->getWidth();
const int numNeeded = 2 + getMaximumVisibleHeight() / rowHeight;
rows.removeRange (numNeeded, rows.size());
while (numNeeded > rows.size())
{
ListBoxRowComponent* newRow = new ListBoxRowComponent (owner);
rows.add (newRow);
getViewedComponent()->addAndMakeVisible (newRow);
}
firstIndex = y / rowHeight;
firstWholeIndex = (y + rowHeight - 1) / rowHeight;
lastWholeIndex = (y + getMaximumVisibleHeight() - 1) / rowHeight;
for (int i = 0; i < numNeeded; ++i)
{
const int row = i + firstIndex;
ListBoxRowComponent* const rowComp = getComponentForRow (row);
if (rowComp != nullptr)
{
rowComp->setBounds (0, row * rowHeight, w, rowHeight);
rowComp->update (row, owner.isRowSelected (row));
}
}
}
if (owner.headerComponent != nullptr)
owner.headerComponent->setBounds (owner.outlineThickness + getViewedComponent()->getX(),
owner.outlineThickness,
jmax (owner.getWidth() - owner.outlineThickness * 2,
getViewedComponent()->getWidth()),
owner.headerComponent->getHeight());
}
void scrollToEnsureRowIsOnscreen (const int row, const int rowHeight)
{
if (row < firstWholeIndex)
{
setViewPosition (getViewPositionX(), row * rowHeight);
}
else if (row >= lastWholeIndex)
{
setViewPosition (getViewPositionX(),
jmax (0, (row + 1) * rowHeight - getMaximumVisibleHeight()));
}
}
void ColumnFileBrowser::resized()
{
Viewport::resized();
fileBrowser->setSize (fileBrowser->getWidth(), getMaximumVisibleHeight());
}
//==============================================================================
void Viewport::updateVisibleRegion()
{
if (contentComp != 0)
{
const int newVX = -contentComp->getX();
const int newVY = -contentComp->getY();
if (newVX == 0 && newVY == 0
&& contentComp->getWidth() <= getWidth()
&& contentComp->getHeight() <= getHeight())
{
horizontalScrollBar->setVisible (false);
verticalScrollBar->setVisible (false);
}
horizontalScrollBar->setRangeLimits (0.0, contentComp->getWidth());
horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
horizontalScrollBar->setSingleStepSize (singleStepX);
if (! (contentComp->getWidth() > 0 && showHScrollbar && getHeight() > getScrollBarThickness()))
horizontalScrollBar->setVisible (false);
verticalScrollBar->setRangeLimits (0.0, contentComp->getHeight());
verticalScrollBar->setCurrentRange (newVY, getMaximumVisibleHeight());
verticalScrollBar->setSingleStepSize (singleStepY);
if (! (contentComp->getHeight() > 0 && showVScrollbar && getWidth() > getScrollBarThickness()))
verticalScrollBar->setVisible (false);
if (verticalScrollBar->isVisible())
{
horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
verticalScrollBar->setCurrentRange (newVY, getMaximumVisibleHeight());
verticalScrollBar
->setBounds (getMaximumVisibleWidth(), 0,
getScrollBarThickness(), getMaximumVisibleHeight());
}
if (horizontalScrollBar->isVisible())
{
horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
horizontalScrollBar
->setBounds (0, getMaximumVisibleHeight(),
getMaximumVisibleWidth(), getScrollBarThickness());
}
contentHolder->setSize (getMaximumVisibleWidth(),
getMaximumVisibleHeight());
const int newVW = jmin (contentComp->getRight(), getMaximumVisibleWidth());
const int newVH = jmin (contentComp->getBottom(), getMaximumVisibleHeight());
if (newVX != lastVX
|| newVY != lastVY
|| newVW != lastVW
|| newVH != lastVH)
{
lastVX = newVX;
lastVY = newVY;
lastVW = newVW;
lastVH = newVH;
visibleAreaChanged (newVX, newVY, newVW, newVH);
for (int i = viewportListeners.size(); --i >= 0;)
{
((ViewportListener*) viewportListeners.getUnchecked (i))
->visibleAreaChanged (this, newVX, newVY, newVW, newVH);
}
}
horizontalScrollBar->handleUpdateNowIfNeeded();
verticalScrollBar->handleUpdateNowIfNeeded();
}
else
{
horizontalScrollBar->setVisible (false);
verticalScrollBar->setVisible (false);
}
}
