shared_code.h

Go to the documentation of this file.

#ifndef RPC_SHARED_CODE_GROUP
#define RPC_SHARED_CODE_GROUP

/*****************************************************************************\
*                                                                             *
*  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 <basis/array.h>
#include <basis/istring.h>
#include <basis/portable.h>
#include <geometric/screen_rectangle.h>
#include <mechanisms/semaphore.h>


#define DEBUG_RPC
  // comment this out for non-debugging version or leave in for debugging.


#define RPC_DEBUG_METHOD debugger::delayed
  // delayed means that messages will wait in the queue until time can be
  // spared to print them.  immediate means they will print when sent.


typedef geometric::point<int> rpc_point;
  // type of point used here (same size under 16 and 32 bit platforms).


// This class is used as a base for classes who want to be alerted to
// the mouse being clicked.

class mouserciser
{
public:
  virtual void mouse_hit(const rpc_point &position) = 0;
    // called by the drawing window when the mouse has been
    // clicked somewhere on the window.
  virtual void update() = 0;
    // called by the drawing window when it's time for the points to be updated
    // to all clients (only if this is a server).
};


// this class is used to capture mouse events and route them to the parent.

class drawing_window : public CView
{
public:
  drawing_window(mouserciser &mouse_alert);
    // the "mouse_alert" object will receive notifications when mouse events
    // occur.  
  virtual ~drawing_window();

  bool Create(CFrameWnd *parent, const istring &title, window_handle alert,
        bool locking);
    // the "parent" window manages the drawing window.  the "title" is used for
    // the window's title.  "alert" is a window to direct debugging messages
    // at; it's only used if DEBUG_RPC is turned on.  if "locking" is true,
    // then the list will be protected using a semaphore.

  IMPLEMENT_CLASS_NAME("drawing_window");

  void be_gone();
    // gets rid of the window in preparation for the controller dying.

  void add_dot(const rpc_point &draw_at);
    // plots a blob at the position to "draw_at".

  int length();
    // returns the current size of the mouse list.

  void get_mouse_list(array<rpc_point> &current_list);
    // returns the "current_list" of points where the user has clicked
    // the mouse.
  void set_mouse_list(const array<rpc_point> &new_mice);
     // resets the mouse list to "new_mice".

  void pull_out_mice(const byte_array &flattened, array<rpc_point> &original);
    // returns a list of mouse positions from their flattened form.
  void push_in_mice(const array<rpc_point> &to_flatten, byte_array &flattened);
    // stuffs a mouse list into an array of bytes.

  const geometric::screen_point dot_size;
    // the dots we draw are this big in magnitude.

  void start_timer(UINT interval);
    // starts the timer to go off after interval milliseconds.

  void stop_timer();
    // stops the operation of the timer.

  CFrameWnd *parent() const { return my_parent; };
    // returns the parent frame window.

  // these protect access to the lists.  every lock must be followed by an
  // unlock or the program will deadlock.
  void lock();
  void unlock();

private:
  CFrameWnd *my_parent;  // controller of this drawing window.
  window_handle alert;  // debugging window console.
  mouserciser &mouse_alert;  // alerted when user adds a point.
  array<rpc_point> mice;  // our list of mice.
  semaphore locker;  // protects our lists.
  bool locking_mode;  // true if semaphore is really used.

  // mfc mechanisms:
  DECLARE_MESSAGE_MAP()

  //{{AFX_MSG(drawing_window)
  afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
  afx_msg void OnClose();
  afx_msg void OnTimer(u_int timer_id);
    // invoked by a timer message from the example server to help test the
    // send_and_receive() function's extended rpc protocol; it sends out the
    // point to be updated.
  afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
  afx_msg void OnPaint();
  afx_msg void OnDraw(CDC *pDC);
  //}}AFX_MSG
};


// strings used for rpc communication.

#define REGISTER_CLIENT istring("regis")
  // in: window handle, out: none.

#define UNREGISTER_CLIENT istring("kathylee")
  // in: window handle, out: none.

#define NEW_POINT istring("add")
  // in: array<rpc_point>, out: none.

#define GET_LIST istring("get")
  // in: none, out: array<rpc_point>.

#define GET_PARTIAL istring("getfrom")
  // in: index, out: array<rpc_point> from index to end. 


const int MAXIMUM_POINT_EXCHANGE = 150000;
  // the largest chunk of bytes that can hold a list of points.

const int THREAD_STACK_SIZE = 20000;
  // the maximum amount of data allowed on an rpc thread's stack, for both
  // client and servers.


u_int POINT_ALERT();
  // provides a registered message for alerting clients to updates to the
  // points list.


#define INSTANTIATE_RPC_EXAMPLE \
  void crunkerfnurt() { const array<rpc_point> dummy; }


#endif

---