New MS Surface Pro 2 project

Extra project needed with more advanced camera utils to get high-def
images.

EyeTab_SP2/ReadMe.txt

@@ -0,0 +1,40 @@
+========================================================================
+    CONSOLE APPLICATION : EyeTab_SP2 Project Overview
+========================================================================
+
+AppWizard has created this EyeTab_SP2 application for you.
+
+This file contains a summary of what you will find in each of the files that
+make up your EyeTab_SP2 application.
+
+
+EyeTab_SP2.vcxproj
+    This is the main project file for VC++ projects generated using an Application Wizard.
+    It contains information about the version of Visual C++ that generated the file, and
+    information about the platforms, configurations, and project features selected with the
+    Application Wizard.
+
+EyeTab_SP2.vcxproj.filters
+    This is the filters file for VC++ projects generated using an Application Wizard. 
+    It contains information about the association between the files in your project 
+    and the filters. This association is used in the IDE to show grouping of files with
+    similar extensions under a specific node (for e.g. ".cpp" files are associated with the
+    "Source Files" filter).
+
+EyeTab_SP2.cpp
+    This is the main application source file.
+
+/////////////////////////////////////////////////////////////////////////////
+Other standard files:
+
+StdAfx.h, StdAfx.cpp
+    These files are used to build a precompiled header (PCH) file
+    named EyeTab_SP2.pch and a precompiled types file named StdAfx.obj.
+
+/////////////////////////////////////////////////////////////////////////////
+Other notes:
+
+AppWizard uses "TODO:" comments to indicate parts of the source code you
+should add to or customize.
+
+/////////////////////////////////////////////////////////////////////////////

EyeTab_SP2/comet/array.h

@@ -0,0 +1,150 @@
+/** \file
+* Array wrapper.
+*/
+/*
+* Copyright © 2001 Sofus Mortensen
+*
+* This material is provided "as is", with absolutely no warranty
+* expressed or implied. Any use is at your own risk. Permission to
+* use or copy this software for any purpose is hereby granted without
+* fee, provided the above notices are retained on all copies.
+* Permission to modify the code and to distribute modified code is
+* granted, provided the above notices are retained, and a notice that
+* the code was modified is included with the above copyright notice.
+*
+* This header is part of Comet version 2.
+* https://github.com/alamaison/comet
+*
+*/
+
+/*
+* comet::array_t is adapted from class array by Nicolai M. Josuttis
+*
+* (C) Copyright Nicolai M. Josuttis 2001.
+* Permission to copy, use, modify, sell and distribute this software
+* is granted provided this copyright notice appears in all copies.
+* This software is provided "as is" without express or implied
+* warranty, and with no claim as to its suitability for any purpose.
+*
+*/
+
+#ifndef COMET_ARRAY_H
+#define COMET_ARRAY_H
+
+#include <cstddef>
+#include <stdexcept>
+#include <iterator>
+#include <algorithm>
+#include <vector>
+
+namespace comet {
+
+#pragma pack(push)
+#pragma pack(1)
+
+    /*!\addtogroup Misc
+     */
+    //@{
+
+    template<typename T, size_t SZ> class array_t
+    {
+        T a_[SZ];
+    public:
+        typedef T value_type;
+        typedef typename std::vector<T>::iterator iterator;
+        typedef typename std::vector<T>::const_iterator const_iterator;
+
+        typedef typename std::vector<T>::reverse_iterator reverse_iterator;
+        typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
+
+        typedef typename std::vector<T>::size_type size_type;
+        typedef typename std::vector<T>::difference_type difference_type;
+
+        typedef T& reference;
+        typedef const T& const_reference;
+
+        //    reference operator[](size_type i) { return a_[i]; }
+        //    const_reference operator[](size_type i) const { return a_[i]; }
+
+        iterator begin() { return iterator(a_); }
+        iterator end() { return iterator(a_ + SZ); }
+        const_iterator begin() const { return const_iterator(a_); }
+        const_iterator end() const { return const_iterator(a_ + SZ); }
+
+        reverse_iterator rbegin() { return reverse_iterator(a_); }
+        reverse_iterator rend() { return reverse_iterator(a_ + SZ); }
+        const_reverse_iterator rbegin() const { return const_reverse_iterator(a_); }
+        const_reverse_iterator rend() const { return const_reverse_iterator(a_ + SZ); }
+
+        operator const T*() const { return a_; }
+        operator T*() { return a_; }
+
+        static size_type size() { return SZ; }
+        static bool empty() { return false; }
+        static size_type max_size() { return SZ; }
+        enum { static_size = SZ };
+
+        reference front() { return a_[0]; }
+        const_reference front() const { return a_[0]; }
+        reference back() { return a_[SZ-1]; };
+        const_reference back() const { return a_[SZ-1]; }
+
+        // swap (note: linear complexity)
+        void swap (array_t<T,SZ>& y) {
+            std::swap_ranges(begin(),end(),y.begin());
+        }
+
+        // assignment with type conversion
+        template <typename T2>
+        array_t<T,SZ>& operator= (const array_t<T2,SZ>& rhs) {
+            std::copy(rhs.begin(),rhs.end(), begin());
+            return *this;
+        }
+
+        // assign one value to all elements
+        void assign (const T& value)
+        {
+            std::fill_n(begin(),size(),value);
+        }
+
+        reference at(size_type i) { rangecheck(i); return a_[i]; }
+        const_reference at(size_type i) const { rangecheck(i); return a_[i]; }
+
+    private:
+        // check range (may be private because it is static)
+        static void rangecheck (size_type i) {
+            if (i >= size()) { throw std::range_error("array"); }
+        }
+
+    };
+    //@}
+#pragma pack(pop)
+
+    // comparisons
+    template<class T, size_t SZ>
+    bool operator== (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return std::equal(x.begin(), x.end(), y.begin());
+    }
+    template<class T, size_t SZ>
+    bool operator< (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+    }
+    template<class T, size_t SZ>
+    bool operator!= (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return !(x==y);
+    }
+    template<class T, size_t SZ>
+    bool operator> (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return y<x;
+    }
+    template<class T, size_t SZ>
+    bool operator<= (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return !(y<x);
+    }
+    template<class T, size_t SZ>
+    bool operator>= (const array_t<T,SZ>& x, const array_t<T,SZ>& y) {
+        return !(x<y);
+    }
+}
+
+#endif

