Added wxOleAutomation class (wxMSW only, obviously...) and some wxTime member functions

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1132 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/msw/ole/automtn.h b/include/wx/msw/ole/automtn.h
new file mode 100644 (file)
index 0000000..e43474d
--- /dev/null
+++ b/include/wx/msw/ole/automtn.h
@@ -0,0 +1,116 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        automtn.h
+// Purpose:     OLE automation utilities
+// Author:      Julian Smart
+// Modified by:
+// Created:     11/6/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998, Julian Smart
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma interface "automtn.h"
+#endif
+
+#ifndef _WX_AUTOMTN_H_
+#define _WX_AUTOMTN_H_
+
+#include "wx/object.h"
+#include "wx/variant.h"
+
+typedef void            WXIDISPATCH;
+typedef unsigned short* WXBSTR;
+
+/*
+ * wxAutomationObject
+ * Wraps up an IDispatch pointer and invocation; does variant conversion.
+ */
+
+class wxAutomationObject: public wxObject
+{
+public:
+    wxAutomationObject(WXIDISPATCH* dispatchPtr = NULL);
+    ~wxAutomationObject();
+
+       // Set/get dispatch pointer
+    inline void SetDispatchPtr(WXIDISPATCH* dispatchPtr) { m_dispatchPtr = dispatchPtr; };
+    inline WXIDISPATCH* GetDispatchPtr() const { return m_dispatchPtr; }
+
+       // Get a dispatch pointer from the current object associated
+       // with a class id, such as "Excel.Application"
+       bool GetInstance(const wxString& classId) const;
+
+       // Get a dispatch pointer from a new instance of the the class
+       bool CreateInstance(const wxString& classId) const;
+
+       // Low-level invocation function. Pass either an array of variants,
+       // or an array of pointers to variants.
+    bool Invoke(const wxString& member, int action,
+        wxVariant& retValue, int noArgs, wxVariant args[], const wxVariant* ptrArgs[] = 0) const;
+
+       // Invoke a member function
+       wxVariant CallMethod(const wxString& method, int noArgs, wxVariant args[]);
+
+       // Convenience function
+       wxVariant CallMethod(const wxString& method,
+               const wxVariant& arg1 = wxNullVariant, const wxVariant& arg2 = wxNullVariant,
+               const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
+               const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
+
+       // Get/Put property
+    wxVariant GetProperty(const wxString& property, int noArgs = 0, wxVariant args[] = (wxVariant*) NULL) const;
+       wxVariant GetProperty(const wxString& property,
+               const wxVariant& arg1, const wxVariant& arg2 = wxNullVariant,
+               const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
+               const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
+
+    bool PutProperty(const wxString& property, int noArgs, wxVariant args[]) ;
+       bool PutProperty(const wxString& property,
+               const wxVariant& arg1, const wxVariant& arg2 = wxNullVariant,
+               const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
+               const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
+
+       // Uses DISPATCH_PROPERTYGET
+       // and returns a dispatch pointer. The calling code should call Release
+       // on the pointer, though this could be implicit by constructing an wxAutomationObject
+       // with it and letting the destructor call Release.
+    WXIDISPATCH* GetDispatchProperty(const wxString& property, int noArgs, wxVariant args[]) const;
+
+       // A way of initialising another wxAutomationObject with a dispatch object,
+       // without having to deal with nasty IDispatch pointers.
+       bool GetObject(wxAutomationObject& obj, const wxString& property, int noArgs = 0, wxVariant args[] = (wxVariant*) NULL) const;
+
+       // Convert variants
+    static bool ConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant) ;
+    static bool ConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant) ;
+
+public:
+    WXIDISPATCH*  m_dispatchPtr;
+};
+
+// wrapper around BSTR type (by Vadim Zeitlin)
+
+class BasicString
+{
+public:
+  // ctors & dtor
+  BasicString(const char *sz);
+ ~BasicString();
+
+  // accessors
+    // just get the string
+  operator BSTR() const { return m_wzBuf; }
+    // retrieve a copy of our string - caller must SysFreeString() it later!
+  BSTR Get() const { return SysAllocString(m_wzBuf); }
+
+private:
+  // @@@ not implemented (but should be)
+  BasicString(const BasicString&);
+  BasicString& operator=(const BasicString&);
+
+  OLECHAR *m_wzBuf;     // actual string
+};
+
+#endif
+    // _WX_AUTOMTN_H_

diff --git a/include/wx/time.h b/include/wx/time.h
index aed87d86ee69d81c818941cd4dbca617b72db1bd..ec06d912bbc111e4aaa1db9fcfa8d5c14f163c1b 100644 (file)
--- a/include/wx/time.h
+++ b/include/wx/time.h
@@ -6,7 +6,7 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem

-// Licence:    wxWindows licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_TIMEH__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_TIMEH__


@@ -32,61 +32,73 @@ class WXDLLEXPORT wxTime: public wxObject
         DECLARE_DYNAMIC_CLASS(wxTime)
         
 public:                 // type definitions
         DECLARE_DYNAMIC_CLASS(wxTime)
         
 public:                 // type definitions

-       enum tFormat { wx12h, wx24h };
-       enum tPrecision { wxStdMinSec, wxStdMin };
+    enum tFormat { wx12h, wx24h };
+    enum tPrecision { wxStdMinSec, wxStdMin };

 private:
 private:

-                 static tFormat                Format;
-                 static tPrecision     Precision;
+    static tFormat      Format;
+    static tPrecision   Precision;

 
 

-                 clockTy               sec;                    /* seconds since 1/1/1901 */
+    clockTy    sec;        /* seconds since 1/1/1901 */

 
 

-        bool IsDST() const;
-        wxTime GetLocalTime() const;
-private:                // static member functions
-        static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
-        static wxTime GetBeginDST(unsigned year);
-        static wxTime GetEndDST(unsigned year);
+    bool IsDST() const;
+    wxTime GetLocalTime() const;
+private:        // static member functions
+    static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
+    static wxTime GetBeginDST(unsigned year);
+    static wxTime GetEndDST(unsigned year);

 public:
 public:

-        wxTime();                         // current time 
-        wxTime(clockTy s)                 { sec = s; }
-        void operator=(const wxTime& t)     { sec = t.sec; } // Ordering required for some compilers
-        wxTime(const wxTime& t)                 { (*this) = t ; }
-                 wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE);
-                 wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
-                 // Convert to string
-        operator char *   (void);
-        operator wxDate() const;
-        bool operator<(const wxTime& t) const     { return sec < t.sec; }
-        bool operator<=(const wxTime& t) const    { return sec <= t.sec; }
-        bool operator>(const wxTime& t) const     { return sec > t.sec; }
-        bool operator>=(const wxTime& t) const    { return sec >= t.sec; }
-        bool operator==(const wxTime& t) const    { return sec == t.sec; }
-        bool operator!=(const wxTime& t) const    { return sec != t.sec; }
-        friend wxTime operator+(const wxTime& t, long s)    { return wxTime(t.sec+s); }
-                 friend wxTime operator+(long s, const wxTime& t)    { return wxTime(t.sec+s); }
-                 long operator-(const wxTime& t) const     { return sec - t.sec; }
-                 wxTime operator-(long s) const    { return wxTime(sec-s); }
-        void operator+=(long s)         { sec += s; }
-        void operator-=(long s)         { sec -= s; }
-        bool IsBetween(const wxTime& a, const wxTime& b) const;
-        hourTy GetHour() const;            // hour in local time
-        hourTy GetHourGMT() const;         // hour in GMT 
-        minuteTy GetMinute() const;        // minute in local time 
-        minuteTy GetMinuteGMT() const;     // minute in GMT 
-        secondTy GetSecond() const;        // second in local time or GMT 
-        clockTy GetSeconds() const         { return sec; }
-        wxTime Max(const wxTime&) const;
-                 wxTime Min(const wxTime&) const;
-                 static void SetFormat(const tFormat lFormat                   = wx12h,
-                                                                               const tPrecision lPrecision     = wxStdMinSec);
-                 char *FormatTime() const;
+    wxTime();             // current time 
+    wxTime(clockTy s)         { sec = s; }
+    void operator=(const wxTime& t)     { sec = t.sec; } // Ordering required for some compilers
+    wxTime(const wxTime& t)         { (*this) = t ; }
+    wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE);
+    wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
+
+    // Convert to string
+    operator char *   (void);
+    operator wxDate() const;
+    bool operator<(const wxTime& t) const     { return sec < t.sec; }
+    bool operator<=(const wxTime& t) const    { return sec <= t.sec; }
+    bool operator>(const wxTime& t) const     { return sec > t.sec; }
+    bool operator>=(const wxTime& t) const    { return sec >= t.sec; }
+    bool operator==(const wxTime& t) const    { return sec == t.sec; }
+    bool operator!=(const wxTime& t) const    { return sec != t.sec; }
+    friend wxTime operator+(const wxTime& t, long s)    { return wxTime(t.sec+s); }
+    friend wxTime operator+(long s, const wxTime& t)    { return wxTime(t.sec+s); }
+    long operator-(const wxTime& t) const     { return sec - t.sec; }
+    wxTime operator-(long s) const    { return wxTime(sec-s); }
+    void operator+=(long s)     { sec += s; }
+    void operator-=(long s)     { sec -= s; }
+    bool IsBetween(const wxTime& a, const wxTime& b) const;
+
+    /// Get day
+    int GetDay() const;
+    /// Get month
+    int GetMonth() const;
+    /// Get year
+    int GetYear() const;
+    /// Get day of week (0=Sunday 6=Saturday)
+    int GetDayOfWeek() const;
+
+    hourTy GetHour() const;        // hour in local time
+    hourTy GetHourGMT() const;     // hour in GMT
+    minuteTy GetMinute() const;    // minute in local time
+    minuteTy GetMinuteGMT() const;     // minute in GMT
+    secondTy GetSecond() const;    // second in local time or GMT
+    clockTy GetSeconds() const     { return sec; }
+    secondTy GetSecondGMT() const ;
+    wxTime Max(const wxTime&) const;
+    wxTime Min(const wxTime&) const;
+    static void SetFormat(const tFormat lFormat = wx12h,
+                  const tPrecision lPrecision = wxStdMinSec);
+    char *FormatTime() const;

 /*
 /*

-        virtual int compare(const Object&) const;
-        virtual void deepenShallowCopy();       // {}
-        virtual unsigned hash() const;
-        virtual bool isEqual(const Object&) const;
-        virtual void printOn(ostream& strm =cout) const;
-        virtual const Class* species() const;
+    virtual int compare(const Object&) const;
+    virtual void deepenShallowCopy();       // {}
+    virtual unsigned hash() const;
+    virtual bool isEqual(const Object&) const;
+    virtual void printOn(ostream& strm =cout) const;
+    virtual const Class* species() const;

 */
 };
 
 */
 };