---

/cygdrive/d/Eigene Dateien/!DProcs/code_gen/QWidget.cpp

Go to the documentation of this file.

// Class QWidget 
// Common super class for all widgets. Here is also the basic implementation of event passing and dragging
// Filename QWidget.cpp
// FaPra 2003-2004, A5,  Alexander Kramer


#include "QWidget.h"
#include <iostream>
using namespace std;

// ----------------------------------------------------------

//! adds given widget to the children
void QWidget::add( QWidget*  widget )
{
  Children.push_front(widget);
  childrenChanged();
} // end of add()

//! removes given widget from the children
void QWidget::remove( QWidget*  widget )
{
  if (FocusPath == widget) FocusPath = 0;
  Children.remove(widget);
  childrenChanged();
} // end of remove()

//! sends request for freeing a widget to parent
void QWidget::freeWidget( QWidget*  widget )
{
  if (Owner) Owner->freeWidget(widget);
} // end of freeWidget()

//! clears the focus path by setting it to 0 recursively
void QWidget::clearFocusPath()
{
  if (FocusPath != 0)
   {
      FocusPath->clearFocusPath();
      FocusPath = 0;
   }
} // end of clearFocusPath()

//! returns true if widget has keyboard focus
bool QWidget::getFocused()
{
  return (Owner->getFocusPath() == this);
} // end of getFocused()

//! frees the widget and all resources. This method must be used insted of explicit delete
void QWidget::free()
{
  if (Owner) Owner->freeWidget(this);
} // end of free()

//! primary event receiver method. Returns true, if event was handled. In this case the event won't be passed to next child
bool QWidget::event( QEvent*  e )
{

  // if widget is not visible there is no event handling
  if (!Visible) return false;

  // check for draw event first
  if (e->getType() == etDraw)
   {
     changeContext();
     draw(e);
     if (onCustomDraw!=0) (*onCustomDraw)(this,e);

     /*
  glColorMask(0,0,0,0);
  glEnable(GL_STENCIL_TEST);
  glStencilFunc(GL_ALWAYS,1,1);
  glStencilOp(GL_KEEP,GL_KEEP,GL_REPLACE);
  glBegin(GL_QUADS);
  LookAndFeel->drawRect(0,0, Width, Height);
  glEnd();
  glColorMask(1,1,1,1);
  glStencilFunc(GL_EQUAL,1,1);
  glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
  glDisable(GL_STENCIL_TEST);
  */

  eventToChildrenReversed(e);


     restoreContext();
     return false;
  }

  // if we are here, we have mouse or keyboard event

  // if widget is disabled, no mouse or keyboard events are handled
  if (!Enabled) return false;

  // check for keyboard events
  if  ((e->getType() == etKeyboard) ||
       (e->getType() == etSpecialKey )  ||
       (e->getType() == etKeyboardUp ))
  {
     return handleKeyboardEvent(e);
  }

   // if we are here we have mouse event

   return handleMouseEvent(e);

} // end of event()

//! post request for redisplay
void QWidget::redraw()
{
  Owner->redraw();
} // end of redraw()

//! sends the event to each child. Returns true if event was handled
bool QWidget::eventToChildren( QEvent*  e )
{
  // Create constant iterator for list.
  list<QWidget*>::const_iterator iter;
  // Iterate through list
  for (iter=Children.begin(); iter != Children.end(); iter++)
  {
    if ((*iter)->event(e)) return true;
  }
  return false;
} // end of eventToChildren()

//! sends the event to each child in reversed order. Returns true if event was handled
bool QWidget::eventToChildrenReversed( QEvent*  e )
{
 // Create constant iterator for list.
  list<QWidget*>::reverse_iterator iter;
  // Iterate through list
  for (iter=Children.rbegin(); iter != Children.rend(); iter++)
  {
    if ((*iter)->event(e)) return true;
  }
  return false;
} // end of eventToChildrenReversed()

//! brings the given widget to the front. Must be a child widget
void QWidget::bringToFront( QWidget*  widget )
{
  unsigned int size = Children.size();
  Children.remove(widget);
  if ((Children.size()+1)== size) Children.push_front(widget);
} // end of bringToFront()

