shared_code.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : shared code                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1995-$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 "implem_only.h"
#include "shared_code.h"
#include "shared_code.rh"

#include <geometric/rectangle.cpp>
#include <rpc_ext/rpc_common.h>

#include <rpc.h>

using namespace geometric;

MIDL_ALLOC;

const int RPC_TIMER_ID = WM_USER + 2005;


BEGIN_MESSAGE_MAP(drawing_window, CView)
  //{{AFX_MSG_MAP(drawing_window)
  ON_WM_CLOSE()
  ON_WM_TIMER()
  ON_WM_LBUTTONDOWN()
  ON_WM_PAINT()
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


drawing_window::drawing_window(mouserciser &_mouse_alert)
: CView(),
  my_parent(NIL),
  alert(NIL),
  mouse_alert(_mouse_alert),
  mice(0),
  dot_size(5, 5),
  locker(1, 1),
  locking_mode(false)
{}

drawing_window::~drawing_window()
{}

bool drawing_window::Create(CFrameWnd *parent, const istring &title,
    window_handle _alert, bool locking)
{
  my_parent = parent;
  alert = _alert;
  locking_mode = locking;
  RECT cli;
  parent->GetClientRect(&cli);
  if (!CView::Create(NIL, title.s(), WS_CHILD, cli, parent, 0)) return false;
  ShowWindow(SW_RESTORE);
  UpdateWindow();
  return true;
}

void drawing_window::lock()
{
  if (!locking_mode) return;
  locker.wait();
}

void drawing_window::unlock()
{
  if (!locking_mode) return;
  locker.signal();
}

void drawing_window::be_gone() { ShowWindow(SW_HIDE); }

int drawing_window::length()
{
  int to_return;
  lock();
  to_return = mice.length();
  unlock();
  return to_return;
}

void drawing_window::get_mouse_list(array<rpc_point> &to_stuff)
{ lock(); to_stuff = mice; unlock(); }

void drawing_window::start_timer(UINT interval)
{ stop_timer(); SetTimer(RPC_TIMER_ID, interval, NIL); }

void drawing_window::stop_timer() { KillTimer(RPC_TIMER_ID); }

void drawing_window::OnClose() { stop_timer(); CView::OnClose(); }

void drawing_window::OnLButtonDown(UINT nFlags, CPoint point)
{
  CView::OnLButtonDown(nFlags, point);
  rpc_point posn(point.x, point.y);  // converted.
  screen_point middle(posn.x(), posn.y());
  screen_rectangle dotsize(middle - dot_size, middle + dot_size);
  // just update the display without invalidating to cause a redraw.  the
  // actual list entry for this dot will come from the server.
  CDC *dc = GetDC();
  RECT r = dotsize;
  dc->Ellipse(&r);
  mouse_alert.mouse_hit(posn);  // notify the parent of a new dot.
}

void drawing_window::OnDraw(CDC *pDC) { CView::OnDraw(pDC); }

void drawing_window::OnPaint()
{
  FUNCDEF("OnPaint");
  if (GetUpdateRect(NIL)) {
    PAINTSTRUCT paint_info;
    CDC *dc = BeginPaint(&paint_info);

    array<rpc_point> temp_list;
    get_mouse_list(temp_list);
      // grab the current list; since the accessor function locks the semaphore,
      // we don't have to.
    for (int i = 0; i < temp_list.length(); i++) {
      // calculate whether this point intersects with the update region.
      screen_point mickey(temp_list[i].x(), temp_list[i].y());
      screen_rectangle dotsize(mickey - dot_size, mickey + dot_size);
      // draw a tasty ellipse if the dot intersected us.
      screen_rectangle rect = paint_info.rcPaint;
      if (rect.intersect(dotsize)) {
        RECT r = dotsize;
        dc->Ellipse(&r);
      }
    }

    EndPaint(&paint_info);
  }
}

void drawing_window::OnTimer(u_int formal(timer_id))
{
  FUNCDEF("OnTimer");
  stop_timer();  // zap it because we've hit the update.
  LOG("timer hit, doing update.");
  mouse_alert.update();
}

void drawing_window::set_mouse_list(const array<rpc_point> &new_mice)
{
  lock();
  mice = new_mice;
  unlock();
  
  RECT r;
  GetClientRect(&r);
  InvalidateRect(&r);
}

void drawing_window::add_dot(const rpc_point &draw_at)
{
  lock();
  mice.concatenate(draw_at);
  unlock();
  screen_point middle(draw_at.x(), draw_at.y());
  screen_rectangle dotsize(middle - dot_size, middle + dot_size);
  RECT temp = dotsize;
  InvalidateRect(&temp);
}

void drawing_window::pull_out_mice(const byte_array &received,
    array<rpc_point> &original)
{
  original.reset();
  if (received.length() < 2) return;  // check format.
  u_int num_mice = received.get(0) * 0x100 + received.get(1);
  if (num_mice == 0) return;  // check number of points.
  original.reset(num_mice, (rpc_point *)&(received.get(2)));
    // suck in the mice points, but skip the chunk with the size.
}

void drawing_window::push_in_mice(const array<rpc_point> &mice,
    byte_array &to_stuff)
{
  to_stuff.reset();
  // to_stuff gets the # of mice first.
  to_stuff += byte(mice.length() / 0x100);
  to_stuff += byte(mice.length() % 0x100);
  if (mice.length()) {
    // now we calculate the necessary size for the number of points we have.
    int list_size = sizeof(rpc_point) * mice.length();
    // the array is adjusted to the proper size.
    to_stuff.insert(2, list_size);
    // now a simple copy of the mouse list and we're done.
    mice.stuff(mice.length(), (rpc_point *)&(to_stuff[2]));
  }
}


u_int POINT_ALERT()
{
  const char *RPC_UNIQUIFYING_STRING = "rpc_event_alerter";
    // this string is used to register a unique windows message.
  return RegisterWindowMessage(RPC_UNIQUIFYING_STRING);
}

---