EyeTab_SP2/comet/assert.h

@@ -0,0 +1,68 @@
+/** \file
+   Provide run-time asserts.
+  */
+/*
+ * Copyright © 2001 Sofus Mortensen
+ *
+ * This material is provided "as is", with absolutely no warranty
+ * expressed or implied. Any use is at your own risk. Permission to
+ * use or copy this software for any purpose is hereby granted without
+ * fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ *
+ * This header is part of Comet version 2.
+ * https://github.com/alamaison/comet
+ */
+
+#ifndef COMET_ASSERT_H
+#define COMET_ASSERT_H
+
+#include <stdexcept>
+
+# if defined(COMET_ASSERT_THROWS) || defined(COMET_ASSERT_THROWS_ALWAYS)
+#  if defined(COMET_ASSERT_THROWS_ALWAYS) || !defined(NDEBUG)
+namespace comet
+{
+    /*! \defgroup ErrorHandling Error handling.
+     */
+    //@{
+//! Indicates a comet assertion failed.
+/** This is enabled for debug builds if COMET_ASSERT_THROWS is defined and
+ *  enabled for both debug and release if COMET_ASSERT_THROWS_ALWAYS is defined.
+ */
+struct assert_failed : std::runtime_error
+{
+    assert_failed( const char *val) : runtime_error(val) {}
+};
+    //@}
+}
+#   define COMET_ASSERT(x_) if (x_) ; else throw comet::assert_failed("Assert Failed: " #x_ );
+#   define COMET_THROWS_ASSERT throw( comet::assert_failed)
+#  else
+#   define COMET_ASSERT(x_) ;
+#  endif
+
+# else
+#  define COMET_THROWS_ASSERT throw()
+#  ifndef __CYGWIN__
+
+#   include <crtdbg.h>
+#   define COMET_ASSERT _ASSERTE
+
+#  else
+
+#   include <assert.h>
+#   define COMET_ASSERT assert
+#  endif
+# endif
+/*! \addtogroup ErrorHandling
+ */
+//@{
+/** \def COMET_ASSERT Assertion in commet.
+ *  \sa COMET_THROWS_ASSERT COMET_ASSERT_THROWS_ALWAYS
+ */
+    //@}
+
+#endif

