manager.cpp

Go to the documentation of this file.

#ifndef MANAGER_IMPLEMENTATION_FILE
#define MANAGER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : manager                                                           *
*  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                               *
\*****************************************************************************/

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

#include <basis/function.h>
#include <basis/guards.h>
#include <geometric/warper.cpp>

#include <stdlib.h>

#ifdef __XWINDOWS__
  #include <Xm/DrawingA.h>
  #include <Xm/BulletinB.h>
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif

manager::manager(const istring &named, const c_rectangle &universe,
   const c_rectangle &deskview, const c_rectangle &initial_size,
   const color &f, const color &b, origin_vertex desktop_corner,
   origin_vertex univ_corner)
: drawable(initial_size.vertex_1(), f),
  c_rectangle_warper(universe, initial_size, univ_corner, desktop_corner),
  nub(nub_init(named), NIL),
  desktop(parent(), deskview, desktop_corner),
  palette(realize(true, initial_size)? parent() : parent()),
  _origin(initial_size.vertex_1()),
  contents(c_point(0, 0)),
  die(false),
  _background(b)
{
  // adjust the background color to the available color set.
  add(_background);
  // adjust the foreground color also.
  color fore = foreground(); add(fore); foreground(fore);
  draw();
  dimensions(initial_size);
  name(named);
}

manager::~manager()
{
//  contents.erase();
  erase();

#ifdef __XWINDOWS__
  Display *display_to_shut_down(display());
  XtDestroyWidget(parent());
  XtCloseDisplay(display_to_shut_down);
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

void manager::shut_down() { die = true; }

c_rectangle manager::dimensions() const { return system_2(); }

c_rectangle manager::universe() const { return system_1(); }

c_rectangle_warper::origin_vertex manager::universe_corner() const { return origin_1(); }

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

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

istring manager::name() const { return _name; }

window_handle manager::nub_init(const istring &formal(name))
{
#ifdef __XWINDOWS__
  window_handle to_return = XtInitialize(__argv[0], "manager", NIL, 0,
      &__argc, __argv);
  return to_return;
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

void manager::name(const istring &new_name)
{
  _name = new_name;
/*
  XTextProperty to_send;
  to_send.value = (unsigned char *)(char *)new_name;
  to_send.encoding = STRING;
  to_send.nitems = 1;
  XSetWMName(display(), window(), &to_send);
*/
  argument_list wargs;
  wargs.add((char *)"*title", new_name);
  wargs.apply(parent());
}

bool manager::realize(bool to_flow, const c_rectangle &size)
{
#ifdef __XWINDOWS__
  argument_list wargs;
  add_dimensions(wargs, view_to_device(size));
    // the dimensions are added here before calling dimensions in the
    // assignment section of the constructor to keep the window showing
    // up with a different size than intended initially.  the manager's
    // dimensions call cannot be used in centerline since it's virtual.
  self(XtCreateManagedWidget
       ("layout_holder", xmBulletinBoardWidgetClass, parent(),
       wargs.generate(), wargs.number()));
  XtRealizeWidget(parent());
  wargs.apply(parent());
    // X seems to like getting them again.  probably some option like don't
    // autoplace the window needs to be set in wargs, because the origin
    // is being ignored otherwise.
  nub::realize();
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
  return to_flow;
}

void manager::poll()
{
  while (!die) {
#ifdef __XWINDOWS__
    XEvent event; XtNextEvent(&event); XtDispatchEvent(&event);
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
  }
}

bool manager::poll_and_return(int maximum_events)
{
  if (die) return false;
#ifdef __XWINDOWS__
  XEvent event;
  while (maximum_events-- >= 0) {
    if (!XtPending()) break;
//LOG("x event supposedly pending");
    XtNextEvent(&event);
    XtDispatchEvent(&event);
    if (die) break;
//LOG("after x event dispatched");
  }
  return die? false : true;
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

void manager::dimensions(const c_rectangle &new_size)
{
  _origin = new_size.vertex_1();
  system_2(new_size, origin_2());
  { 
    c_rectangle in_dev(view_to_device(new_size));
    nub temp(parent(), parent());
      // safe due to UNSPOKEN policy in nub of not zapping widget for
      // parent and self equal.
    temp.device_dimensions(in_dev);
  }
  {
    argument_list wargs;
    c_rectangle bull_dim(universe());
    bull_dim = universe_to_device(bull_dim);
    add_dimensions(wargs, bull_dim);
    disengage();
    wargs.apply(self());
    engage();
  }
}

void manager::draw()
{
  if (!visible()) {
#ifdef __XWINDOWS__
    if (!realized()) nub::realize();
    else XMapWindow(display(), window());
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
    set_visible();
  }
  redraw_part(dimensions());
}

void manager::erase()
{
  if (visible()) {
#ifdef __XWINDOWS__
    XUnmapWindow(display(), window());
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
    set_invisible();
  }
}

void manager::redraw_part(const c_rectangle &to_redraw)
  { contents.draw_intersecting(to_redraw); }

c_point manager::universe_to_device(const c_point &in_universe) const
{
  return universe_to_device(c_rectangle(in_universe, in_universe)).vertex_1();
}

c_point manager::device_to_universe(const c_point &in_device) const
{
  return device_to_universe(c_rectangle(in_device, in_device)).vertex_1();
}

c_rectangle manager::universe_to_device(const c_rectangle &in_universe) const
{
  c_rectangle in_view(to_system_2(in_universe));
  c_rectangle in_dev(view_to_device(in_view));
  c_rectangle relative(in_dev - view_to_device(dimensions()).vertex_1());
    // the entire dimensions rectangle is converted to make sure we get
    // the right orientation of the origin's vertex.
  return relative;
}

c_rectangle manager::device_to_universe(const c_rectangle &in_device) const
{
  c_rectangle in_view
    (device_to_view(in_device + view_to_device(dimensions()).vertex_1()));
  c_rectangle in_univ(to_system_1(in_view));
  return in_univ;
}

// ARGH!  fonts in x windows are a maze.

#ifdef __XWINDOWS__
c_point manager::text_size(const istring &to_measure)
{
  FUNCDEF("text_size");
LOG("in text size");
  XFontStruct *font = XLoadQueryFont(display(), "lucidasans-bold-10");
  if (!font) non_continuable_error(class_name(), "text_size", "font not loaded");
LOG("textsize queried.");
  XmFontList fonts = XmFontListCreate(font, (char *)"manager_fonts");
  if (!fonts) non_continuable_error(class_name(), "text_size", "font list not created");
LOG("textsize created.");
  Dimension width, height;
LOG("textsize dimmed.");
  system_string to_meas(to_measure);
  XmStringExtent(fonts, to_meas, &width, &height);
LOG("textsize string extented.");
  return c_point(width, height);
}
#endif

void manager::foreground(const color &new_foreground)
{
  color fg(new_foreground);
  add(fg);
  drawable::foreground(fg);
  set_foreground(fg);
}

void manager::background(const color &new_background)
{
  color bg(new_background);
  add(bg);
  _background = bg;
  set_background(bg);
}


#endif //MANAGER_IMPLEMENTATION_FILE

---