wg_listbox.cpp

// wg_listbox.cpp
//
// CListBox class implementation
//
//
// Copyright (c) 2002-2004 Rob Wiskow
// rob-dev@boxedchaos.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//


#include "wgui_include_config.h"
#include "wg_listbox.h"
#include "wg_application.h"
#include "wg_message_server.h"
#include "wg_error.h"
#include "wutil_debug.h"
#include "std_ex.h"

namespace wGui
{

CListBox::CListBox(const CRect& WindowRect, CWindow* pParent, bool bSingleSelection, unsigned int iItemHeight, CFontEngine* pFontEngine) :
     CWindow(WindowRect, pParent),
     m_iItemHeight(iItemHeight),
     m_iFocusedItem(0),
     m_bSingleSelection(bSingleSelection),
     m_pDropDown(0)
{
     if (pFontEngine)
     {
          m_pFontEngine = pFontEngine;
     }
     else
     {
          m_pFontEngine = CApplication::Instance()->GetDefaultFontEngine();
     }
     CRect ScrollbarRect(m_WindowRect.SizeRect());
     ScrollbarRect.Grow(-1);
     m_pVScrollbar = new CScrollBar(
          CRect(ScrollbarRect.Right() - 12, ScrollbarRect.Top(), ScrollbarRect.Right(), ScrollbarRect.Bottom()) - CPoint(2, 2) /* client adjustment */,
          this, CScrollBar::VERTICAL),
     m_pVScrollbar->SetMaxLimit(0);
     m_ClientRect = CRect(2, 2, m_WindowRect.Width() - 16, m_WindowRect.Height() - 2);
     m_BackgroundColor = COLOR_WHITE;
     CMessageServer::Instance().RegisterMessageClient(this, CMessage::KEYBOARD_KEYDOWN);
     CMessageServer::Instance().RegisterMessageClient(this, CMessage::CTRL_VALUECHANGE);
     CMessageServer::Instance().RegisterMessageClient(this, CMessage::CTRL_VALUECHANGING);
     Draw();
}


CListBox::~CListBox(void)
{

}


void CListBox::SetItemHeight(unsigned int iItemHeight)
{
     m_iItemHeight = iItemHeight;
     Draw();
}


int CListBox::AddItem(SListItem ListItem)
{
     m_Items.push_back(ListItem);
     m_SelectedItems.push_back(false);
     m_RenderedStrings.push_back(CRenderedString(m_pFontEngine, ListItem.sItemText, CRenderedString::VALIGN_TOP, CRenderedString::HALIGN_LEFT));
     int iMax = (m_Items.size() - 1) < 0 ? 0 : stdex::safe_static_cast<int>(m_Items.size() - 1);
     if (m_iItemHeight > 0)
          iMax = iMax - (m_ClientRect.Height() / m_iItemHeight) + 1;
     m_pVScrollbar->SetMaxLimit(std::max(iMax, 0));
     Draw();
     return stdex::safe_static_cast<int>(m_Items.size());
}


void CListBox::RemoveItem(int iItemIndex)
{
     if (iItemIndex >= 0 && iItemIndex < stdex::safe_static_cast<int>(m_SelectedItems.size()))
     {
          m_Items.erase(m_Items.begin() + iItemIndex);
          m_SelectedItems.erase(m_SelectedItems.begin() + iItemIndex);
          int iMax = (m_Items.size() - 1) < 0 ? 0 : stdex::safe_static_cast<int>(m_Items.size() - 1);
          if (m_iItemHeight > 0)
               iMax = iMax - (m_ClientRect.Height() / m_iItemHeight) + 1;
          m_pVScrollbar->SetMaxLimit(std::max(iMax, 0));
          Draw();
     }
}


void CListBox::ClearItems(void)
{
     m_Items.clear();
     m_SelectedItems.clear();
     m_pVScrollbar->SetMaxLimit(0);
     Draw();
}


int CListBox::GetFirstSelectedIndex(void) const
{
     int iFirstSelectedItem = -1;
     for (unsigned int i = 0; i < m_Items.size(); ++i)
     {
          if (m_SelectedItems.at(i))
          {
               iFirstSelectedItem = i;
               break;
          }
     }
     
     return iFirstSelectedItem;
}


void CListBox::SetSelection(int iItemIndex, bool bSelected)
{
     if (iItemIndex >= 0 && iItemIndex < stdex::safe_static_cast<int>(m_SelectedItems.size()))
          m_SelectedItems.at(iItemIndex) = bSelected;
}


void CListBox::SetAllSelections(bool bSelected)
{
     for (unsigned int i = 0; i < m_Items.size(); ++i)
     {
          m_SelectedItems.at(i) = bSelected;
     }
}


void CListBox::Draw(void) const
{
     CWindow::Draw();

     if (m_pSDLSurface)
     {
          CPainter Painter(m_pSDLSurface, CPainter::PAINT_REPLACE);
          Painter.DrawRect(m_WindowRect.SizeRect(), false, COLOR_BLACK);
          int iStartIndex = m_pVScrollbar->GetValue();
          for (unsigned int i = iStartIndex; i < m_Items.size(); ++i)
          {
               CRect ItemRect(m_ClientRect.Left(), m_ClientRect.Top() + (i - iStartIndex) * m_iItemHeight,
                    m_ClientRect.Right(), m_ClientRect.Top() + (i - iStartIndex + 1) * m_iItemHeight - 1);
               if (ItemRect.Overlaps(m_ClientRect))
               {
                    ItemRect.ClipTo(m_ClientRect);
                    ItemRect.SetBottom(ItemRect.Bottom() - 1);
                    if (m_SelectedItems.at(i))
                    {
                         Painter.DrawRect(ItemRect, true, CApplication::Instance()->GetDefaultSelectionColor(), CApplication::Instance()->GetDefaultSelectionColor());
                    }
                    if (stdex::safe_static_cast<int>(i) == m_iFocusedItem)
                    {
                         ItemRect.Grow(1);
                         Painter.DrawRect(ItemRect, false, COLOR_BLACK);
                         ItemRect.Grow(-1);
                    }
                    ItemRect.Grow(-1);
                    m_RenderedStrings.at(i).Draw(m_pSDLSurface, ItemRect, ItemRect.TopLeft() + CPoint(0, 1), m_Items[i].ItemColor);
               }
          }
     }
}


void CListBox::SetWindowRect(const CRect& WindowRect)
{
     CWindow::SetWindowRect(WindowRect);
     m_ClientRect = CRect(2, 2, m_WindowRect.Width() - 16, m_WindowRect.Height() - 2);
     CRect ScrollbarRect(m_WindowRect.SizeRect());
     ScrollbarRect.Grow(-1);
     m_pVScrollbar->SetWindowRect(
          CRect(ScrollbarRect.Right() - 12, ScrollbarRect.Top(), ScrollbarRect.Right(), ScrollbarRect.Bottom()) - CPoint(2, 2) /* client adjustment */);
}


void CListBox::PaintToSurface(SDL_Surface& ScreenSurface, SDL_Surface& FloatingSurface, const CPoint& Offset) const
{
     if (m_pDropDown)
     {
          if (m_bVisible)
          {
               SDL_Rect SourceRect = CRect(m_WindowRect.SizeRect()).SDLRect();
               SDL_Rect DestRect = CRect(m_WindowRect + Offset).SDLRect();
               SDL_BlitSurface(m_pSDLSurface, &SourceRect, &FloatingSurface, &DestRect);
               CPoint NewOffset = m_ClientRect.TopLeft() + m_WindowRect.TopLeft() + Offset;
               for (std::list<CWindow*>::const_iterator iter = m_ChildWindows.begin(); iter != m_ChildWindows.end(); ++iter)
               {
                    (*iter)->PaintToSurface(FloatingSurface, FloatingSurface, NewOffset);
               }
          }
     }
     else
     {
          CWindow::PaintToSurface(ScreenSurface, FloatingSurface, Offset);
     }
}


bool CListBox::OnMouseButtonDown(CPoint Point, unsigned int Button)
{
     CPoint WindowPoint(ViewToWindow(Point));
     bool bResult = CWindow::OnMouseButtonDown(Point, Button);
     if (!bResult && m_bVisible && (Button == CMouseMessage::LEFT) &&
          (m_WindowRect.SizeRect().HitTest(WindowPoint) == CRect::RELPOS_INSIDE))
     {
          if (CApplication::Instance()->GetKeyFocus() != this)
          {
               CApplication::Instance()->SetKeyFocus(this);
          }

          if (!m_Items.empty() && m_ClientRect.HitTest(WindowPoint) == CRect::RELPOS_INSIDE)
          {
               // Prep the new selection
               m_iFocusedItem = (WindowPoint.YPos() + m_ClientRect.Top()) / m_iItemHeight + m_pVScrollbar->GetValue();
               Draw();
          }
          bResult = true;
     }

     return bResult;
}


bool CListBox::OnMouseButtonUp(CPoint Point, unsigned int Button)
{
     bool bResult = CWindow::OnMouseButtonUp(Point, Button);

     CPoint WindowPoint(ViewToWindow(Point));
     if (!bResult && m_bVisible && (Button == CMouseMessage::LEFT) && (m_ClientRect.HitTest(WindowPoint) == CRect::RELPOS_INSIDE))
     {
          if (m_iFocusedItem == stdex::safe_static_cast<int>((WindowPoint.YPos() - m_ClientRect.Top()) / m_iItemHeight + m_pVScrollbar->GetValue()))
          {
               if (m_bSingleSelection)
               {
                    SetAllSelections(false);
               }
               SetSelection(m_iFocusedItem, !IsSelected(m_iFocusedItem));
               CWindow* pDestination = m_pParentWindow;
               if (m_pDropDown)
               {
                    pDestination = m_pDropDown;
               }
               CMessageServer::Instance().QueueMessage(new TIntMessage(CMessage::CTRL_VALUECHANGE, pDestination, this, m_iFocusedItem));
               Draw();
          }
          bResult = true;
     }

     return bResult;
}


bool CListBox::HandleMessage(CMessage* pMessage)
{
     bool bHandled = false;

     if (pMessage)
     {
          switch(pMessage->MessageType())
          {
          case CMessage::KEYBOARD_KEYDOWN:
          {
               CKeyboardMessage* pKeyMsg = dynamic_cast<CKeyboardMessage*>(pMessage);
               if (pKeyMsg && pMessage->Destination() == this)
               {
                    switch (pKeyMsg->Key)
                    {
                         case SDLK_DOWN:
                         {
                              if (m_iFocusedItem + 1 < Size())
                              {
                                   m_iFocusedItem++;
                                   int diff = m_iFocusedItem - m_pVScrollbar->GetValue();
                                   if (m_iItemHeight * (m_pVScrollbar->GetValue() + diff + 1) > stdex::safe_static_cast<unsigned int>(m_ClientRect.Height()))
                                   {
                                        m_pVScrollbar->SetValue(m_pVScrollbar->GetValue() + 1);
                                   }

                                   Draw();
                                   bHandled = true;
                              }
                              break;
                         }
                         case SDLK_UP:
                         {
                              if ( m_iFocusedItem > 0 )
                              {
                                   m_iFocusedItem--;
                                   if (m_iFocusedItem < m_pVScrollbar->GetValue())
                                   {
                                        m_pVScrollbar->SetValue(m_pVScrollbar->GetValue() - 1);
                                   }
                                   Draw();
                                   bHandled = true;
                              }
                              break;
                         }
                         case SDLK_PAGEDOWN:
                         {
                              int nSize = Size() - 1;
                              int nItemsPerPage = m_ClientRect.Height() / m_iItemHeight;
                              if (m_iFocusedItem + nItemsPerPage < nSize)
                              {
                                   m_iFocusedItem += nItemsPerPage;
                              }
                              else
                              {
                                   m_iFocusedItem = nSize;
                              }
                              m_pVScrollbar->SetValue(m_iFocusedItem);
                              Draw();
                              bHandled=true;
                              break;
                         }
                         case SDLK_PAGEUP:
                         {
                              int nItemsPerPage = m_ClientRect.Height() / m_iItemHeight;
                              if (m_iFocusedItem - nItemsPerPage > 0)
                              {
                                   m_iFocusedItem -= nItemsPerPage;
                              }
                              else
                              {
                                   m_iFocusedItem = 0;
                              }
                              m_pVScrollbar->SetValue(m_iFocusedItem);
                              Draw();
                              bHandled=true;
                              break;
                         }
                         case SDLK_SPACE:
                         {
                              if (! m_Items.empty())
                              {
                                   SetSelection(m_iFocusedItem, !IsSelected(m_iFocusedItem));
                                   Draw();
                              }
                              bHandled = true;
                              break;
                         }
                         default:
                         {
                              bHandled=false;
                              break;
                         }
                    }
               }
               break;
          }
          case CMessage::CTRL_VALUECHANGE:
          case CMessage::CTRL_VALUECHANGING:
          {
               if (pMessage->Source() == m_pVScrollbar)
               {
                    Draw();
                    bHandled = true;
               }
               break;
          }
          default :
               bHandled = CWindow::HandleMessage(pMessage);
               break;
          }
     }

     return bHandled;
}

}

---