add initial files l8

1 files changed, 335 insertions, 0 deletions

diff --git a/labb8/lib/StanfordCPPLib/gevents.cpp b/labb8/lib/StanfordCPPLib/gevents.cpp
new file mode 100755
index 0000000..72043d6
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gevents.cpp
@@ -0,0 +1,335 @@
+/*
+ * File: gevents.cpp
+ * -----------------
+ * This file implements the machine-independent functions for the classes
+ * in the gevents.h interface.  The actual functions for receiving events
+ * from the environment are implemented in the platform package.
+ */
+
+/*
+ * Implementation notes:
+ * ---------------------
+ * The classes in this hierarchy are defined in an unusual way
+ * for C++ in that all instance variables are part of the top-level
+ * class.  The advantage of this design is that the GEvent class
+ * then has all of the memory it needs to store an event of any of
+ * its subclasses.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cctype>
+#include "error.h"
+#include "gevents.h"
+#include "gtimer.h"
+#include "gtypes.h"
+#include "map.h"
+#include "platform.h"
+using namespace std;
+
+/* Global variables */
+
+static Platform *pp = getPlatform();
+
+/* Implementation of GEvent class */
+
+GEvent::GEvent() {
+   eventClass = NULL_EVENT;
+   eventType = 0;
+   valid = false;
+   modifiers = 0;
+}
+
+EventClassType GEvent::getEventClass() const {
+   return eventClass;
+}
+
+EventType GEvent::getEventType() const {
+   return EventType(eventType);
+}
+
+double GEvent::getEventTime() const {
+   return eventTime;
+}
+
+int GEvent::getModifiers() const {
+   return modifiers;
+}
+
+string GEvent::toString() const {
+   if (eventClass == 0) {
+      return "GEvent(NULL)";
+   } else if (eventClass == WINDOW_EVENT) {
+      GWindowEvent windowEvent(*this);
+      return (&windowEvent)->toString();
+   } else if (eventClass == ACTION_EVENT) {
+      GActionEvent actionEvent(*this);
+      return (&actionEvent)->toString();
+   } else if (eventClass == MOUSE_EVENT) {
+      GMouseEvent mouseEvent(*this);
+      return (&mouseEvent)->toString();
+   } else if (eventClass == KEY_EVENT) {
+      GKeyEvent keyEvent(*this);
+      return (&keyEvent)->toString();
+   } else if (eventClass == TIMER_EVENT) {
+      GTimerEvent timerEvent(*this);
+      return (&timerEvent)->toString();
+   } else {
+      return "GEvent(?)";
+   }
+}
+
+bool GEvent::isValid() {
+   return valid;
+}
+
+void GEvent::setEventTime(double time) {
+   eventTime = time;
+}
+
+void GEvent::setModifiers(int modifiers) {
+   this->modifiers = modifiers;
+}
+
+GWindowEvent::GWindowEvent() {
+   valid = false;
+}
+
+GWindowEvent::GWindowEvent(GEvent e) {
+   valid = e.valid && e.eventClass == WINDOW_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      gwd = e.gwd;
+   }
+}
+
+GWindowEvent::GWindowEvent(EventType type, const GWindow & gw) {
+   this->eventClass = WINDOW_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   valid = true;
+}
+
+GWindow GWindowEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+string GWindowEvent::toString() const {
+   if (!valid) return "GWindowEvent(?)";
+   ostringstream os;
+   os << "GWindowEvent:";
+   switch (eventType) {
+    case WINDOW_CLOSED:      os << "WINDOW_CLOSED";       break;
+    case WINDOW_RESIZED:     os << "WINDOW_RESIZED";      break;
+   }
+   os << "()";
+   return os.str();
+}
+
+GActionEvent::GActionEvent() {
+   valid = false;
+}
+
+GActionEvent::GActionEvent(GEvent e) {
+   valid = e.valid && e.eventClass == ACTION_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      source = e.source;
+      actionCommand = e.actionCommand;
+   }
+}
+
+GActionEvent::GActionEvent(EventType type, GObject *source,
+                           string actionCommand) {
+   this->eventClass = ACTION_EVENT;
+   this->eventType = int(type);
+   this->source = source;
+   this->actionCommand = actionCommand;
+   valid = true;
+}
+
+GObject *GActionEvent::getSource() const {
+   return source;
+}
+
+string GActionEvent::getActionCommand() const {
+   if (!valid) error("getActionCommand: Event is not valid");
+   return actionCommand;
+}
+
+string GActionEvent::toString() const {
+   if (!valid) return "GActionEvent(?)";
+   ostringstream os;
+   os << "GActionEvent:ACTION_PERFORMED(" << actionCommand << ")";
+   return os.str();
+}
+
+GMouseEvent::GMouseEvent() {
+   valid = false;
+}
+
+GMouseEvent::GMouseEvent(GEvent e) {
+   valid = e.valid && e.eventClass == MOUSE_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      x = e.x;
+      y = e.y;
+   }
+}
+
+GMouseEvent::GMouseEvent(EventType type, const GWindow & gw,
+                                         double x, double y) {
+   this->eventClass = MOUSE_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   this->x = x;
+   this->y = y;
+   valid = true;
+}
+
+GWindow GMouseEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+double GMouseEvent::getX() const {
+   if (!valid) error("getX: Event is not valid");
+   return x;
+}
+
+double GMouseEvent::getY() const {
+   if (!valid) error("getY: Event is not valid");
+   return y;
+}
+
+string GMouseEvent::toString() const {
+   if (!valid) return "GMouseEvent(?)";
+   ostringstream os;
+   os << "GMouseEvent:";
+   switch (eventType) {
+    case MOUSE_PRESSED:  os << "MOUSE_PRESSED";   break;
+    case MOUSE_RELEASED: os << "MOUSE_RELEASED";  break;
+    case MOUSE_CLICKED:  os << "MOUSE_CLICKED";   break;
+    case MOUSE_MOVED:    os << "MOUSE_MOVED";     break;
+    case MOUSE_DRAGGED:  os << "MOUSE_DRAGGED";   break;
+   }
+   os << "(" << x << ", " << y << ")";
+   return os.str();
+}
+
+GKeyEvent::GKeyEvent() {
+   valid = false;
+}
+
+GKeyEvent::GKeyEvent(GEvent e) {
+   this->eventClass = KEY_EVENT;
+   valid = e.valid && e.eventClass == KEY_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      keyChar = e.keyChar;
+      keyCode = e.keyCode;
+   }
+}
+
+GKeyEvent::GKeyEvent(EventType type, const GWindow & gw,
+                                     int keyChar, int keyCode) {
+   this->eventClass = KEY_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   this->keyChar = keyChar;
+   this->keyCode = keyCode;
+   valid = true;
+}
+
+GWindow GKeyEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+char GKeyEvent::getKeyChar() const {
+   if (!valid) error("getKey: Event is not valid");
+   return char(keyChar);
+   // Think about wide characters at some point
+}
+
+int GKeyEvent::getKeyCode() const {
+   if (!valid) error("getKey: Event is not valid");
+   return keyCode;
+}
+
+string GKeyEvent::toString() const {
+   if (!valid) return "GKeyEvent(?)";
+   ostringstream os;
+   os << "GKeyEvent:";
+   int ch = '\0';
+   switch (eventType) {
+    case KEY_PRESSED:  os << "KEY_PRESSED";   ch = keyCode; break;
+    case KEY_RELEASED: os << "KEY_RELEASED";  ch = keyCode; break;
+    case KEY_TYPED:    os << "KEY_TYPED";     ch = keyChar; break;
+   }
+   if (isprint(ch)) {
+      os << "('" << char(ch) << "')";
+   } else {
+      os << oct << "('\\" << ch << "')";
+   }
+   return os.str();
+}
+
+/* Timer events */
+
+GTimerEvent::GTimerEvent() {
+   valid = false;
+}
+
+GTimerEvent::GTimerEvent(GEvent e) {
+   valid = e.valid && e.eventClass == TIMER_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      gtd = e.gtd;
+   }
+}
+
+GTimerEvent::GTimerEvent(EventType type, const GTimer & timer) {
+   this->eventClass = TIMER_EVENT;
+   this->eventType = int(type);
+   this->gtd = timer.gtd;
+   valid = true;
+}
+
+GTimer GTimerEvent::getGTimer() const {
+   return GTimer(gtd);
+}
+
+string GTimerEvent::toString() const {
+   if (!valid) return "GTimerEvent(?)";
+   return "GTimerEvent:TIMER_TICKED()";
+}
+
+/* Global event handlers */
+
+void waitForClick() {
+   waitForEvent(CLICK_EVENT);
+}
+
+GEvent waitForEvent(int mask) {
+   return pp->waitForEvent(mask);
+}
+
+GEvent getNextEvent(int mask) {
+   return pp->getNextEvent(mask);
+}
+