EyeTab_SP2/comet/atl_module.h

@@ -0,0 +1,121 @@
+/** \file
+  * ATL Module Compatability wrapper.
+  */
+/*
+ * Copyright © 2000, 2001 Paul Hollingsworth, Michael Geddes
+ * Copyright © 2013 Alexander Lamaison
+ *
+ * This material is provided "as is", with absolutely no warranty
+ * expressed or implied. Any use is at your own risk. Permission to
+ * use or copy this software for any purpose is hereby granted without
+ * fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ *
+ * This header is part of Comet version 2.
+ * https://github.com/alamaison/comet
+ */
+
+#ifndef COMET_ATL_MODULE_H
+#define COMET_ATL_MODULE_H
+
+#include <comet/server.h>
+
+#include <atlbase.h>
+
+namespace comet {
+    /*! \defgroup ATL ATL conversion.
+     */
+    //@{
+
+    /** \struct declspec_comtype atl_module.h comet/atl_module.h
+      * Helper to create a 'comtype' for a non-comet interface.
+      * \code
+      * namespace comet{
+      * template<> struct comtype<IApplicationOption> :
+      *    declspec_comtype<IApplicationOption, ::IDispatch >
+      * { };
+      * };
+      * \endcode
+      *
+      */
+    template<typename ITF, typename BASE = ::IUnknown> struct declspec_comtype
+    {
+        static const uuid_t& uuid() { return uuid_t::create_const_reference(__uuidof(ITF)); }
+        typedef BASE base;
+    };
+
+
+    /// Placeholder for an empty comet typelibrary.
+    struct empty_typelib
+    {
+        typedef nil coclasses;
+    };
+
+    template<typename COM_SERVER, typename ATL_MODULE = ATL::CComModule>
+        class atl_module_ex : public ATL_MODULE
+    {
+        // ATL will take the responsibility of registering the embedded type library.
+        public:
+        HRESULT Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, const GUID* plibid = NULL)
+        {
+            module().instance(h);
+            return ATL_MODULE::Init(p, h, plibid);
+        }
+
+        HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID* pCLSID = NULL)
+        {
+            HRESULT hr = ATL_MODULE::RegisterServer(bRegTypeLib, pCLSID);
+            if(SUCCEEDED(hr))
+                hr = COM_SERVER::DllRegisterServer();
+            return hr;
+        }
+
+        HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID* pCLSID = NULL)
+        {
+            COM_SERVER::DllUnregisterServer();
+            return ATL_MODULE::UnregisterServer(bUnRegTypeLib, pCLSID);
+        }
+
+        HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+        {
+            HRESULT hr = COM_SERVER::DllGetClassObject( rclsid, riid, ppv);
+            if( hr == CLASS_E_CLASSNOTAVAILABLE )
+            {
+                hr = ATL_MODULE::GetClassObject(rclsid, riid,ppv);
+            }
+            return hr;
+        }
+
+        LONG GetLockCount()
+        {
+            return module().rc() + ATL_MODULE::GetLockCount();
+        }
+    };
+
+    /** Wraps an ATL::CComModule to provide co-existing ATL/Comet co-classes.
+      * ATL will take responsibility for registering the embedded type-library.
+      *
+      * Here is an example of how to use it:
+      * \code
+      *     struct typelib_subset
+      *     {
+      *         typedef COMET_STRICT_TYPENAME comet::typelist::make_list< CoClass1, CoClass2 > coclasses;
+      *     };
+      *     comet::atl_module<typelib_subset> _Module;
+      * \endcode
+      * And in std.h:
+      * \code
+      *     struct typelib_subset;
+      *     extern comet::atl_module<typelib_subset> _Module;
+      *  \endcode
+      */
+    template<typename TYPELIB = empty_typelib, typename ATL_MODULE = ATL::CComModule>
+        class atl_module : public atl_module_ex< com_server<TYPELIB, com_server_traits<NO_EMBEDDED_TLB> >, ATL_MODULE >
+    {
+    };
+    //@}
+} // namespace comet
+
+#endif