Initial commit

common/rfb/ScreenSet.h

@@ -0,0 +1,151 @@
+/* Copyright 2009 Pierre Ossman for Cendio AB
+ * 
+ * This 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 software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+// Management class for the RFB virtual screens
+
+#ifndef __RFB_SCREENSET_INCLUDED__
+#define __RFB_SCREENSET_INCLUDED__
+
+#include <stdio.h>
+#include <string.h>
+
+#include <rdr/types.h>
+#include <rfb/Rect.h>
+#include <list>
+#include <set>
+
+namespace rfb {
+
+  // rfb::Screen
+  //
+  // Represents a single RFB virtual screen, which includes
+  // coordinates, an id and flags.
+
+  struct Screen {
+    Screen(void) : id(0), flags(0) {};
+    Screen(rdr::U32 id_, int x_, int y_, int w_, int h_, rdr::U32 flags_) :
+      id(id_), dimensions(x_, y_, x_+w_, y_+h_), flags(flags_) {};
+
+    inline bool operator==(const Screen& r) const {
+      if (id != r.id)
+        return false;
+      if (!dimensions.equals(r.dimensions))
+        return false;
+      if (flags != r.flags)
+        return false;
+      return true;
+    }
+
+    rdr::U32 id;
+    Rect dimensions;
+    rdr::U32 flags;
+  };
+
+  // rfb::ScreenSet
+  //
+  // Represents a complete screen configuration, excluding framebuffer
+  // dimensions.
+
+  struct ScreenSet {
+    ScreenSet(void) {};
+
+    typedef std::list<Screen>::iterator iterator;
+    typedef std::list<Screen>::const_iterator const_iterator;
+
+    inline iterator begin(void) { return screens.begin(); };
+    inline const_iterator begin(void) const { return screens.begin(); };
+    inline iterator end(void) { return screens.end(); };
+    inline const_iterator end(void) const { return screens.end(); };
+
+    inline int num_screens(void) const { return screens.size(); };
+
+    inline void add_screen(const Screen screen) { screens.push_back(screen); };
+    inline void remove_screen(rdr::U32 id) {
+      std::list<Screen>::iterator iter, nextiter;
+      for (iter = screens.begin();iter != screens.end();iter = nextiter) {
+        nextiter = iter; nextiter++;
+        if (iter->id == id)
+            screens.erase(iter);
+      }
+    }
+
+    inline bool validate(int fb_width, int fb_height) const {
+      std::list<Screen>::const_iterator iter;
+      std::set<rdr::U32> seen_ids;
+      Rect fb_rect;
+
+      if (screens.empty())
+        return false;
+      if (num_screens() > 255)
+        return false;
+
+      fb_rect.setXYWH(0, 0, fb_width, fb_height);
+
+      for (iter = screens.begin();iter != screens.end();++iter) {
+        if (iter->dimensions.is_empty())
+          return false;
+        if (!iter->dimensions.enclosed_by(fb_rect))
+          return false;
+        if (seen_ids.find(iter->id) != seen_ids.end())
+          return false;
+        seen_ids.insert(iter->id);
+      }
+
+      return true;
+    };
+
+    inline void print(char* str, size_t len) const {
+      char buffer[128];
+      std::list<Screen>::const_iterator iter;
+      snprintf(buffer, sizeof(buffer), "%d screen(s)\n", num_screens());
+      str[0] = '\0';
+      strncat(str, buffer, len - 1 - strlen(str));
+      for (iter = screens.begin();iter != screens.end();++iter) {
+        snprintf(buffer, sizeof(buffer),
+                 "    %10d (0x%08x): %dx%d+%d+%d (flags 0x%08x)\n",
+                 (int)iter->id, (unsigned)iter->id,
+                 iter->dimensions.width(), iter->dimensions.height(),
+                 iter->dimensions.tl.x, iter->dimensions.tl.y,
+                 (unsigned)iter->flags);
+        strncat(str, buffer, len - 1 - strlen(str));
+      }
+    };
+
+    inline bool operator==(const ScreenSet& r) const {
+      std::list<Screen> a = screens;
+      a.sort(compare_screen);
+      std::list<Screen> b = r.screens;
+      b.sort(compare_screen);
+      return a == b;
+    };
+    inline bool operator!=(const ScreenSet& r) const { return !operator==(r); }
+
+    std::list<Screen> screens;
+
+  private:
+    static inline bool compare_screen(const Screen& first, const Screen& second)
+    {
+      return first.id < second.id;
+    }
+
+  };
+
+};
+
+#endif
+