home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / INCLUDE / GESTSET.HPP < prev    next >
C/C++ Source or Header  |  1993-05-08  |  4KB  |  145 lines
  1. //
  2. // GestSet.hpp:
  3. //    Interface Definition of classes priorityMechanism, GestureSet,
  4. //    RecognizableList, and AbsGestSet.  Part of Court Jesture library.
  5. //
  6. // Copyright 1993   Mark Thomas Pflaging
  7. //
  8. // Date:       3/22/93 (Release 3.0)
  9. //
  10. #ifndef __GESTSET_HPP
  11. #define __GESTSET_HPP
  12.  
  13. #include "gesture.hpp"
  14.  
  15. class priorityMechanism : Vector<long> {
  16.     void fixLast();
  17.  
  18. public:
  19.     priorityMechanism(size_t elements) : Vector<long>(elements) {}
  20.     Vector<long> & operator+=(long & p);
  21.     Vector<long> & operator-=(long & p);
  22.     long findHighest();
  23. };
  24.  
  25. typedef ListElement<Recognizable> GestHandle;
  26.  
  27. class RecognizableList : public LinkList<Recognizable> {
  28.     static Comparator<Recognizable> finder;
  29.     static Boolean greaterThan(Recognizable & arg1, Recognizable & arg2);
  30.     static Boolean equalTo(Recognizable & arg1, Recognizable & arg2);
  31.     void sortedInsert(GestHandle & gesture) {
  32.         finder.setValue(&gesture);
  33.         LinkList<Recognizable>::sortedInsert(finder);
  34.     }
  35.     void findAndRemove(GestHandle & gesture) {
  36.         finder.setValue(&gesture);
  37.         LinkList<Recognizable>::findAndRemove(finder);
  38.     }
  39.     int len;
  40.  
  41. protected:
  42.     static Boolean dump(LinkList<Recognizable> &that, void * where);
  43.  
  44. public:
  45.     RecognizableList() : LinkList<Recognizable>(), len(0) {}
  46.     RecognizableList(RecognizableList & arg) { *this = arg; }
  47.     RecognizableList & operator=(RecognizableList & arg) {
  48.         len = arg.len;
  49.         LinkList<Recognizable>::operator=(arg);
  50.         return *this;
  51.     }
  52.     RecognizableList & operator+(GestHandle & gesture) {
  53.         int templen = (gesture.getData()).getLength();
  54.         if (templen > len) len = templen;
  55.         sortedInsert(gesture);
  56.         return *this;
  57.     }
  58.     RecognizableList & operator-(GestHandle & gesture) {
  59.         // Should we change len if this was the longest gesture
  60.         // in the list?  I don't think we need to bother,
  61.         // since it's ok if the sample buffer is too long.
  62.         findAndRemove(gesture);
  63.         return *this;
  64.     }
  65.     virtual GestHandle & add(char * text) {
  66.         Gesture & gest = *(new Gesture);
  67.         gest.setFromText(text);
  68.         GestHandle & retval = *(new ListElement<Recognizable>);
  69.          retval.setData(&gest);
  70.         *this + retval;
  71.         return retval;
  72.     }
  73.     ostream & dump(ostream & where) {
  74.         doFunc(dump, &where);
  75.         return where;
  76.     }
  77.     int getLen() { return len; }
  78. };
  79.  
  80. class GestureSystem;
  81.  
  82. class AbsGestSet {
  83. public:
  84.     virtual void Setup() = 0;
  85.     virtual void Register(Gesture & found, Boolean offOrOn) = 0;
  86. };
  87.  
  88. class GestureSet : public RecognizableList, private priorityMechanism, public StringName,
  89.     public Activator, public AbsGestSet {
  90.     Boolean CheckPriority(Recognizable & popped, Boolean onOrOff);
  91.     friend class GestureSystem;
  92.     long active_priority;
  93.     static Boolean killGest(LinkList<Recognizable> & here, void * dumb) {
  94.         Recognizable & what = here.currentData();
  95.         delete &(what.getData());
  96.         return True;
  97.     }
  98.  
  99. public:
  100.     // You might need the priorityMechanism to be a little
  101.     // longer than the QueueVector, but I seriously doubt it.
  102.     GestureSet(char * name = NULL) :
  103.         priorityMechanism(15), active_priority(0), StringName(name) {}
  104.     GestureSet(GestureSet & arg) : priorityMechanism(15) { *this = arg; }
  105.     GestureSet & operator =(GestureSet & arg) {
  106.         if (!arg.isOn()) {
  107.             active_priority = 0;
  108.             RecognizableList::operator=(arg);
  109.             StringName::operator=(arg);
  110.         }
  111.         return *this;
  112.     }
  113.     virtual ~GestureSet() {}
  114.     virtual void killAssociatedGestures() {
  115.         doFunc(killGest, NULL);
  116.         clearList();
  117.         }
  118.     virtual void Register(Gesture & found, Boolean offOrOn) {
  119.         found.Register(offOrOn);
  120.     }
  121.     void setName(char *arg) { StringName::setName(arg); }
  122.     void Setup() {}
  123.     GestureSet & operator+(Gesture * arg) {
  124.                 if (!isOn()) {
  125.             ListElement<Recognizable> & added = *(new ListElement<Recognizable>);
  126.             added.setData(arg);
  127.             RecognizableList::operator+(added);
  128.                 }
  129.         return *this;
  130.     }
  131.     GestureSet & operator-(Gesture * arg) {
  132.         if (!isOn()) {
  133.             // Two Recognizables are equal when they point to the
  134.             // same Gesture.  Need to make a fake recognizable
  135.             // for the purposes of 'equalTo()'.
  136.             ListElement<Recognizable> temp;
  137.             temp.setData(arg);
  138.             RecognizableList::operator-(temp);
  139.         }
  140.         return *this;
  141.     }
  142. };
  143.  
  144. #endif
  145.