nub.cpp

Go to the documentation of this file.

#ifndef NUB_IMPLEMENTATION_FILE
#define NUB_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : nub                                                               *
*  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 "color.h"
#include "nub.h"
#include "wp_implementation.h"

#include <basis/guards.h>

#include <X11/IntrinsicP.h>

nub::nub(window_handle parent, window_handle w)
#ifdef __XWINDOWS__
: i_am_realized(false), _parent(parent), _self(w)
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
{ if (!parent) non_continuable_error("nub", "nub", "my parent cannot be NIL"); }

nub::~nub()
{ if ( (_parent != _self) && _self) XtDestroyWidget(_self); }

window_handle nub::parent() const { return _parent; }

window_handle nub::self() const { return _self; }

void nub::parent(window_handle w)
{
  if (!w) non_continuable_error("nub", "parent set", "my parent cannot be NIL");
  _parent = w;
}

void nub::self(window_handle w) { _self = w; }

#ifdef __XWINDOWS__

bool nub::realized() const { return i_am_realized; }

void nub::map() { XMapWindow(display(), window()); }

void nub::unmap() { XUnmapWindow(display(), window()); }

c_rectangle nub::device_dimensions() const
{
  if (!_self) non_continuable_error("nub", "device_dimensions", "NIL self");
  argument_list wargs;
  int x, y, width, height;
  wargs.add(XtNx, XtArgVal(&x));
  wargs.add(XtNy, XtArgVal(&y));
  wargs.add(XtNwidth, XtArgVal(&width));
  wargs.add(XtNheight, XtArgVal(&height));
  XtGetValues(_self, wargs.generate(), wargs.number());
  return c_rectangle(c_point(x, y), c_point(x, y) + c_point(width, height));
}

Display *nub::display()
{
  if (!_self) non_continuable_error("nub", "display", "NIL self");
  return XtDisplay(_self);
}

Window nub::window()
{
  if (!_self) non_continuable_error("nub", "window", "NIL self");
  return XtWindow(_self);
}

Visual *nub::visual()
{
  if (!_self) non_continuable_error("nub", "visual", "NIL self");
  return DefaultVisual(display(), screen());
}

int nub::screen()
{
  if (!_self) non_continuable_error("nub", "visual", "NIL self");
  return DefaultScreen(display());
}

void nub::disengage()
{
  if (!_self) non_continuable_error("nub", "disengage", "NIL self");
  XtUnmanageChild(_self);
}

void nub::engage()
{
  if (!_self) non_continuable_error("nub", "engage", "NIL self");
  XtManageChild(_self);
}

void nub::device_dimensions(const c_rectangle &initial_size)
{
  c_rectangle init_size(initial_size.order());
    // order in case someone is confused about vertices and origin.
  if (!_self) non_continuable_error("nub", "device_dimensions set", "NIL self");
  XtMoveWidget(_self, short(init_size.vertex_1().x()),
      short(init_size.vertex_1().y()));
  if (init_size.vertex_1() != init_size.vertex_2())
    XtResizeWidget(_self, (unsigned short)init_size.width(), 
       (unsigned short)init_size.height(), 1);
}

void nub::add_origin(argument_list &wargs, const c_point &origin)
{ wargs.add(XmNx, int(origin.x())); wargs.add(XmNy, int(origin.y())); }

void nub::add_dimensions(argument_list &wargs, const c_rectangle &initial_size)
{
  c_rectangle init_size(initial_size.order());
  c_point origin(init_size.vertex_1());
  add_origin(wargs, origin);
  int width = int(init_size.width());
  int height = int(init_size.height());
  if (width < 1) width = 1;
  if (height < 1) height = 1;
  wargs.add(XmNwidth, width);
  wargs.add(XmNheight, height);
}

void nub::realize()
{
  if (!_self) non_continuable_error("nub", "realize", "NIL self");
  if (!i_am_realized) {
// XtMoveWidget(_self, 9999, 9999);
// needs to be done from perspective of more reasonable construction.
    XtRealizeWidget(_self);
    i_am_realized = true;
  }
}

void nub::set_foreground(const color &new_foreground)
{
  argument_list wargs;
  wargs.add(XmNforeground, new_foreground.index());
  wargs.apply(self());
}

void nub::set_background(const color &new_background)
{
  argument_list wargs;
  wargs.add(XmNbackground, new_background.index());
  wargs.apply(self());
}

#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif


#endif //NUB_IMPLEMENTATION_FILE

---