//! Returns true if a given widget is in front
bool QWidget::isInFront( QWidget*  widget )
{
  return (Children.front() == widget);
} // end of isInFront()

//! handles the keyboard event
bool QWidget::handleKeyboardEvent( QEvent*  e )
{
 processEvent(e);
 if (onKey!=0)  (*onKey)(this,e);
 if (FocusPath) FocusPath->event(e);
 return true;
} // end of handleKeyboardEvent()

//! handles the mouse event for this widget
bool QWidget::handleMouseEvent( QEvent*  e )
{

    // handle dragging
    if ((Dragging) && (e->getType() == etMouseMotion))
    {
      handleDragging(e);
      return true;
    }

      // save mouse coordinates for later restore
    int saved_x = e->getX();
    int saved_y = e->getY();

    // x and y are mouse coordinates relative to this widget
    int x = saved_x - Left;
    int y = saved_y - Top;


    //defines whether mouse coordinates are in this widget
    bool ourRegion = ((x>=0) && (y>=0) && (x<=Width) && (y<=Height));

    if (ourRegion && (e->getType() == etMouseDown))
    {
      doFocus(e);
    }

    // adjust mouse coordinates to be relative to this widget
    e->setX(x);
    e->setY(y);


    // pass mouse event to the children
    // handledByChildren is true if one of the
    bool handledByChildren = eventToChildren(e);

    // set mouse coordinates back to the saved values
    e->setX(saved_x);
    e->setY(saved_y);

    // return true if mouse event was handled in children widgets
    if (handledByChildren) return true;

    // So, the event was not handled by any child, see
    // what we can do with it.

    if ((Dragging) && (e->getType() == etMouseUp)) Dragging = false;

    // process mouse events in derived classes with owners coordinates
    processMouseOwner(e);

    // so we are not in dragging mode right now
    // check for entering dragging mode and other mouse events

    if  (ourRegion)
    {
       // processEvent in derived classes if we are in widgets region
       processEvent(e);

       // check for dragging and call custom event handlers
        switch (e->getType())
        {
          case etMouseClick:
            if (onClick!=0)     (*onClick)(this,e);
          break;

          case etMouseDown:
            if (canDrag(e))
            {
              Dragging = true;
              DragStartX = x;
              DragStartY = y;
            }
            if (onMouseDown!=0) (*onMouseDown)(this,e);
          break;

          case etMouseUp:

            if (onMouseUp!=0)   (*onMouseUp)(this,e);
          break;

          case etMouseMotion:
             if (onMouseMove!=0)   (*onMouseMove)(this,e);
          break;

          default: ;
        }

       //the event was handled in this widget, so other children should not
       //get it -> return true
       return true;
    }


  // mouse event was not in our region -> return false
  return false;

} // end of handleMouseEvent()

//! handles the dragging
void QWidget::handleDragging( QEvent*  e )
{
   // defines snap width
   const int snap_width = 5;

   int new_x = e->getX()-DragStartX;
   int new_y = e->getY()-DragStartY;

   int minx = Owner->getClientBorderLeft();
   int maxx = Owner->getWidth()-Width-Owner->getClientBorderRight();
   int miny = Owner->getClientBorderTop();
   int maxy = Owner->getHeight()-Height-Owner->getClientBorderBottom();

   if (new_x < snap_width + minx ) new_x = minx;
   else
   if (new_x > maxx - snap_width) new_x = maxx;

   if (new_y < snap_width + miny) new_y = miny;
   else
   if (new_y > maxy - snap_width) new_y = maxy;

   setLeft(new_x);
   setTop (new_y);

} // end of handleDragging()

//! tries to set focus to the current widget
void QWidget::doFocus( QEvent*  e )
{
  if (Owner) Owner->bringToFront(this);
  if ((canFocus(e)) && (Owner!=0))
   {
     Owner->requestFocus(this,this);
   }
} // end of doFocus()

//! called if Sender wants to announce new focused control
void QWidget::requestFocus( QWidget*  Sender , QWidget*  FocusedWidget )
{
  if ((FocusPath != 0) && (FocusPath != Sender))
   {
      FocusPath->clearFocusPath();
   }
  FocusPath = Sender;
  Owner->requestFocus(this,FocusedWidget);
} // end of requestFocus()

