worker.h

Go to the documentation of this file.

#ifndef WORKER_CLASS
#define WORKER_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : worker                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    A worker object can be displayed on a manager object.                    *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

// Description:
//
//   Each worker has an origin.  An origin serves as both: (a) an internal
//   reference point that each part of the worker is located in relation
//   to, and (b) the point on the parent where the worker starts.  The
//   value held in "origin()" is (b), while that origin's location on the
//   parent is considered as the (0, 0) for the internal origin (a).

#include "argument_list.h"
#include "drawable.h"
#include "manager.h"

class WP_PASSIVE_CLASS_STYLE worker : public nub, public drawable
{
public:
  worker(manager &root, const c_rectangle &dimensions, window_handle self = NIL,
          const color &foreground = colors::WHITE, const color &background = colors::BLACK);
    // The "self" is used when the worker's underlying window object can be
    // constructed along with the worker, and "self" should contain the handle
    // of that object.  The "dimensions" are used to set the size of the
    // worker, if that is possible.  if the vertices of dimensions are
    // identical, then the underlying windowing system must determine the size
    // of the worker.

  virtual ~worker();

  IMPLEMENT_CLASS_NAME("worker");

  virtual void draw();
    // This function places the worker on the screen.  The default function
    // makes the window_handle visible on the screen and then calls
    // set_visible().  The worker::draw() function should at least be called
    // by virtual draw functions for these actions.
  virtual void erase();
    // This function removes the worker from the screen.  The default
    // function checks to make sure the object is "visible()", then it
    // unmaps the window_handle and calls "set_invisible()".  If the object
    // was not visible (i.e., the set_visible function was not called), then
    // the object is not erased.  If a virtual "erase" function is provided
    // in a derived class, it should also call the worker erase function or
    // at least mimic the functionality (by calling "set_invisible").

  virtual c_rectangle dimensions() const;
  virtual void dimensions(const c_rectangle &new_location);
    // Observes or modifies the worker's size (in universal coordinates).

  palette &colormap() const;
    // Accesses this worker's manager's palette.
  manager &root() const;
    // Accesses the parent of this worker.

  color foreground() const;
  virtual void foreground(const color &new_foreground);
    // Observes or modifies the foreground color of the worker.  The color
    // is returned by the modifier after being added to the colormap.

  color background() const;
  virtual void background(const color &new_background);

  virtual void set_origin(const c_point &new_origin);
    // sets a new origin for the worker.  this is virtual to allow more
    // complicated objects to adapt themselves to the new origin.

private:
  manager &_root;
  color _background;
  c_rectangle _dimensions;

  c_rectangle ask_for_dimensions();
  worker(const worker &to_copy);
  worker &operator =(const worker &to_copy);

  void attach();
  void detach();
};

#endif

---