Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1132 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Julian Smart
1998-12-08 18:54:05 +00:00
parent aa0b7e1e64
commit e8b6d59d51
2 changed files with 179 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
include/wx/msw/ole/automtn.h Normal file
View File

@@ -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_

114
include/wx/time.h
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // 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) DECLARE_DYNAMIC_CLASS(wxTime)
public: // type definitions public: // type definitions
enum tFormat { wx12h, wx24h }; enum tFormat { wx12h, wx24h };
enum tPrecision { wxStdMinSec, wxStdMin }; enum tPrecision { wxStdMinSec, wxStdMin };
private: private:
static tFormat Format; static tFormat Format;
static tPrecision Precision; static tPrecision Precision;
clockTy sec; /* seconds since 1/1/1901 */ clockTy sec; /* seconds since 1/1/1901 */
bool IsDST() const; bool IsDST() const;
wxTime GetLocalTime() const; wxTime GetLocalTime() const;
private: // static member functions private: // static member functions
static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0); static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
static wxTime GetBeginDST(unsigned year); static wxTime GetBeginDST(unsigned year);
static wxTime GetEndDST(unsigned year); static wxTime GetEndDST(unsigned year);
public: public:
wxTime(); // current time wxTime(); // current time
wxTime(clockTy s) { sec = s; } wxTime(clockTy s) { sec = s; }
void operator=(const wxTime& t) { sec = t.sec; } // Ordering required for some compilers void operator=(const wxTime& t) { sec = t.sec; } // Ordering required for some compilers
wxTime(const wxTime& t) { (*this) = t ; } wxTime(const wxTime& t) { (*this) = t ; }
wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE); 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); wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
// Convert to string
operator char * (void); // Convert to string
operator wxDate() const; operator char * (void);
bool operator<(const wxTime& t) const { return sec < t.sec; } 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; }
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); } bool operator!=(const wxTime& t) const { return sec != t.sec; }
friend wxTime operator+(long s, const wxTime& t) { return wxTime(t.sec+s); } friend wxTime operator+(const wxTime& t, long s) { return wxTime(t.sec+s); }
long operator-(const wxTime& t) const { return sec - t.sec; } friend wxTime operator+(long s, const wxTime& t) { return wxTime(t.sec+s); }
wxTime operator-(long s) const { return wxTime(sec-s); } long operator-(const wxTime& t) const { return sec - t.sec; }
void operator+=(long s) { sec += s; } 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; void operator-=(long s) { sec -= s; }
hourTy GetHour() const; // hour in local time bool IsBetween(const wxTime& a, const wxTime& b) const;
hourTy GetHourGMT() const; // hour in GMT
minuteTy GetMinute() const; // minute in local time /// Get day
minuteTy GetMinuteGMT() const; // minute in GMT int GetDay() const;
secondTy GetSecond() const; // second in local time or GMT /// Get month
clockTy GetSeconds() const { return sec; } int GetMonth() const;
wxTime Max(const wxTime&) const; /// Get year
wxTime Min(const wxTime&) const; int GetYear() const;
static void SetFormat(const tFormat lFormat = wx12h, /// Get day of week (0=Sunday 6=Saturday)
const tPrecision lPrecision = wxStdMinSec); int GetDayOfWeek() const;
char *FormatTime() 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 int compare(const Object&) const;
virtual void deepenShallowCopy(); // {} virtual void deepenShallowCopy(); // {}
virtual unsigned hash() const; virtual unsigned hash() const;
virtual bool isEqual(const Object&) const; virtual bool isEqual(const Object&) const;
virtual void printOn(ostream& strm =cout) const; virtual void printOn(ostream& strm =cout) const;
virtual const Class* species() const; virtual const Class* species() const;
*/ */
}; };