--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TIMEH__
DECLARE_DYNAMIC_CLASS(wxTime)
public: // type definitions
- enum tFormat { wx12h, wx24h };
- enum tPrecision { wxStdMinSec, wxStdMin };
+ enum tFormat { wx12h, wx24h };
+ enum tPrecision { wxStdMinSec, wxStdMin };
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:
- 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;
*/
};