---

BWidget.h

Go to the documentation of this file.

// BWidget.h (this is -*- C++ -*-)
// 
// \author: Bjoern Giesler <bjoern@giesler.de>
// 
// 
// 
// $Author: giesler $
// $Locker$
// $Revision$
// $Date: 2002-08-19 10:41:28 +0200 (Mon, 19 Aug 2002) $

#ifndef BWIDGET_H
#define BWIDGET_H

/* system includes */
#include <nds.h>
#include <vector>

/* my includes */
#include "BGraphics.h"
#include "BImage.h"
#include "BResponder.h"

class BFont;
class BScreen;

class BWidget: public BResponder {
public:
  typedef enum {
    STATE_DISABLED, 
    STATE_ENABLED,  
    STATE_SELECTED, 
    STATE_ACTIVE    
  } State;

  typedef enum {
    ROT_0 = 0,
    ROT_90 = 1,
    ROT_180 = 2,
    ROT_270 = 3
  } Rotation;

  typedef enum {
    DIR_LEFTTORIGHT = 0,
    DIR_TOPTOBOTTOM = 1,
    DIR_RIGHTTOLEFT = 2,
    DIR_BOTTOMTOTOP = 3
  } TextDirection;

  typedef enum {
    ALIGN_CENTER,
    ALIGN_LEFT,
    ALIGN_RIGHT
  } TextAlignment;

  typedef enum {
    RELIEF_NONE,   
    RELIEF_SIMPLE, 
    RELIEF_RAISED, 
    RELIEF_SUNKEN  
  } ReliefType;

  BWidget(BWidget* parent, const BRect& frame);
  virtual ~BWidget();

  const BRect& frame() const { return _frame; }
  virtual void setFrame(const BRect& frame);

  virtual State state() const { return _state; }
  virtual void setState(State state) { _state = state; _needsRedraw = true; }

  void setTag(int tag) { _tag = tag; }
  int tag() { return _tag; }
  
  virtual TextDirection textDirectionRelativeToScreen() const;
  virtual TextDirection textDirection() const { return _tdir; }
  virtual void setTextDirection(TextDirection dir) { _tdir = dir; _needsRedraw = true; }

  virtual Rotation rotation() const { return _rot; }
  virtual void setRotation(Rotation rot);
  virtual Rotation accumulatedRotation() const;

  inline BPoint transformUp(BPoint pt, bool global = true)
    const
  {
    BPoint pt1;
    switch(_rot) {
    case ROT_0:
      pt1.x = pt.x + _frame.pt.x;
      pt1.y = pt.y + _frame.pt.y;
      break;

    case ROT_90:
      pt1.x = _frame.pt.x - pt.y + _frame.sz.width;
      pt1.y = _frame.pt.y + pt.x;
      break;

    case ROT_180:
      pt1.x = _frame.pt.x - pt.x + _frame.sz.width;
      pt1.y = _frame.pt.y - pt.y + _frame.sz.height;
      break;
      
    case ROT_270:
      pt1.x = _frame.pt.x + pt.y;
      pt1.y = _frame.pt.y - pt.x + _frame.sz.height;
      break;
    }

    if(_parent && global)
      return _parent->transformUp(pt1);
    return pt1;
  }

  inline BPoint transformDown(const BPoint& pt, bool global = true)
    const
  {
    BPoint pt1 = pt, pt2;

    if(_parent && global)
      pt1 = _parent->transformDown(pt1);

    switch(_rot) {
    case ROT_0:
      pt2.x = pt1.x - _frame.pt.x;
      pt2.y = pt1.y - _frame.pt.y;
      break;

    case ROT_90:
      pt2.x = pt1.y - _frame.pt.y;
      pt2.y = _frame.pt.x + _frame.sz.width - pt1.x;
      break;

    case ROT_180:
      pt2.x = _frame.pt.x + _frame.sz.width - pt1.x;
      pt2.y = _frame.pt.y + _frame.sz.height - pt1.y;
      break;
      
    case ROT_270:
      pt2.x = _frame.pt.y + _frame.sz.height - pt1.y;
      pt2.y = pt1.x - _frame.pt.x;
      break;
    }

    return pt2;
  }

  inline BRect transformUp(const BRect& r, bool global = true)
    const
  {
    return BRect(transformUp(r.topLeft(), global),
                 transformUp(r.bottomRight(), global));
  }

  inline BRect transformDown(const BRect& r, bool global = true)
    const
  {
    return BRect(transformDown(r.topLeft(), global),
                 transformDown(r.bottomRight(), global));
  }
    
  TextAlignment textAlignment() const { return _align; }
  virtual void setTextAlignment(TextAlignment align);

  ReliefType reliefType() const { return _relief; }
  virtual void setReliefType(ReliefType relief);

  unsigned int vPadding() const { return _vpadding; }
  virtual void setVPadding(unsigned int padding);

  unsigned int hPadding() const { return _hpadding; }
  virtual void setHPadding(unsigned int padding);

  bool drawsDebugStuff() const { return _debug; }
  virtual void setDrawsDebugStuff(bool debug);


  virtual void draw(BImage& img);

  virtual void setNeedsRedraw(bool needs);

  virtual bool needsRedraw();

  virtual bool isShown() {
    if(_parent) return _parent->isShown() && _shown;
    return _shown;
  }
  virtual void hide() { _shown = false; }
  virtual void show();

  uint16 backgroundColor() const { return _bgcolor; }
  virtual void setBackgroundColor(uint16 color, bool recursive = false);

  uint8 backgroundAlpha() const { return _bgalpha; }
  virtual void setBackgroundAlpha(uint8 alpha);
  
  uint8 widgetAlpha() const { return _widgetalpha; }
  virtual void setWidgetAlpha(uint8 alpha);

  BFont *font() const { return _font; }
  virtual void setFont(BFont* font);

  uint16 textColor() { return _textcolor; }
  virtual void setTextColor(uint16 color, bool recursive = false);

  uint16 selectedTextColor() { return _selectedtextcolor; }
  virtual void setSelectedTextColor(uint16 color);

  void handleEvent(const BEvent& event);


  std::vector<BWidget*>& children() { return _children; }

  bool deletesChildren() { return _deleteChildren; }
  void setDeletesChildren(bool yesno) { _deleteChildren = yesno; }
  void deleteChildren();

  BWidget* parent() { return _parent; }

  BScreen* screen();
  void setScreen(BScreen* screen);

protected:
  std::vector<BWidget*> _children;
  virtual void addChild(BWidget* w);
  virtual void removeChild(BWidget* w);
  
  BRect _frame;
  ReliefType _relief;
  unsigned int _vpadding, _hpadding;
  uint16 _bgcolor;
  uint16 _textcolor, _selectedtextcolor;
  uint8 _bgalpha;
  uint8 _widgetalpha;
  bool _needsRedraw;
  bool _debug;
  bool _shown;

  BFont *_font;
  BWidget *_parent;
  BScreen *_screen;

  State _state;
  TextDirection _tdir;
  Rotation _rot;
  TextAlignment _align;
  int _tag;
  bool _deleteChildren;
};

#endif /* BWIDGET_H */

---