wg_radiobutton.cpp

// wg_radiobutton.cpp
//
// CRadioButton class implementation
//
//
// Copyright (c) 2005-2006 Rob Wiskow, Jurgen De Backer
// rob-dev@boxedchaos.com, jurgendb@users.sourceforge.net
//
// 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_radiobutton.h"
#include "wg_message_server.h"
#include "wg_painter.h"


namespace wGui
{

// judb p is the upper-left corner of the radiobutton; size is the width=height
CRadioButton::CRadioButton(const CRect& WindowRect, CWindow* pParent) :
     CWindow(WindowRect, pParent),
     m_eRadioButtonState(UNCHECKED),
     m_MouseButton(0)
{
     m_BackgroundColor = COLOR_WHITE;   
     CMessageServer::Instance().RegisterMessageClient(this, CMessage::MOUSE_BUTTONUP);
     CMessageServer::Instance().RegisterMessageClient(this, CMessage::CTRL_SINGLELCLICK);
     Draw();
}


void CRadioButton::SetState(EState eState)
{
     if (m_eRadioButtonState != eState)
     {
          m_eRadioButtonState = eState;
          Draw();
     }
}


void CRadioButton::Draw(void) const
{
     CWindow::Draw();
     if (m_pSDLSurface)
     {
          CRect SubRect(m_WindowRect.SizeRect());
          CPainter Painter(m_pSDLSurface, CPainter::PAINT_REPLACE);
          if (m_eRadioButtonState != DISABLED)
          {
               Painter.DrawRect(SubRect, false, COLOR_DARKGRAY);
               if (m_eRadioButtonState == CHECKED)
               {
                    SubRect.Grow(-3);
                    Painter.DrawRect(SubRect, true, COLOR_BLACK, COLOR_BLACK);
               }
          }
          else
          {
               Painter.DrawRect(SubRect, false, COLOR_LIGHTGRAY);
          }
     }
}


bool CRadioButton::OnMouseButtonDown(CPoint Point, unsigned
int Button)
{
     bool bResult = CWindow::OnMouseButtonDown(Point, Button);
     if (!bResult && m_bVisible && (m_eRadioButtonState != DISABLED) &&
          (m_ClientRect.HitTest(ViewToWindow(Point)) == CRect::RELPOS_INSIDE))
     {
          m_MouseButton = Button;
          bResult = true;
     }
     return bResult;
}


bool CRadioButton::OnMouseButtonUp(CPoint Point, unsigned int Button)
{
     bool bResult = CWindow::OnMouseButtonUp(Point, Button);
     if (!bResult && m_bVisible && (m_eRadioButtonState != DISABLED) &&
          (m_MouseButton == Button) && (m_ClientRect.HitTest(ViewToWindow(Point)) == CRect::RELPOS_INSIDE))
     {
          CMessage::EMessageType MessageType =  CMessage::UNKNOWN;
          switch (m_MouseButton)
          {
          case CMouseMessage::LEFT:
               MessageType = CMessage::CTRL_SINGLELCLICK;
               break;
          case CMouseMessage::RIGHT:
               MessageType = CMessage::CTRL_SINGLERCLICK;
               break;
          case CMouseMessage::MIDDLE:
               MessageType = CMessage::CTRL_SINGLEMCLICK;
               break;
          }
          CMessageServer::Instance().QueueMessage(new TIntMessage(MessageType, this, this, 0));
          bResult = true;
     }
     return bResult;
}


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

     if (pMessage)
     {
          switch(pMessage->MessageType())
          {
          case CMessage::MOUSE_BUTTONUP:
          {
               CMouseMessage* pMouseMessage = dynamic_cast<CMouseMessage*>(pMessage);
               if (pMouseMessage && (m_ClientRect.HitTest(ViewToWindow(pMouseMessage->Point)) !=
                    CRect::RELPOS_INSIDE) && (m_MouseButton == pMouseMessage->Button))
               {
                    m_MouseButton = 0;
                    bHandled = true;
               }
               break;
          }
          case CMessage::CTRL_SINGLELCLICK:
               if (pMessage->Destination() == this)
               {
                    if (m_eRadioButtonState == UNCHECKED)
                    {
                         SetState(CHECKED);
                         // Uncheck all other 'children' of this parent that are radiobuttons:
                         std::list<CWindow*> ChildWindows = m_pParentWindow->GetChildWindows();
                         for (std::list<CWindow*>::iterator iter = ChildWindows.begin(); iter != ChildWindows.end(); ++iter)
                         {
                              // Compare the types to find out if a child is a CRadioButton.
                              CRadioButton* pRadioButton = dynamic_cast<CRadioButton*>(*iter);
                              if (pRadioButton && *iter != this)
                              {
                                   pRadioButton->SetState(UNCHECKED);
                              }
                         }                               
                         CMessageServer::Instance().QueueMessage(new TIntMessage(CMessage::CTRL_VALUECHANGE, m_pParentWindow, this, 1));
                         break;
                    }
               bHandled = true;
               }
               break;
          default :
               bHandled = CWindow::HandleMessage(pMessage);
               break;
          }
     }
     
     return bHandled;
}

}

---