bool CGUIFixedListContainer::MoveDown(bool wrapAround)
{
if (m_offset + m_cursor + 1 < (int)m_items.size())
{
ScrollToOffset(m_offset + 1);
}
else if (wrapAround)
{ // move first item in list
ScrollToOffset(-m_cursor);
g_infoManager.SetContainerMoving(GetID(), 1);
}
else
return false;
if (m_items.size() > (size_t) (m_offset +m_cursor) && m_items[m_offset +m_cursor]->GetPropertyBOOL("isseparator"))
{
if ((size_t) (m_offset +m_cursor) == m_items.size() - 1)
{
MoveUp(wrapAround);
if (!wrapAround)
return false;
}
else
{
MoveDown(wrapAround);
}
}
return true;
}
bool CGUIListContainer::MoveUp(bool wrapAround)
{
if (GetCursor() > 0)
{
SetCursor(GetCursor() - 1);
}
else if (GetCursor() == 0 && GetOffset())
{
ScrollToOffset(GetOffset() - 1);
}
else if (wrapAround)
{
if (m_items.size() > 0)
{ // move 2 last item in list, and set our container moving up
int offset = m_items.size() - m_itemsPerPage;
if (offset < 0) offset = 0;
SetCursor(m_items.size() - offset - 1);
ScrollToOffset(offset);
SetContainerMoving(-1);
}
}
else
return false;
return true;
}
bool CGUIFixedListContainer::MoveUp(bool wrapAround)
{
if (m_offset > -m_cursor)
ScrollToOffset(m_offset - 1);
else if (wrapAround)
{
if (m_items.size() > 0)
{ // move 2 last item in list
int offset = m_items.size() - m_cursor - 1;
if (offset < -m_cursor) offset = -m_cursor;
ScrollToOffset(offset);
g_infoManager.SetContainerMoving(GetID(), -1);
}
}
else
return false;
if (m_items.size() > (size_t) (m_offset +m_cursor) && m_items[m_offset +m_cursor]->GetPropertyBOOL("isseparator"))
{
if (m_offset +m_cursor == 0)
{
MoveDown(wrapAround);
if (!wrapAround)
return false;
}
else
{
MoveUp(wrapAround);
}
}
return true;
}
bool CGUIPanelContainer::MoveDown(bool wrapAround)
{
if (GetCursor() + m_itemsPerRow < m_itemsPerPage * m_itemsPerRow && (GetOffset() + 1 + GetCursor() / m_itemsPerRow) * m_itemsPerRow < (int)m_items.size())
{ // move to last item if necessary
if ((GetOffset() + 1)*m_itemsPerRow + GetCursor() >= (int)m_items.size())
SetCursor((int)m_items.size() - 1 - GetOffset()*m_itemsPerRow);
else
SetCursor(GetCursor() + m_itemsPerRow);
}
else if ((GetOffset() + 1 + GetCursor() / m_itemsPerRow) * m_itemsPerRow < (int)m_items.size())
{ // we scroll to the next row, and move to last item if necessary
if ((GetOffset() + 1)*m_itemsPerRow + GetCursor() >= (int)m_items.size())
SetCursor((int)m_items.size() - 1 - (GetOffset() + 1)*m_itemsPerRow);
ScrollToOffset(GetOffset() + 1);
}
else if (wrapAround)
{ // move first item in list
SetCursor(GetCursor() % m_itemsPerRow);
ScrollToOffset(0);
SetContainerMoving(1);
}
else
return false;
return true;
}
bool CGUIListContainer::MoveUp(bool wrapAround)
{
if (m_cursor > 0)
{
SetCursor(m_cursor - 1);
}
else if (m_cursor == 0 && m_offset)
{
ScrollToOffset(m_offset - 1);
}
else if (wrapAround)
{
if (m_items.size() > 0)
{ // move 2 last item in list, and set our container moving up
int offset = m_items.size() - m_itemsPerPage;
if (offset < 0) offset = 0;
SetCursor(m_items.size() - offset - 1);
ScrollToOffset(offset);
g_infoManager.SetContainerMoving(GetID(), -1);
}
}
else
return false;
return true;
}
bool CGUIFixedListContainer::SelectItemFromPoint(const CPoint &point)
{
if (!m_focusedLayout || !m_layout)
return false;
MarkDirtyRegion();
const float mouse_scroll_speed = 0.25f;
const float mouse_max_amount = 1.5f;
float sizeOfItem = m_layout->Size(m_orientation);
int minCursor, maxCursor;
GetCursorRange(minCursor, maxCursor);
// see if the point is either side of our focus range
float start = (minCursor + 0.2f) * sizeOfItem;
float end = (maxCursor - 0.2f) * sizeOfItem + m_focusedLayout->Size(m_orientation);
float pos = (m_orientation == VERTICAL) ? point.y : point.x;
if (pos < start && GetOffset() > -minCursor)
{ // scroll backward
if (!InsideLayout(m_layout, point))
return false;
float amount = std::min((start - pos) / sizeOfItem, mouse_max_amount);
m_analogScrollCount += amount * amount * mouse_scroll_speed;
if (m_analogScrollCount > 1)
{
ScrollToOffset(GetOffset() - 1);
m_analogScrollCount = 0;
}
return true;
}
else if (pos > end && GetOffset() + maxCursor < (int)m_items.size() - 1)
{
if (!InsideLayout(m_layout, point))
return false;
// scroll forward
float amount = std::min((pos - end) / sizeOfItem, mouse_max_amount);
m_analogScrollCount += amount * amount * mouse_scroll_speed;
if (m_analogScrollCount > 1)
{
ScrollToOffset(GetOffset() + 1);
m_analogScrollCount = 0;
}
return true;
}
else
{ // select the appropriate item
int cursor = GetCursorFromPoint(point);
if (cursor < 0)
return false;
// calling SelectItem() here will focus the item and scroll, which isn't really what we're after
SetCursor(cursor);
return true;
}
}
bool CGUIFixedListContainer::MoveDown(bool wrapAround)
{
if (m_offset + m_cursor + 1 < (int)m_items.size())
{
ScrollToOffset(m_offset + 1);
}
else if (wrapAround)
{ // move first item in list
ScrollToOffset(-m_cursor);
g_infoManager.SetContainerMoving(GetID(), 1);
}
else
return false;
return true;
}
void CGUIFixedListContainer::SelectItem(int item)
{
// Check that GetOffset() is valid
ValidateOffset();
// only select an item if it's in a valid range
if (item >= 0 && item < (int)m_items.size())
{
// Select the item requested - we first set the cursor position
// which may be different at either end of the list, then the offset
int minCursor, maxCursor;
GetCursorRange(minCursor, maxCursor);
int cursor;
if ((int)m_items.size() - 1 - item <= maxCursor - m_fixedCursor)
cursor = std::max(m_fixedCursor, maxCursor + item - (int)m_items.size() + 1);
else if (item <= m_fixedCursor - minCursor)
cursor = std::min(m_fixedCursor, minCursor + item);
else
cursor = m_fixedCursor;
if (cursor != GetCursor())
SetContainerMoving(cursor - GetCursor());
SetCursor(cursor);
ScrollToOffset(item - GetCursor());
}
}
EVENT_RESULT CGUIBaseContainer::OnMouseEvent(const CPoint &point, const CMouseEvent &event)
{
if (event.m_id >= ACTION_MOUSE_LEFT_CLICK && event.m_id <= ACTION_MOUSE_DOUBLE_CLICK)
{
if (SelectItemFromPoint(point - CPoint(m_posX, m_posY)))
{
OnClick(event.m_id);
return EVENT_RESULT_HANDLED;
}
}
else if (event.m_id == ACTION_MOUSE_WHEEL_UP)
{
Scroll(-1);
return EVENT_RESULT_HANDLED;
}
else if (event.m_id == ACTION_MOUSE_WHEEL_DOWN)
{
Scroll(1);
return EVENT_RESULT_HANDLED;
}
else if (event.m_id == ACTION_GESTURE_NOTIFY)
{
return (m_orientation == HORIZONTAL) ? EVENT_RESULT_PAN_HORIZONTAL : EVENT_RESULT_PAN_VERTICAL;
}
else if (event.m_id == ACTION_GESTURE_BEGIN)
{ // grab exclusive access
CGUIMessage msg(GUI_MSG_EXCLUSIVE_MOUSE, GetID(), GetParentID());
SendWindowMessage(msg);
return EVENT_RESULT_HANDLED;
}
else if (event.m_id == ACTION_GESTURE_PAN)
{ // do the drag and validate our offset (corrects for end of scroll)
m_scroller.SetValue(m_scroller.GetValue() - ((m_orientation == HORIZONTAL) ? event.m_offsetX : event.m_offsetY));
float size = (m_layout) ? m_layout->Size(m_orientation) : 10.0f;
int offset = (int)MathUtils::round_int(m_scroller.GetValue() / size);
m_lastScrollStartTimer.Stop();
m_scrollTimer.Start();
SetOffset(offset);
ValidateOffset();
return EVENT_RESULT_HANDLED;
}
else if (event.m_id == ACTION_GESTURE_END)
{ // release exclusive access
CGUIMessage msg(GUI_MSG_EXCLUSIVE_MOUSE, 0, GetParentID());
SendWindowMessage(msg);
m_scrollTimer.Stop();
// and compute the nearest offset from this and scroll there
float size = (m_layout) ? m_layout->Size(m_orientation) : 10.0f;
float offset = m_scroller.GetValue() / size;
int toOffset = (int)MathUtils::round_int(offset);
if (toOffset < offset)
SetOffset(toOffset+1);
else
SetOffset(toOffset-1);
ScrollToOffset(toOffset);
return EVENT_RESULT_HANDLED;
}
return EVENT_RESULT_UNHANDLED;
}
void CGUITextBox::Scroll(unsigned int offset)
{
ResetAutoScrolling();
if (m_lines.size() <= m_itemsPerPage)
return; // no need to scroll
if (offset > m_lines.size() - m_itemsPerPage)
offset = m_lines.size() - m_itemsPerPage; // on last page
ScrollToOffset(offset);
}
bool CGUIFixedListContainer::MoveUp(bool wrapAround)
{
if (m_offset > -m_cursor)
ScrollToOffset(m_offset - 1);
else if (wrapAround)
{
if (m_items.size() > 0)
{ // move 2 last item in list
int offset = m_items.size() - m_cursor - 1;
if (offset < -m_cursor) offset = -m_cursor;
ScrollToOffset(offset);
g_infoManager.SetContainerMoving(GetID(), -1);
}
}
else
return false;
return true;
}
void CGUIFixedListContainer::SelectItem(int item)
{
// Check that m_offset is valid
ValidateOffset();
// only select an item if it's in a valid range
if (item >= 0 && item < (int)m_items.size())
{
// Select the item requested
ScrollToOffset(item - m_cursor);
}
}
bool CGUIPanelContainer::MoveUp(bool wrapAround)
{
if (GetCursor() >= m_itemsPerRow)
SetCursor(GetCursor() - m_itemsPerRow);
else if (GetOffset() > 0)
ScrollToOffset(GetOffset() - 1);
else if (wrapAround)
{ // move last item in list in this column
SetCursor((GetCursor() % m_itemsPerRow) + (m_itemsPerPage - 1) * m_itemsPerRow);
int offset = std::max((int)GetRows() - m_itemsPerPage, 0);
// should check here whether cursor is actually allowed here, and reduce accordingly
if (offset * m_itemsPerRow + GetCursor() >= (int)m_items.size())
SetCursor((int)m_items.size() - offset * m_itemsPerRow - 1);
ScrollToOffset(offset);
SetContainerMoving(-1);
}
else
return false;
return true;
}
// scrolls the said amount
void CGUIListContainer::Scroll(int amount)
{
// increase or decrease the offset
int offset = GetOffset() + amount;
if (offset > (int)m_items.size() - m_itemsPerPage)
{
offset = m_items.size() - m_itemsPerPage;
}
if (offset < 0) offset = 0;
ScrollToOffset(offset);
}
// scrolls the said amount
void CGUIPanelContainer::Scroll(int amount)
{
// increase or decrease the offset
int offset = GetOffset() + amount;
if (offset > ((int)GetRows() - m_itemsPerPage) * m_itemsPerRow)
{
offset = ((int)GetRows() - m_itemsPerPage) * m_itemsPerRow;
}
if (offset < 0) offset = 0;
ScrollToOffset(offset);
}
// scrolls the said amount
void CGUIFixedListContainer::Scroll(int amount)
{
// increase or decrease the offset
int offset = m_offset + amount;
if (offset >= (int)m_items.size() - m_cursor)
{
offset = m_items.size() - m_cursor - 1;
}
if (offset < -m_cursor) offset = -m_cursor;
ScrollToOffset(offset);
}
bool CGUIListContainer::MoveDown(bool wrapAround)
{
if (GetOffset() + GetCursor() + 1 < (int)m_items.size())
{
if (GetCursor() + 1 < m_itemsPerPage)
{
SetCursor(GetCursor() + 1);
}
else
{
ScrollToOffset(GetOffset() + 1);
}
}
else if(wrapAround)
{ // move first item in list, and set our container moving in the "down" direction
SetCursor(0);
ScrollToOffset(0);
SetContainerMoving(1);
}
else
return false;
return true;
}
bool CGUIListContainer::MoveDown(bool wrapAround)
{
if (m_offset + m_cursor + 1 < (int)m_items.size())
{
if (m_cursor + 1 < m_itemsPerPage)
{
SetCursor(m_cursor + 1);
}
else
{
ScrollToOffset(m_offset + 1);
}
}
else if(wrapAround)
{ // move first item in list, and set our container moving in the "down" direction
SetCursor(0);
ScrollToOffset(0);
g_infoManager.SetContainerMoving(GetID(), 1);
}
else
return false;
return true;
}
void CGUIListContainer::SelectItem(int item)
{
// Check that m_offset is valid
ValidateOffset();
// only select an item if it's in a valid range
if (item >= 0 && item < (int)m_items.size())
{
// Select the item requested
if (item >= m_offset && item < m_offset + m_itemsPerPage)
{ // the item is on the current page, so don't change it.
SetCursor(item - m_offset);
}
else if (item < m_offset)
{ // item is on a previous page - make it the first item on the page
SetCursor(0);
ScrollToOffset(item);
}
else // (item >= m_offset+m_itemsPerPage)
{ // item is on a later page - make it the last item on the page
SetCursor(m_itemsPerPage - 1);
ScrollToOffset(item - m_cursor);
}
}
}
void CGUIPanelContainer::SelectItem(int item)
{
// Check that our offset is valid
ValidateOffset();
// only select an item if it's in a valid range
if (item >= 0 && item < (int)m_items.size())
{
// Select the item requested
if (item >= GetOffset() * m_itemsPerRow && item < (GetOffset() + m_itemsPerPage) * m_itemsPerRow)
{ // the item is on the current page, so don't change it.
SetCursor(item - GetOffset() * m_itemsPerRow);
}
else if (item < GetOffset() * m_itemsPerRow)
{ // item is on a previous page - make it the first item on the page
SetCursor(item % m_itemsPerRow);
ScrollToOffset((item - GetCursor()) / m_itemsPerRow);
}
else // (item >= GetOffset()+m_itemsPerPage)
{ // item is on a later page - make it the last row on the page
SetCursor(item % m_itemsPerRow + m_itemsPerRow * (m_itemsPerPage - 1));
ScrollToOffset((item - GetCursor()) / m_itemsPerRow);
}
}
}
void CGUIFixedListContainer::SelectItem(int item)
{
// Check that m_offset is valid
ValidateOffset();
// only select an item if it's in a valid range
if (item >= 0 && item < (int)m_items.size())
{
if (m_items[item]->GetPropertyBOOL("isseparator"))
{
SelectItem(item + 1);
return;
}
ScrollToOffset(item - m_cursor);
}
}
// scrolls the said amount
void CGUIFixedListContainer::Scroll(int amount)
{
// increase or decrease the offset
int offset = m_offset + amount;
if (offset >= (int)m_items.size() - m_cursor)
{
offset = m_items.size() - m_cursor - 1;
}
if (offset < -m_cursor) offset = -m_cursor;
ScrollToOffset(offset);
if (amount > 0)
{
if (m_items.size() > (size_t) (m_offset +m_cursor) && m_items[m_offset +m_cursor]->GetPropertyBOOL("isseparator"))
{
if ((size_t) (m_offset +m_cursor) == m_items.size() - 1)
{
Scroll(-1);
return;
}
else
{
Scroll(1);
return;
}
}
}
if (amount < 0)
{
if (m_items.size() > (size_t) (m_offset +m_cursor) && m_items[m_offset +m_cursor]->GetPropertyBOOL("isseparator"))
{
if (m_offset +m_cursor == 0)
{
Scroll(1);
return;
}
else
{
Scroll(-1);
return;
}
}
}
}
void CGUIFixedListContainer::Scroll(int amount)
{
// increase or decrease the offset within [-minCursor, m_items.size() - maxCursor]
int minCursor, maxCursor;
GetCursorRange(minCursor, maxCursor);
int offset = GetOffset() + amount;
if (offset < -minCursor)
{
offset = -minCursor;
SetCursor(minCursor);
}
if (offset > (int)m_items.size() - 1 - maxCursor)
{
offset = m_items.size() - 1 - maxCursor;
SetCursor(maxCursor);
}
ScrollToOffset(offset);
}
void HTMLView::AddStatement() {
int32 number_of_runs = (int32)insertStyles.Count();
int32 lineCount, lastOffset;
bool doAutoScroll = true;
// Get the scrollbar position... this is the part where we do autoscroll, but only
// if the scrollbar is already at the bottom. That way it won't get annoying.
if( scroll == NULL ) scroll = ScrollBar( B_VERTICAL );
if( scroll ) {
float scrMin, scrMax;
scroll->GetRange( &scrMin, &scrMax );
if( scroll->Value() != scrMax )
doAutoScroll = false;
}
// allocate some room for the text_run_array
text_run_array* styles = (text_run_array*)malloc( sizeof(text_run_array) +
(sizeof(text_run) * (number_of_runs - 1)));
// fill in the individual text_runs
styles->count = number_of_runs;
for( int32 i = 0; i < number_of_runs; ++i )
styles->runs[i] = insertStyles[i];
// Get the offset of the last line
lineCount = CountLines();
lastOffset = OffsetAt( lineCount );
// Add the silly thing
Insert( lastOffset, insertText, strlen(insertText), styles );
// do the autoscroll, if needed
if( doAutoScroll ) {
lineCount = CountLines();
lastOffset = OffsetAt( lineCount );
ScrollToOffset( lastOffset );
}
// Prepare to start over
Empty = false;
ClearFontStates();
free( styles );
}
void CGUITextBox::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
// update our auto-scrolling as necessary
if (m_autoScrollTime && m_lines.size() > m_itemsPerPage)
{
if ((!m_autoScrollCondition || m_autoScrollCondition->Get()) && !g_application.ScreenSaverDisablesAutoScrolling())
{
if (m_lastRenderTime)
m_autoScrollDelayTime += currentTime - m_lastRenderTime;
if (m_autoScrollDelayTime > (unsigned int)m_autoScrollDelay && m_scrollSpeed == 0)
{ // delay is finished - start scrolling
MarkDirtyRegion();
if (m_offset < (int)m_lines.size() - m_itemsPerPage)
ScrollToOffset(m_offset + 1, true);
else
{ // at the end, run a delay and restart
if (m_autoScrollRepeatAnim)
{
if (m_autoScrollRepeatAnim->GetState() == ANIM_STATE_NONE)
m_autoScrollRepeatAnim->QueueAnimation(ANIM_PROCESS_NORMAL);
else if (m_autoScrollRepeatAnim->GetState() == ANIM_STATE_APPLIED)
{ // reset to the start of the list and start the scrolling again
m_offset = 0;
m_scrollOffset = 0;
ResetAutoScrolling();
}
}
}
}
}
else if (m_autoScrollCondition)
ResetAutoScrolling(); // conditional is false, so reset the autoscrolling
}
// render the repeat anim as appropriate
if (m_autoScrollRepeatAnim)
{
if (m_autoScrollRepeatAnim->GetProcess() != ANIM_PROCESS_NONE)
MarkDirtyRegion();
m_autoScrollRepeatAnim->Animate(currentTime, true);
TransformMatrix matrix;
m_autoScrollRepeatAnim->RenderAnimation(matrix);
m_cachedTextMatrix = g_graphicsContext.AddTransform(matrix);
}
// update our scroll position as necessary
if (m_scrollSpeed != 0)
MarkDirtyRegion();
if (m_lastRenderTime)
m_scrollOffset += m_scrollSpeed * (currentTime - m_lastRenderTime);
if ((m_scrollSpeed < 0 && m_scrollOffset < m_offset * m_itemHeight) ||
(m_scrollSpeed > 0 && m_scrollOffset > m_offset * m_itemHeight))
{
m_scrollOffset = m_offset * m_itemHeight;
m_scrollSpeed = 0;
}
m_lastRenderTime = currentTime;
if (m_pageControl)
{
CGUIMessage msg(GUI_MSG_ITEM_SELECT, GetID(), m_pageControl, MathUtils::round_int(m_scrollOffset / m_itemHeight));
SendWindowMessage(msg);
}
CGUIControl::Process(currentTime, dirtyregions);
if (m_autoScrollRepeatAnim)
g_graphicsContext.RemoveTransform();
}
// scrolls the said amount
void CGUIBaseContainer::Scroll(int amount)
{
ResetAutoScrolling();
ScrollToOffset(GetOffset() + amount);
}
bool CGUIBaseContainer::OnMessage(CGUIMessage& message)
{
if (message.GetControlId() == GetID() )
{
if (!m_listProvider)
{
if (message.GetMessage() == GUI_MSG_LABEL_BIND && message.GetPointer())
{ // bind our items
Reset();
CFileItemList *items = static_cast<CFileItemList*>(message.GetPointer());
for (int i = 0; i < items->Size(); i++)
m_items.push_back(items->Get(i));
UpdateLayout(true); // true to refresh all items
UpdateScrollByLetter();
SelectItem(message.GetParam1());
return true;
}
else if (message.GetMessage() == GUI_MSG_LABEL_RESET)
{
Reset();
SetPageControlRange();
return true;
}
}
if (message.GetMessage() == GUI_MSG_ITEM_SELECT)
{
SelectItem(message.GetParam1());
return true;
}
else if (message.GetMessage() == GUI_MSG_SETFOCUS)
{
if (message.GetParam1()) // subfocus item is specified, so set the offset appropriately
{
int offset = GetOffset();
if (message.GetParam2() && message.GetParam2() == 1)
offset = 0;
int item = std::min(offset + (int)message.GetParam1() - 1, (int)m_items.size() - 1);
SelectItem(item);
}
}
else if (message.GetMessage() == GUI_MSG_ITEM_SELECTED)
{
message.SetParam1(GetSelectedItem());
return true;
}
else if (message.GetMessage() == GUI_MSG_PAGE_CHANGE)
{
if (message.GetSenderId() == m_pageControl && IsVisible())
{ // update our page if we're visible - not much point otherwise
if ((int)message.GetParam1() != GetOffset())
m_pageChangeTimer.StartZero();
ScrollToOffset(message.GetParam1());
return true;
}
}
else if (message.GetMessage() == GUI_MSG_REFRESH_LIST)
{ // update our list contents
for (unsigned int i = 0; i < m_items.size(); ++i)
m_items[i]->SetInvalid();
}
else if (message.GetMessage() == GUI_MSG_MOVE_OFFSET)
{
int count = (int)message.GetParam1();
while (count < 0)
{
MoveUp(true);
count++;
}
while (count > 0)
{
MoveDown(true);
count--;
}
return true;
}
}
return CGUIControl::OnMessage(message);
}
// scrolls the said amount
void CGUIWrappingListContainer::Scroll(int amount)
{
ScrollToOffset(m_offset + amount);
}
void CGUIWrappingListContainer::SelectItem(int item)
{
if (item >= 0 && item < (int)m_items.size())
ScrollToOffset(item - m_cursor);
}
