ccomponent.h

Go to the documentation of this file.

#ifndef CCOMPONENT_H
#define CCOMPONENT_H

#include <string>
#include <list>

#include "citerator.h"
#include "cevent.h"
#include "cvideo.h"
#include "cfont.h"

class ITickable {
public:
  virtual void tick(unsigned long time) = 0;
};

class CModel;

class IObserver {
protected:
  IObserver() { }
public:
  virtual ~IObserver() { }

  virtual void update(CModel *model) = 0;
};

class CModel {
protected:
  std::list<IObserver *> observers;

public:
  virtual void attach(IObserver *o) { observers.push_back(o); o->update(this); }

  virtual void detach(IObserver *o) { observers.remove(o); }

  virtual void notify() {
    for (std::list<IObserver *>::iterator i = observers.begin(); i != observers.end(); i++) {
      (*i)->update(this);
    }
  }
};

class CComponent {
private:
  int is_visible;

protected:
  CComponent *parent;

  /* The component's bounding rectangle, in absolute coordinates. */
  CRect absolute_bounding_rect;

  /* The component's bounding rectangle, in local coordinates. */
  CRect local_bounding_rect;

  virtual void do_draw(CSurface &surface, CRect &rect) { }

  virtual int do_handle_event(CEvent &event) { return 0; }

  CComponent(CComponent &copy);
  virtual void add_dirty_rect(const CRect &r) { if (parent) parent->add_dirty_rect(r); }

  /* Should only be called by a child on its parent when its position changes, or by
     a parent on its children when its position changes. */
  void update_absolute_pos(CComponent *child) {
    child->set_absolute_pos(get_absolute_bounding_rect().pos + child->get_pos());
  }

  /* Invalidate's the component's current bounding rectangle by telling
     the parent to redraw this area of the surface. */
  void invalidate() { add_dirty_rect(get_absolute_bounding_rect()); }

public:
  CComponent() : is_visible(1), parent(0) { }
  virtual ~CComponent() { }

  void redraw() { invalidate(); }

  int visible() { return is_visible; }

  void set_visible(int visibility) {
    if (is_visible != visibility) {
      is_visible = visibility;
      invalidate();
    }
  }

  virtual void draw(CSurface &surface, CRect &rect) {
    if (is_visible && rect.intersects_with(get_absolute_bounding_rect())) {
      do_draw(surface, rect);
    }
  }

  virtual int handle_event(CEvent &event) { return do_handle_event(event); }

  virtual void set_pos(const CPoint &pos) {
    //if (get_pos() == pos) return;
    invalidate();
    /* \todo make this a template method? */
    local_bounding_rect.pos = pos;
    if (parent) parent->update_absolute_pos(this);
    redraw();
  }

  virtual void set_absolute_pos(const CPoint &pos) {
    absolute_bounding_rect.pos = pos;
  }

  void set_size(CPoint &size) {
    invalidate();
    /* \todo make this a template method? */
    local_bounding_rect.size = absolute_bounding_rect.size = size;
    redraw();
  }

  const CPoint &get_size() {
    return local_bounding_rect.size;
  }

  void set_bounding_rect(CRect &rect) {
    set_pos(rect.pos);
    set_size(rect.size);
  }

  const CPoint &get_absolute_pos() {
    return absolute_bounding_rect.pos;
  }

  const CPoint &get_pos() {
    return local_bounding_rect.pos;
  }

  const CRect &get_absolute_bounding_rect() {
    return absolute_bounding_rect;
  }

  void set_parent(CComponent *n_parent) { this->parent = n_parent; }
};

typedef std::deque<CComponent *> CComponentList;

class CPanel : public CComponent {
protected:
  /* The panel's children components. */
  CComponentList children;

public:
  virtual ~CPanel() {  }

  virtual void draw(CSurface &surface, CRect &rect);

  virtual int handle_event(CEvent &event);

  void add(CComponent &c) {
    c.set_parent(this);
    children.push_front(&c);
    update_absolute_pos(&c);
    c.redraw();
  }

  virtual void set_pos(const CPoint &pos);

  virtual void set_absolute_pos(const CPoint &pos);
};

class CColoredPanel : public CPanel {
private:
  CColor color;

public:
  CColoredPanel(CRect &bounding_rect, CColor color) : color(color) {
    set_bounding_rect(bounding_rect);
  }

  void set_color(CColor color) {
    this->color = color;
    redraw();
  }

  virtual void do_draw(CSurface &surface, CRect &rect) {
    surface.fill_rect(get_absolute_bounding_rect(), color);
  }
};

class CTextLabel : public CComponent {
private:
  /* The label's text. */
  std::string text;

  /* The label's font. */
  CFont *font;

public:
  virtual ~CTextLabel() { }

  CTextLabel(std::string str, CPoint &pos, CFont *font) : font(font) {
    set_pos(pos);
    set_text(str);
  }

  void set_text(std::string str) {
    text = str;

    CPoint new_size(font->get_string_size(text.c_str()));

    set_size(new_size);
  }

  virtual void do_draw(CSurface &surface, CRect &rect) {
    //printf("drawing string: '%s'\n", text.c_str());
    font->draw_string(&surface, get_absolute_pos(), text.c_str());
  }
};

#endif

---