manager.h

Go to the documentation of this file.

#ifndef MANAGER_CLASS
#define MANAGER_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : manager                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Manages the details involved in starting up the window manager that      *
*  supports the windows parts library.                                        *
*                                                                             *
*******************************************************************************
* 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                               *
\*****************************************************************************/

#include "desktop.h"
#include "nub.h"
#include "palette.h"
#include "picture.h"

#include <geometric/cartesian_objects.h>

const c_rectangle default_universe = c_rectangle(0, 0, 1000, 1000);
  // The default universe coordinate system has an origin at (0,0) and the
  // opposite corner is 1000 units to the right and 1000 units upward from it.

const c_rectangle default_desktop_view = c_rectangle(0, 0, 100, 100);
  // The initial view of the desktop as seen by the manager.

const c_rectangle default_manager_size = c_rectangle(10, 10, 90, 90);
  // The default_size for the manager in desktop_view coordinates.

class WP_PASSIVE_CLASS_STYLE manager
: public drawable, public c_rectangle_warper, public nub,
  public desktop, public palette
{
public:
  manager(const istring &name,
          const c_rectangle &initial_universe = default_universe,
          const c_rectangle &initial_view = default_desktop_view,
          const c_rectangle &initial_size = default_manager_size,
          const color &foreground = colors::WHITE,
          const color &background = colors::BLACK,
          origin_vertex view_corner = BOTTOM_LEFT,
          origin_vertex universe_corner = BOTTOM_LEFT);
    // Once a manager is constructed, windowing objects can be created and
    // attached to it.  Multiple managers may be used within one program.
    // The "name" is the application name.  The argument array "argv" will be
    // destructively manipulated by the initialization function.  The initial
    // universal coordinates are represented by "initial_universe", where an
    // implicit ordering is used to define the coordinate system: the first
    // vertex of the rectangle is the origin, while the second is the extent
    // of the universal coordinates away from that origin. All objects
    // connected to this manager are described in the universal coordinates.
    // The "initial_size" is how large the root window will be initially
    // (measured in the desktop view coordinates).

  ~manager();
    // Shuts down the window manager.

  IMPLEMENT_CLASS_NAME("manager");

  void poll();
    // Causes the window system to go into interactive mode where only user
    // requests are processed.  When the system is in this mode, event
    // functions and callbacks are the only active functions.  The system will
    // not return control to the invoker of poll until the user asks for a
    // system shutdown (which causes some function to invoke the shut_down
    // method on this class) or until the system shuts down due to a fatal
    // error.

  bool poll_and_return(int maximum_events);
    // Causes the window system to process as many underlying windowing system
    // events as are available (to the maximum of "maximum_events"), but does
    // not wait if no events are ready.  If the windowing system is still
    // alive, then true is returned.

  void shut_down();
    // Causes the manager to stop polling and close down the program.

  c_rectangle universe() const;
  origin_vertex universe_corner() const;
    // The universe is how the internal span of pixels contained in the manager
    // is represented to objects that are placed on the manager.

  virtual void draw();
  virtual void erase();

  istring name() const;
  void name(const istring &new_name);
    // Observes or modifies the title of the canvas.

  c_rectangle dimensions() const;
  void dimensions(const c_rectangle &new_location);
    // Observes or modifies the manager's size (in desktop view coordinates).

  // The "device" coordinates below are relative to the origin of the manager.
  // If one has been passed a point in absolute device coordinates, then
  // these functions can be used if the origin for this manager (in device
  // coordinates) is subtracted from it.  (the safe way to do this is:
  //   devcoord - mang.view_to_device(mang.dimensions()).vertex_1();
  // because the origin may be interpreted differently by the device.)
  c_point universe_to_device(const c_point &in_universe) const;
  c_point device_to_universe(const c_point &in_device) const;

  c_rectangle universe_to_device(const c_rectangle &in_universe) const;
  c_rectangle device_to_universe(const c_rectangle &in_device) const;

  virtual void redraw_part(const c_rectangle &to_redraw);
    // Causes the portion of the manager that intersects with the rectangle
    // (in universal coordinates) to be redrawn.

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

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

  c_point text_size(const istring &to_measure);
    // Returns the size of a character string in universal coordinates.

private:
  c_point _origin;
  picture contents;
  bool die;
  color _background;
  friend class worker;
  istring _name;
 
  window_handle nub_init(const istring &name);
  bool realize(bool to_flow, const c_rectangle &initial_size);
};

#endif

---