worker.cpp

Go to the documentation of this file.

#ifndef WORKER_IMPLEMENTATION_FILE
#define WORKER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : worker                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* 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                               *
\*****************************************************************************/

//hmmm: move to header.

//   attach()
//
//     Registers this worker with its manager (by adding the worker to a list
//     that is maintained by the manager).  This is a windowing system
//     independent call.  Until this is done, the manager will not know that
//     it should redraw the worker when it needs to redraw itself.
//
//   detach()
//
//     Disconnects this worker from the manager.
//
//   ask_for_dimensions()
//
//     Retrieves the size of the worker as the underlying windowing system
//     currently reports that size.  The size is returned in universal
//     coordinates.  This does not work until the object has been realized
//     on the screen.

#include "argument_list.h"
#include "worker.h"
#include "wp_implementation.h"

#include <basis/function.h>
#include <basis/guards.h>

worker::worker(manager &root, const c_rectangle &dim, window_handle a_self,
   const color &f, const color &b)
: nub(root.self(), a_self),
  drawable(dim.vertex_1(), f),
  _root(root),
  _background(b),
  _dimensions(dim)
{
  background(_background);
  foreground(f);
    // called because drawable does not add colors to the palette.
}

worker::worker(const worker &to_copy)
: nub(to_copy.parent(), to_copy.self()),
  drawable(to_copy),
  _root(to_copy._root),
  _background(to_copy._background),
  _dimensions(to_copy._dimensions)
{}

worker::~worker() { erase(); detach(); }

manager &worker::root() const { return _root; }

palette &worker::colormap() const { return _root; }

color worker::background() const { return _background; }

color worker::foreground() const { return drawable::foreground(); }

void worker::attach()
{
  FUNCDEF("attach");
  for (int i = 0; i < _root.contents.elements(); i++)
    if (_root.contents.get(i) == this) {
LOG("worker::attach: adding worker again!");
      return;
    }
  _root.contents.add(this);
}

void worker::detach()
{
  FUNCDEF("detach");
  if (!_root.contents.remove(this))
    LOG("worker::detach: not found in contents");
}

c_rectangle worker::dimensions() const { return _dimensions; }

void worker::draw()
{
  if (!visible()) {
    if (!realized()) {
      realize();
      foreground(_foreground);
      background(_background);
        // fg & bg called again in case no self() existed at construction time.
      if (self() && (_dimensions.vertex_1() == _dimensions.vertex_2()) )
        dimensions(ask_for_dimensions());
      else if (self()) dimensions(_dimensions);
      else non_continuable_error(class_name(), "draw", "worker's self is NIL");
      attach();
    } else map();
    engage();
    set_visible();
  }
}

void worker::erase()
{
  if (visible()) {
    disengage();
    unmap();
    set_invisible();
  }
}

void worker::foreground(const color &new_foreground)
{
  color fg(new_foreground);
  _root.add(fg);
  drawable::foreground(fg);
  if (self()) {
#ifdef __XWINDOWS__
    disengage();
    set_foreground(fg);
    engage();
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
  }
}

void worker::background(const color &new_background)
{
  color bg(new_background);
  _root.add(bg);
  _background = bg;
#ifdef __XWINDOWS__
  if (self()) {
    disengage();
    set_background(bg);
    engage();
  }
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

void worker::dimensions(const c_rectangle &new_size)
{
  _dimensions = new_size;
  disengage();
  device_dimensions(_root.universe_to_device(new_size));
  engage();
}

c_rectangle worker::ask_for_dimensions()
{
  c_rectangle dev_size(device_dimensions());
  c_rectangle fake_univ_dim(_root.device_to_universe(dev_size));
  fake_univ_dim -= fake_univ_dim.vertex_1();
  c_rectangle univ_dim(fake_univ_dim + drawable::origin());
  return univ_dim;
}

void worker::set_origin(const c_point &new_origin)
{
  c_rectangle new_dim(dimensions());
  new_dim -= drawable::origin();
  new_dim += new_origin;
  drawable::set_origin(new_origin);
  dimensions(new_dim);
}

#endif //WORKER_IMPLEMENTATION_FILE

---