//! changes the global drawing context
void QWidget::changeContext()
{
  glPushMatrix();
  glTranslatef(Left,Top,0.0);
} // end of changeContext()

//! restores the global drawing context
void QWidget::restoreContext()
{
  glPopMatrix();
} // end of restoreContext()

//! calls delete for every child widget
void QWidget::freeChildren()
{
  while (Children.size() > 0)
  {
    delete Children.front();
    Children.pop_front();
  }
} // end of freeChildren()

//! draws itself with OpenGL. Here is the OpenGL drawing code
void QWidget::draw( QEvent*  e )
{

} // end of draw()

//! layout the children widgets. This method is called every time the size is changed. Have to be overwritten for respond on size changes
void QWidget::layout()
{

} // end of layout()

//! have to return true if widget should be dragged with mouse. This method is overwritten in sub classes. If returns true, widget will be dragged
bool QWidget::canDrag( QEvent*  e )
{
 return false;
} // end of canDrag()

//! processing mouse/keyboard events which are in widgets region. Mouse coordinates are relative to Owner
bool QWidget::processEvent( QEvent*  e )
{
 return false;
} // end of processEvent()

//! processing mouse events which are in Owner widget region. Mouse coordinates are relative to Owner
bool QWidget::processMouseOwner( QEvent*  e )
{
 return false;
} // end of processMouseOwner()

//! called if a child is added/removed
void QWidget::childrenChanged()
{
} // end of childrenChanged()

//! defines whether control can have keyboard focus. Should return true if Widget wants to get keyboard focus
bool QWidget::canFocus( QEvent*  e )
{
 return false;
} // end of canFocus()

//! initialization code
void QWidget::Init()
{

} // end of Init()

//! clean up code
void QWidget::CleanUp()
{

} // end of CleanUp()

//! getter method for Width
int QWidget::getWidth()
{
return Width;
} // end of getWidth()

//! setter method for Width
void QWidget::setWidth( int  newValue )
{
 if (newValue < MinWidth) newValue = MinWidth;
 if (Width != newValue)
  {
    Width = newValue;
    layout();
    if (onResize!=0)   (*onResize)(this);
  }
} // end of setWidth()

//! getter method for Height
int QWidget::getHeight()
{
return Height;
} // end of getHeight()

//! setter method for Height
void QWidget::setHeight( int  newValue )
{
  if (newValue < MinHeight) newValue = MinHeight;
  if (Height != newValue)
  {
    Height = newValue;
    layout();
    if (onResize!=0)   (*onResize)(this);
  }
} // end of setHeight()

//! getter method for Top
int QWidget::getTop()
{
return Top;
} // end of getTop()

//! setter method for Top
void QWidget::setTop( int  newValue )
{
 if (Top != newValue)
 {
    Top  = newValue;
 }
} // end of setTop()

//! getter method for Left
int QWidget::getLeft()
{
return Left;
} // end of getLeft()

//! setter method for Left
void QWidget::setLeft( int  newValue )
{
  if (Left != newValue)
  {
    Left = newValue;
  }
} // end of setLeft()

//! getter method for MinWidth
int QWidget::getMinWidth()
{
return MinWidth;
} // end of getMinWidth()

//! setter method for MinWidth
void QWidget::setMinWidth( int  newValue )
{
MinWidth = newValue;
} // end of setMinWidth()

//! getter method for MinHeight
int QWidget::getMinHeight()
{
return MinHeight;
} // end of getMinHeight()

//! setter method for MinHeight
void QWidget::setMinHeight( int  newValue )
{
MinHeight = newValue;
} // end of setMinHeight()

//! getter method for ClientBorderLeft
int QWidget::getClientBorderLeft()
{
return ClientBorderLeft;
} // end of getClientBorderLeft()

//! setter method for ClientBorderLeft
void QWidget::setClientBorderLeft( int  newValue )
{
ClientBorderLeft = newValue;
} // end of setClientBorderLeft()

//! getter method for ClientBorderRight
int QWidget::getClientBorderRight()
{
return ClientBorderRight;
} // end of getClientBorderRight()

