canvas.cpp

Go to the documentation of this file.

#ifndef CANVAS_IMPLEMENTATION_FILE
#define CANVAS_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : canvas                                                            *
*  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 "box.h"
#include "canvas.h"
#include "drawable.h"
#include "picture.h"
#include "wp_implementation.h"

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

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

canvas::canvas(manager &root, const c_rectangle &position,
    const c_rectangle &initial_world, const color &foreground,
    const color &background, origin_vertex world_corner)
: worker(root, position, create_canvas_handle(root, position.vertex_1()),
      foreground, background),
  c_rectangle_warper(position, initial_world, root.universe_corner(),
      world_corner),
  _details(root.self()),
  contents(c_point(0, 0))
{
  FUNCDEF("constructor");
#ifdef __XWINDOWS__
  dimensions(position);
LOG("before creating XOR gc");
  // _details._gc = create_exclusive_or_GC(self());
LOG("after creating XOR gc");
  XtAddCallback
    (self(), XmNresizeCallback, XtCallbackProc(resizer), XtPointer(this));
  XtAddCallback
    (self(), XmNexposeCallback, XtCallbackProc(exposer), XtPointer(this));
  XtAddCallback
    (self(), XmNinputCallback, XtCallbackProc(inputer), XtPointer(this));
LOG("after adding callbacks");
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

canvas::~canvas()
{
#ifdef __XWINDOWS__
  XtRemoveCallback
    (self(), XmNresizeCallback, XtCallbackProc(resizer), XtPointer(this));
  XtRemoveCallback
    (self(), XmNexposeCallback, XtCallbackProc(exposer), XtPointer(this));
  XtRemoveCallback
    (self(), XmNinputCallback, XtCallbackProc(inputer), XtPointer(this));
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

c_rectangle canvas::world() const { return system_2(); }

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

void canvas::redraw() { redraw_part(system_1()); }

int canvas::elements() { return contents.elements(); }

void canvas::add(drawable *to_add) { contents.add(to_add); }

void canvas::remove(drawable *to_add) { contents.remove(to_add); }

void canvas::update() { contents.update(); }

resources &canvas::details() { return _details; }

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

c_point canvas::world_to_device(const c_point &in_world) const
  { return world_to_device(c_rectangle(in_world, in_world)).vertex_1(); }

c_point canvas::device_to_world(const c_point &in_device) const
  { return device_to_world(c_rectangle(in_device, in_device)).vertex_1(); }

window_handle canvas::create_canvas_handle(manager &root, const c_point &origin)
{
  argument_list wargs;
  add_origin(wargs, root.universe_to_device(origin));
  return XtCreateManagedWidget
    ("canvas", xmDrawingAreaWidgetClass, root.self(),
     wargs.generate(), wargs.number());
}

void canvas::exposer(window_handle, canvas *me, XmAnyCallbackStruct *parms)
{
  FUNCDEF("exposer");
  XExposeEvent *event = (XExposeEvent *)parms->event;
  c_rectangle dev_to_redraw(event->x, event->y, event->x + event->width,
      event->y + event->height);
  c_rectangle to_redraw(me->device_to_world(dev_to_redraw));
LOG(istring("<expose> on dev ") + dev_to_redraw.text_form() + " and world " + to_redraw.text_form() + ".");
  me->redraw_part(to_redraw);
}

void canvas::inputer(window_handle, canvas *formal(me), XmAnyCallbackStruct *formal(parms))
{
  FUNCDEF("inputer");
LOG("<inputer>");
}

void canvas::resizer(window_handle, canvas *me, XmAnyCallbackStruct *formal(parms))
{
  FUNCDEF("resizer");
LOG("<resizer>");
  argument_list wargs;
  int width, height, x, y;
  wargs.add(XtNx, XtArgVal(&x));
  wargs.add(XtNy, XtArgVal(&y));
  wargs.add(XtNwidth, XtArgVal(&width));
  wargs.add(XtNheight, XtArgVal(&height));
  XtGetValues(me->self(), wargs.generate(), wargs.number());

  c_rectangle new_position
    (me->root().device_to_view(c_rectangle(x, y, x+width, y+height)));
  me->dimensions(new_position);
//LOG(istring(" called on ") + new_position.text_form());
  me->redraw();
}

c_rectangle canvas::world_to_device(const c_rectangle &in_world) const
{
  c_rectangle in_univ(to_system_1(in_world));
  c_rectangle in_dev(root().universe_to_device(in_univ));
  c_rectangle relative
    (in_dev - root().universe_to_device(dimensions()).vertex_1());
  return relative;
}

c_rectangle canvas::device_to_world(const c_rectangle &in_device) const
{
  c_rectangle relative
    (in_device + root().universe_to_device(dimensions()).vertex_1());
  c_rectangle in_univ(root().device_to_universe(relative));
  c_rectangle in_world(to_system_2(in_univ));
  return in_world;
}


#endif //CANVAS_IMPLEMENTATION_FILE

---