amroc/converters/HDFToV3/Eventhandler.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@cacr.caltech.edu

#ifndef AMROC_EVENTHANDLER_H
#define AMROC_EVENTHANDLER_H

#include <queue>
#include <utility>
#include <deque>

#include "IO/control-device.h"

#include <wsdepend.h>
#include <X11/Xlib.h>

struct SetState {
  SetState(int o, long *iv, int ivlen, float *rv, int rvlen, char *st, int slen) :
    opt(o), str_len(slen) {
    ivec = new long[ivlen];
    for (int i=0; i<ivlen; i++) 
      ivec[i] = iv[i];

    rvec = new float[rvlen];
    for (int r=0; r<rvlen; r++) 
      rvec[r] = rv[r];

    str = new char[slen];
    for (int s=0; s<slen; s++) 
      str[s] = st[s];
  }

  ~SetState() {
    if (ivec)
      delete [] ivec;
    if (rvec)
      delete [] rvec;
    if (str)
      delete [] str;
  }
  
  int opt;
  long *ivec;
  float *rvec;
  char *str;
  int str_len;
};

struct SingleEvent {
  SingleEvent() : 
    start(0), win(0), type(0), state(0), xe(1), ye(1), ststate((SetState *)0) {}
  SingleEvent(int st, int w, int t, int s) : 
    start(st), win(w), type(t), state(s), xe(1), ye(1), ststate((SetState *)0) {}
  SingleEvent(int st, int w, int t, int s, int x, int y) : 
    start(st), win(w), type(t), state(s), xe(x), ye(y), ststate((SetState *)0) {}
  SingleEvent(int st, int w, int t, int s, SetState *stst) : 
    start(st), win(w), type(t), state(s), xe(1), ye(1), ststate(stst) {}
  SingleEvent(int st, int w, int t, int s, int x, int y, SetState *stst) : 
    start(st), win(w), type(t), state(s), xe(x), ye(y), ststate(stst) {}

  ~SingleEvent() {
//     if (ststate)
//       delete ststate;
  }

  int start;
  int win;
  int type;
  int state;
  int xe, ye;
  SetState *ststate;
};


class VisualEventHandler {
  typedef std::queue<SingleEvent, std::deque<SingleEvent> > event_queue_type;

public:
  VisualEventHandler() : _NumberInits(0) {
    InitVariables();
  }

  virtual ~VisualEventHandler() {}

  virtual void SetUpQueue() {}
  
  void ProcessEvent(int *iwin, int *type, int *xe, int *ye, int *state) {
    if (called == -1) {
      float dummy;
      char cstr[80];
      int opt = 0;
      V3_GETSTATE( &opt, winid, &dummy, cstr, 80);
      opt = -1;
      V3_GETSTATE( &opt, keybin, &dummy, cstr, 80);
      called = 0;
      _NumberInits++;
      SetUpQueue();
      return;
    }
    if (!_EventQueue.empty()) {
      if (called>=_EventQueue.front().start && *iwin==-1) {
        SingleEvent& Current = _EventQueue.front();
        if (Current.ststate) {
          SetState *CSSt = Current.ststate;
          V3_SETSTATE( &(CSSt->opt), CSSt->ivec, CSSt->rvec, CSSt->str, CSSt->str_len);
          delete Current.ststate;
          Current.ststate = (SetState *)0;
          Current.start++;
          *iwin = 0;
          *type = 0;
          *state = 0;
          *xe = 0; 
          *ye = 0;        
          return;
        }
        
        *iwin = Current.win;
        *type = Current.type;
        *state = Current.state;
        *xe = Current.xe; 
        *ye = Current.ye;

        _EventQueue.pop();
        called = 0;
      }
      else
        called++;
    }

   if (*state == keybin[19])
      InitVariables();
  }

  inline event_queue_type& EventQueue() { return _EventQueue; }
  inline const event_queue_type& EventQueue() const { return _EventQueue; }
  inline void InitVariables() { called = -1; }
  inline const int& NumberInits() const { return _NumberInits; }
  inline int NumberInits() { return _NumberInits; }
  inline void SetNumberInits(int& ni) { _NumberInits = ni; }

protected:
  event_queue_type _EventQueue;

  long winid[8];
  long keybin[32];

private:
  int called;
  int _NumberInits; 
};


#endif

---