//! setter method for ClientBorderRight
void QWidget::setClientBorderRight( int  newValue )
{
ClientBorderRight = newValue;
} // end of setClientBorderRight()

//! getter method for ClientBorderTop
int QWidget::getClientBorderTop()
{
return ClientBorderTop;
} // end of getClientBorderTop()

//! setter method for ClientBorderTop
void QWidget::setClientBorderTop( int  newValue )
{
ClientBorderTop = newValue;
} // end of setClientBorderTop()

//! getter method for ClientBorderBottom
int QWidget::getClientBorderBottom()
{
return ClientBorderBottom;
} // end of getClientBorderBottom()

//! setter method for ClientBorderBottom
void QWidget::setClientBorderBottom( int  newValue )
{
ClientBorderBottom = newValue;
} // end of setClientBorderBottom()

//! getter method for Enabled
bool QWidget::getEnabled()
{
return Enabled;
} // end of getEnabled()

//! setter method for Enabled
void QWidget::setEnabled( bool  newValue )
{
Enabled = newValue;
} // end of setEnabled()

//! getter method for Visible
bool QWidget::getVisible()
{
return Visible;
} // end of getVisible()

//! setter method for Visible
void QWidget::setVisible( bool  newValue )
{
Visible = newValue;
} // end of setVisible()

//! getter method for LookAndFeel
QLookAndFeel* QWidget::getLookAndFeel()
{
return LookAndFeel;
} // end of getLookAndFeel()

//! setter method for LookAndFeel
void QWidget::setLookAndFeel( QLookAndFeel*  newValue )
{
LookAndFeel = newValue;
} // end of setLookAndFeel()

//! getter method for Owner
QWidget* QWidget::getOwner()
{
return Owner;
} // end of getOwner()

//! setter method for Owner
void QWidget::setOwner( QWidget*  newValue )
{
Owner = newValue;
} // end of setOwner()

//! getter method for FocusPath
QWidget* QWidget::getFocusPath()
{
return FocusPath;
} // end of getFocusPath()

//! setter method for FocusPath
void QWidget::setFocusPath( QWidget*  newValue )
{
  FocusPath = newValue;
} // end of setFocusPath()

// WARNING : The implementation of this method will be automatically generated with code generator.
// To prevent this add '//KEEP' at the first line of the implementation.(first line after '{')
//! prints itself to the cout
void QWidget::print()
{
//KEEP
cout << "Class : QWidget" << endl;
cout << "Width = " << Width << endl;
cout << "Height = " << Height << endl;
cout << "Top = " << Top << endl;
cout << "Left = " << Left << endl;
cout << "Enabled = " << Enabled << endl;
cout << "Visible = " << Visible << endl;
cout << "Owner = " << Owner << endl;
cout << "Children = " << Children.size() << endl;
} // end of print()

// WARNING : The implementation of this method will be automatically generated with code generator.
// To prevent this add '//KEEP' at the first line of the implementation.(first line after '{')
//! Constructor
 QWidget::QWidget( QWidget*  aOwner )
{
onResize = 0;
onCustomDraw = 0;
onKey = 0;
onMouseMove = 0;
onMouseUp = 0;
onMouseDown = 0;
onClick = 0;
DragStartX = 0;
DragStartY = 0;
Width = 20;
Height = 10;
Top = 0;if (aOwner) Top = aOwner->getClientBorderTop();
Left = 0;if (aOwner) Left = aOwner->getClientBorderLeft();
MinWidth = 0;
MinHeight = 0;
ClientBorderLeft = 0;
ClientBorderRight = 0;
ClientBorderTop = 0;
ClientBorderBottom = 0;
Enabled = true;
Visible = true;
Dragging = false;
LookAndFeel = 0;if (aOwner) LookAndFeel = aOwner->getLookAndFeel();
Owner = aOwner;if (aOwner) aOwner->add(this);
FocusPath = 0;
Init();
layout();
} // end of QWidget()

// WARNING : The implementation of this method will be automatically generated with code generator.
// To prevent this add '//KEEP' at the first line of the implementation.(first line after '{')
//! Destructor
 QWidget::~QWidget()
{
freeChildren();
CleanUp();
} // end of ~QWidget()

// end of implementation of QWidget

---