]>
git.saurik.com Git - wxWidgets.git/blob - src/msw/ole/automtn.cpp
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: OLE automation utilities
4 // Author: Julian Smart
8 // Copyright: (c) 1998, Julian Smart
9 // Licence: wxWindows Licence
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "automtn.h"
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
19 #if defined(__BORLANDC__)
25 // Watcom C++ gives a linker error if this is compiled in.
26 // With Borland C++, all samples crash if this is compiled in.
27 #if !defined(__WATCOMC__) && !(defined(__BORLANDC__) && (__BORLANDC__ < 0x520)) && !defined(__CYGWIN10__)
30 #include "wx/msw/ole/automtn.h"
31 #include "wx/msw/private.h"
43 // wrapper around BSTR type (by Vadim Zeitlin)
45 class WXDLLEXPORT BasicString
49 BasicString(const char *sz
);
53 // just get the string
54 operator BSTR() const { return m_wzBuf
; }
55 // retrieve a copy of our string - caller must SysFreeString() it later!
56 BSTR
Get() const { return SysAllocString(m_wzBuf
); }
59 // @@@ not implemented (but should be)
60 BasicString(const BasicString
&);
61 BasicString
& operator=(const BasicString
&);
63 OLECHAR
*m_wzBuf
; // actual string
67 static bool ConvertVariantToOle(const wxVariant
& variant
, VARIANTARG
& oleVariant
) ;
68 static bool ConvertOleToVariant(const VARIANTARG
& oleVariant
, wxVariant
& variant
) ;
70 // Convert string to Unicode
71 static BSTR
ConvertStringToOle(const wxString
& str
);
73 // Convert string from BSTR to wxString
74 static wxString
ConvertStringFromOle(BSTR bStr
);
76 // Verifies will fail if the needed buffer size is too large
77 #define MAX_TIME_BUFFER_SIZE 128 // matches that in timecore.cpp
78 #define MIN_DATE (-657434L) // about year 100
79 #define MAX_DATE 2958465L // about year 9999
81 // Half a second, expressed in days
82 #define HALF_SECOND (1.0/172800.0)
84 // One-based array of days in year at month start
85 static int rgMonthDays
[13] =
86 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
88 static BOOL
OleDateFromTm(WORD wYear
, WORD wMonth
, WORD wDay
,
89 WORD wHour
, WORD wMinute
, WORD wSecond
, DATE
& dtDest
);
90 static BOOL
TmFromOleDate(DATE dtSrc
, struct tm
& tmDest
);
92 static void ClearVariant(VARIANTARG
*pvarg
) ;
93 static void ReleaseVariant(VARIANTARG
*pvarg
) ;
94 // static void ShowException(LPOLESTR szMember, HRESULT hr, EXCEPINFO *pexcep, unsigned int uiArgErr);
100 wxAutomationObject::wxAutomationObject(WXIDISPATCH
* dispatchPtr
)
102 m_dispatchPtr
= dispatchPtr
;
105 wxAutomationObject::~wxAutomationObject()
109 ((IDispatch
*)m_dispatchPtr
)->Release();
110 m_dispatchPtr
= NULL
;
114 #define INVOKEARG(i) (args ? args[i] : *(ptrArgs[i]))
116 // For Put/Get, no named arguments are allowed.
117 bool wxAutomationObject::Invoke(const wxString
& member
, int action
,
118 wxVariant
& retValue
, int noArgs
, wxVariant args
[], const wxVariant
* ptrArgs
[]) const
123 // nonConstMember is necessary because the wxString class doesn't have enough consts...
124 wxString
nonConstMember(member
);
126 int ch
= nonConstMember
.Find('.');
129 // Use dot notation to get the next object
130 wxString
member2(nonConstMember
.Left((size_t) ch
));
131 wxString
rest(nonConstMember
.Right(nonConstMember
.Length() - ch
- 1));
132 wxAutomationObject obj
;
133 if (!GetObject(obj
, member2
))
135 return obj
.Invoke(rest
, action
, retValue
, noArgs
, args
, ptrArgs
);
139 ClearVariant(& vReturn
);
141 VARIANTARG
* vReturnPtr
= & vReturn
;
143 // Find number of names args
144 int namedArgCount
= 0;
146 for (i
= 0; i
< noArgs
; i
++)
147 if (!INVOKEARG(i
).GetName().IsNull())
152 int namedArgStringCount
= namedArgCount
+ 1;
153 BSTR
* argNames
= new BSTR
[namedArgStringCount
];
154 argNames
[0] = ConvertStringToOle(member
);
156 // Note that arguments are specified in reverse order
157 // (all totally logical; hey, we're dealing with OLE here.)
160 for (i
= 0; i
< namedArgCount
; i
++)
162 if (!INVOKEARG(i
).GetName().IsNull())
164 argNames
[(namedArgCount
-j
)] = ConvertStringToOle(INVOKEARG(i
).GetName());
169 // + 1 for the member name, + 1 again in case we're a 'put'
170 DISPID
* dispIds
= new DISPID
[namedArgCount
+ 2];
173 DISPPARAMS dispparams
;
174 unsigned int uiArgErr
;
177 // Get the IDs for the member and its arguments. GetIDsOfNames expects the
178 // member name as the first name, followed by argument names (if any).
179 hr
= ((IDispatch
*)m_dispatchPtr
)->GetIDsOfNames(IID_NULL
, argNames
,
180 1 + namedArgCount
, LOCALE_SYSTEM_DEFAULT
, dispIds
);
183 // ShowException(szMember, hr, NULL, 0);
187 // if doing a property put(ref), we need to adjust the first argument to have a
188 // named arg of DISPID_PROPERTYPUT.
189 if (action
& (DISPATCH_PROPERTYPUT
| DISPATCH_PROPERTYPUTREF
))
192 dispIds
[1] = DISPID_PROPERTYPUT
;
193 vReturnPtr
= (VARIANTARG
*) NULL
;
196 // Convert the wxVariants to VARIANTARGs
197 VARIANTARG
* oleArgs
= new VARIANTARG
[noArgs
];
198 for (i
= 0; i
< noArgs
; i
++)
200 // Again, reverse args
201 if (!ConvertVariantToOle(INVOKEARG((noArgs
-1) - i
), oleArgs
[i
]))
202 return FALSE
; // TODO: clean up memory at this point
205 dispparams
.rgdispidNamedArgs
= dispIds
+ 1;
206 dispparams
.rgvarg
= oleArgs
;
207 dispparams
.cArgs
= noArgs
;
208 dispparams
.cNamedArgs
= namedArgCount
;
210 excep
.pfnDeferredFillIn
= NULL
;
212 hr
= ((IDispatch
*)m_dispatchPtr
)->Invoke(dispIds
[0], IID_NULL
, LOCALE_SYSTEM_DEFAULT
,
213 action
, &dispparams
, vReturnPtr
, &excep
, &uiArgErr
);
215 for (i
= 0; i
< namedArgStringCount
; i
++)
217 SysFreeString(argNames
[i
]);
222 for (i
= 0; i
< noArgs
; i
++)
223 ReleaseVariant(& oleArgs
[i
]) ;
228 // display the exception information if appropriate:
229 // ShowException((const char*) member, hr, &excep, uiArgErr);
231 // free exception structure information
232 SysFreeString(excep
.bstrSource
);
233 SysFreeString(excep
.bstrDescription
);
234 SysFreeString(excep
.bstrHelpFile
);
237 ReleaseVariant(vReturnPtr
);
244 // Convert result to wxVariant form
245 ConvertOleToVariant(vReturn
, retValue
);
246 // Mustn't release the dispatch pointer
247 if (vReturn
.vt
== VT_DISPATCH
)
249 vReturn
.pdispVal
= (IDispatch
*) NULL
;
251 ReleaseVariant(& vReturn
);
257 // Invoke a member function
258 wxVariant
wxAutomationObject::CallMethod(const wxString
& member
, int noArgs
, wxVariant args
[])
260 wxVariant retVariant
;
261 if (!Invoke(member
, DISPATCH_METHOD
, retVariant
, noArgs
, args
))
263 retVariant
.MakeNull();
268 wxVariant
wxAutomationObject::CallMethod(const wxString
& member
,
269 const wxVariant
& arg1
, const wxVariant
& arg2
,
270 const wxVariant
& arg3
, const wxVariant
& arg4
,
271 const wxVariant
& arg5
, const wxVariant
& arg6
)
273 const wxVariant
** args
= new const wxVariant
*[6];
305 wxVariant retVariant
;
306 if (!Invoke(member
, DISPATCH_METHOD
, retVariant
, i
, NULL
, args
))
308 retVariant
.MakeNull();
315 wxVariant
wxAutomationObject::GetProperty(const wxString
& property
, int noArgs
, wxVariant args
[]) const
317 wxVariant retVariant
;
318 if (!Invoke(property
, DISPATCH_PROPERTYGET
, retVariant
, noArgs
, args
))
320 retVariant
.MakeNull();
325 wxVariant
wxAutomationObject::GetProperty(const wxString
& property
,
326 const wxVariant
& arg1
, const wxVariant
& arg2
,
327 const wxVariant
& arg3
, const wxVariant
& arg4
,
328 const wxVariant
& arg5
, const wxVariant
& arg6
)
330 const wxVariant
** args
= new const wxVariant
*[6];
362 wxVariant retVariant
;
363 if (!Invoke(property
, DISPATCH_PROPERTYGET
, retVariant
, i
, NULL
, args
))
365 retVariant
.MakeNull();
371 bool wxAutomationObject::PutProperty(const wxString
& property
, int noArgs
, wxVariant args
[])
373 wxVariant retVariant
;
374 if (!Invoke(property
, DISPATCH_PROPERTYPUT
, retVariant
, noArgs
, args
))
381 bool wxAutomationObject::PutProperty(const wxString
& property
,
382 const wxVariant
& arg1
, const wxVariant
& arg2
,
383 const wxVariant
& arg3
, const wxVariant
& arg4
,
384 const wxVariant
& arg5
, const wxVariant
& arg6
)
386 const wxVariant
** args
= new const wxVariant
*[6];
418 wxVariant retVariant
;
419 bool ret
= Invoke(property
, DISPATCH_PROPERTYPUT
, retVariant
, i
, NULL
, args
);
425 // Uses DISPATCH_PROPERTYGET
426 // and returns a dispatch pointer. The calling code should call Release
427 // on the pointer, though this could be implicit by constructing an wxAutomationObject
428 // with it and letting the destructor call Release.
429 WXIDISPATCH
* wxAutomationObject::GetDispatchProperty(const wxString
& property
, int noArgs
, wxVariant args
[]) const
431 wxVariant retVariant
;
432 if (Invoke(property
, DISPATCH_PROPERTYGET
, retVariant
, noArgs
, args
))
434 if (retVariant
.GetType() == wxT("void*"))
436 return (WXIDISPATCH
*) retVariant
.GetVoidPtr();
440 return (WXIDISPATCH
*) NULL
;
443 // A way of initialising another wxAutomationObject with a dispatch object
444 bool wxAutomationObject::GetObject(wxAutomationObject
& obj
, const wxString
& property
, int noArgs
, wxVariant args
[]) const
446 WXIDISPATCH
* dispatch
= GetDispatchProperty(property
, noArgs
, args
);
449 obj
.SetDispatchPtr(dispatch
);
456 // Get a dispatch pointer from the current object associated
458 bool wxAutomationObject::GetInstance(const wxString
& classId
) const
464 IUnknown
* pUnk
= NULL
;
466 BasicString
unicodeName(classId
.mb_str());
468 if (FAILED(CLSIDFromProgID((BSTR
) unicodeName
, &clsId
)))
470 wxLogWarning(wxT("Cannot obtain CLSID from ProgID"));
474 if (FAILED(GetActiveObject(clsId
, NULL
, &pUnk
)))
476 wxLogWarning(wxT("Cannot find an active object"));
480 if (pUnk
->QueryInterface(IID_IDispatch
, (LPVOID
*) &m_dispatchPtr
) != S_OK
)
482 wxLogWarning(wxT("Cannot find IDispatch interface"));
489 // Get a dispatch pointer from a new object associated
490 // with the given class id
491 bool wxAutomationObject::CreateInstance(const wxString
& classId
) const
498 BasicString
unicodeName(classId
.mb_str());
500 if (FAILED(CLSIDFromProgID((BSTR
) unicodeName
, &clsId
)))
502 wxLogWarning(wxT("Cannot obtain CLSID from ProgID"));
506 // start a new copy of Excel, grab the IDispatch interface
507 if (FAILED(CoCreateInstance(clsId
, NULL
, CLSCTX_LOCAL_SERVER
, IID_IDispatch
, (void**)&m_dispatchPtr
)))
509 wxLogWarning(wxT("Cannot start an instance of this class."));
517 bool ConvertVariantToOle(const wxVariant
& variant
, VARIANTARG
& oleVariant
)
519 ClearVariant(&oleVariant
);
520 if (variant
.IsNull())
522 oleVariant
.vt
= VT_NULL
;
526 wxString
type(variant
.GetType());
528 if (type
== wxT("long"))
530 oleVariant
.vt
= VT_I4
;
531 oleVariant
.lVal
= variant
.GetLong() ;
533 else if (type
== wxT("double"))
535 oleVariant
.vt
= VT_R8
;
536 oleVariant
.dblVal
= variant
.GetDouble();
538 else if (type
== wxT("bool"))
540 oleVariant
.vt
= VT_BOOL
;
541 // 'bool' required for VC++ 4 apparently
542 #if defined(__WATCOMC__) || (defined(__VISUALC__) && (__VISUALC__ <= 1000))
543 oleVariant
.bool = variant
.GetBool();
545 oleVariant
.boolVal
= variant
.GetBool();
548 else if (type
== wxT("string"))
550 wxString
str( variant
.GetString() );
551 oleVariant
.vt
= VT_BSTR
;
552 oleVariant
.bstrVal
= ConvertStringToOle(str
);
554 // For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
555 #if wxUSE_TIMEDATE && !defined(__WATCOMC__)
556 else if (type
== wxT("date"))
558 wxDate
date( variant
.GetDate() );
559 oleVariant
.vt
= VT_DATE
;
561 if (!OleDateFromTm(date
.GetYear(), date
.GetMonth(), date
.GetDay(),
562 0, 0, 0, oleVariant
.date
))
565 else if (type
== wxT("time"))
567 wxTime
time( variant
.GetTime() );
568 oleVariant
.vt
= VT_DATE
;
570 if (!OleDateFromTm(time
.GetYear(), time
.GetMonth(), time
.GetDay(),
571 time
.GetHour(), time
.GetMinute(), time
.GetSecond(), oleVariant
.date
))
575 else if (type
== wxT("void*"))
577 oleVariant
.vt
= VT_DISPATCH
;
578 oleVariant
.pdispVal
= (IDispatch
*) variant
.GetVoidPtr();
580 else if (type
== wxT("list") || type
== wxT("stringlist"))
582 oleVariant
.vt
= VT_VARIANT
| VT_ARRAY
;
585 SAFEARRAYBOUND saBound
;
586 VARIANTARG
*pvargBase
;
590 int iCount
= variant
.GetCount();
593 saBound
.cElements
= iCount
;
595 psa
= SafeArrayCreate(VT_VARIANT
, 1, &saBound
);
599 SafeArrayAccessData(psa
, (void**)&pvargBase
);
602 for (i
= 0; i
< iCount
; i
++)
604 // copy each string in the list of strings
605 wxVariant
eachVariant(variant
[i
]);
606 if (!ConvertVariantToOle(eachVariant
, * pvarg
))
608 // memory failure: back out and free strings alloc'ed up to
609 // now, and then the array itself.
611 for (j
= 0; j
< i
; j
++)
613 SysFreeString(pvarg
->bstrVal
);
616 SafeArrayDestroy(psa
);
622 SafeArrayUnaccessData(psa
);
624 oleVariant
.parray
= psa
;
628 oleVariant
.vt
= VT_NULL
;
635 #define VT_TYPEMASK 0xfff
638 bool ConvertOleToVariant(const VARIANTARG
& oleVariant
, wxVariant
& variant
)
640 switch (oleVariant
.vt
& VT_TYPEMASK
)
644 wxString
str(ConvertStringFromOle(oleVariant
.bstrVal
));
652 if (!TmFromOleDate(oleVariant
.date
, tmTemp
))
655 wxDate
date(tmTemp
.tm_yday
, tmTemp
.tm_mon
, tmTemp
.tm_year
);
656 wxTime
time(date
, tmTemp
.tm_hour
, tmTemp
.tm_min
, tmTemp
.tm_sec
);
665 variant
= (long) oleVariant
.lVal
;
670 variant
= (long) oleVariant
.iVal
;
676 #if defined(__WATCOMC__) || (defined(_MSC_VER) && (_MSC_VER <= 1000) && !defined(__MWERKS__) ) //GC
677 #ifndef HAVE_BOOL // Can't use bool operator if no native bool type
678 variant
= (long) (oleVariant
.bool != 0);
680 variant
= (bool) (oleVariant
.bool != 0);
683 #ifndef HAVE_BOOL // Can't use bool operator if no native bool type
684 variant
= (long) (oleVariant
.boolVal
!= 0);
686 variant
= (bool) (oleVariant
.boolVal
!= 0);
693 variant
= oleVariant
.dblVal
;
700 int cDims
, cElements
, i
;
703 // Iterate the dimensions: number of elements is x*y*z
704 for (cDims
= 0, cElements
= 1;
705 cDims
< oleVariant
.parray
->cDims
; cDims
++)
706 cElements
*= oleVariant
.parray
->rgsabound
[cDims
].cElements
;
708 // Get a pointer to the data
709 HRESULT hr
= SafeArrayAccessData(oleVariant
.parray
, (void HUGEP
* FAR
*) & pvdata
);
713 for (i
= 0; i
< cElements
; i
++)
715 VARIANTARG
& oleElement
= pvdata
[i
];
717 if (!ConvertOleToVariant(oleElement
, vElement
))
720 variant
.Append(vElement
);
722 SafeArrayUnaccessData(oleVariant
.parray
);
727 variant
= (void*) oleVariant
.pdispVal
;
737 break; // Ignore Empty Variant, used only during destruction of objects
741 wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type"));
748 static BSTR
ConvertStringToOle(const wxString
& str
)
751 unsigned int len = strlen((const char*) str);
752 unsigned short* s = new unsigned short[len*2+2];
754 memset(s, 0, len*2+2);
755 for (i=0; i < len; i++)
758 BasicString
bstr(str
.mb_str());
762 static wxString
ConvertStringFromOle(BSTR bStr
)
764 int len
= SysStringLen(bStr
) + 1;
765 char *buf
= new char[len
];
766 (void)wcstombs( buf
, bStr
, len
);
773 // ----------------------------------------------------------------------------
775 // ----------------------------------------------------------------------------
777 // ctor takes an ANSI string and transforms it to Unicode
778 BasicString::BasicString(const char *sz
)
780 // get the size of required buffer
781 UINT lenAnsi
= strlen(sz
);
783 UINT lenWide
= lenAnsi
* 2 ;
785 UINT lenWide
= mbstowcs(NULL
, sz
, lenAnsi
);
789 m_wzBuf
= new OLECHAR
[lenWide
+ 1];
790 mbstowcs(m_wzBuf
, sz
, lenAnsi
);
791 m_wzBuf
[lenWide
] = L
'\0';
799 BasicString::~BasicString()
804 /////////////////////////////////////////////////////////////////////////////
805 // COleDateTime class HELPERS - implementation
807 BOOL
OleDateFromTm(WORD wYear
, WORD wMonth
, WORD wDay
,
808 WORD wHour
, WORD wMinute
, WORD wSecond
, DATE
& dtDest
)
810 // Validate year and month (ignore day of week and milliseconds)
811 if (wYear
> 9999 || wMonth
< 1 || wMonth
> 12)
814 // Check for leap year and set the number of days in the month
815 BOOL bLeapYear
= ((wYear
& 3) == 0) &&
816 ((wYear
% 100) != 0 || (wYear
% 400) == 0);
819 rgMonthDays
[wMonth
] - rgMonthDays
[wMonth
-1] +
820 ((bLeapYear
&& wDay
== 29 && wMonth
== 2) ? 1 : 0);
822 // Finish validating the date
823 if (wDay
< 1 || wDay
> nDaysInMonth
||
824 wHour
> 23 || wMinute
> 59 ||
830 // Cache the date in days and time in fractional days
834 //It is a valid date; make Jan 1, 1AD be 1
835 nDate
= wYear
*365L + wYear
/4 - wYear
/100 + wYear
/400 +
836 rgMonthDays
[wMonth
-1] + wDay
;
838 // If leap year and it's before March, subtract 1:
839 if (wMonth
<= 2 && bLeapYear
)
842 // Offset so that 12/30/1899 is 0
845 dblTime
= (((long)wHour
* 3600L) + // hrs in seconds
846 ((long)wMinute
* 60L) + // mins in seconds
847 ((long)wSecond
)) / 86400.;
849 dtDest
= (double) nDate
+ ((nDate
>= 0) ? dblTime
: -dblTime
);
854 BOOL
TmFromOleDate(DATE dtSrc
, struct tm
& tmDest
)
856 // The legal range does not actually span year 0 to 9999.
857 if (dtSrc
> MAX_DATE
|| dtSrc
< MIN_DATE
) // about year 100 to about 9999
860 long nDays
; // Number of days since Dec. 30, 1899
861 long nDaysAbsolute
; // Number of days since 1/1/0
862 long nSecsInDay
; // Time in seconds since midnight
863 long nMinutesInDay
; // Minutes in day
865 long n400Years
; // Number of 400 year increments since 1/1/0
866 long n400Century
; // Century within 400 year block (0,1,2 or 3)
867 long n4Years
; // Number of 4 year increments since 1/1/0
868 long n4Day
; // Day within 4 year block
869 // (0 is 1/1/yr1, 1460 is 12/31/yr4)
870 long n4Yr
; // Year within 4 year block (0,1,2 or 3)
871 BOOL bLeap4
= TRUE
; // TRUE if 4 year block includes leap year
873 double dblDate
= dtSrc
; // tempory serial date
875 // If a valid date, then this conversion should not overflow
876 nDays
= (long)dblDate
;
878 // Round to the second
879 dblDate
+= ((dtSrc
> 0.0) ? HALF_SECOND
: -HALF_SECOND
);
881 nDaysAbsolute
= (long)dblDate
+ 693959L; // Add days from 1/1/0 to 12/30/1899
883 dblDate
= fabs(dblDate
);
884 nSecsInDay
= (long)((dblDate
- floor(dblDate
)) * 86400.);
886 // Calculate the day of week (sun=1, mon=2...)
887 // -1 because 1/1/0 is Sat. +1 because we want 1-based
888 tmDest
.tm_wday
= (int)((nDaysAbsolute
- 1) % 7L) + 1;
890 // Leap years every 4 yrs except centuries not multiples of 400.
891 n400Years
= (long)(nDaysAbsolute
/ 146097L);
893 // Set nDaysAbsolute to day within 400-year block
894 nDaysAbsolute
%= 146097L;
896 // -1 because first century has extra day
897 n400Century
= (long)((nDaysAbsolute
- 1) / 36524L);
900 if (n400Century
!= 0)
902 // Set nDaysAbsolute to day within century
903 nDaysAbsolute
= (nDaysAbsolute
- 1) % 36524L;
905 // +1 because 1st 4 year increment has 1460 days
906 n4Years
= (long)((nDaysAbsolute
+ 1) / 1461L);
909 n4Day
= (long)((nDaysAbsolute
+ 1) % 1461L);
913 n4Day
= (long)nDaysAbsolute
;
918 // Leap century - not special case!
919 n4Years
= (long)(nDaysAbsolute
/ 1461L);
920 n4Day
= (long)(nDaysAbsolute
% 1461L);
925 // -1 because first year has 366 days
926 n4Yr
= (n4Day
- 1) / 365;
929 n4Day
= (n4Day
- 1) % 365;
937 // n4Day is now 0-based day of year. Save 1-based day of year, year number
938 tmDest
.tm_yday
= (int)n4Day
+ 1;
939 tmDest
.tm_year
= n400Years
* 400 + n400Century
* 100 + n4Years
* 4 + n4Yr
;
941 // Handle leap year: before, on, and after Feb. 29.
942 if (n4Yr
== 0 && bLeap4
)
953 // Pretend it's not a leap year for month/day comp.
958 // Make n4DaY a 1-based day of non-leap year and compute
959 // month/day for everything but Feb. 29.
962 // Month number always >= n/32, so save some loop time */
963 for (tmDest
.tm_mon
= (n4Day
>> 5) + 1;
964 n4Day
> rgMonthDays
[tmDest
.tm_mon
]; tmDest
.tm_mon
++);
966 tmDest
.tm_mday
= (int)(n4Day
- rgMonthDays
[tmDest
.tm_mon
-1]);
970 tmDest
.tm_hour
= tmDest
.tm_min
= tmDest
.tm_sec
= 0;
973 tmDest
.tm_sec
= (int)nSecsInDay
% 60L;
974 nMinutesInDay
= nSecsInDay
/ 60L;
975 tmDest
.tm_min
= (int)nMinutesInDay
% 60;
976 tmDest
.tm_hour
= (int)nMinutesInDay
/ 60;
982 // this function is not used
984 void TmConvertToStandardFormat(struct tm
& tmSrc
)
986 // Convert afx internal tm to format expected by runtimes (_tcsftime, etc)
987 tmSrc
.tm_year
-= 1900; // year is based on 1900
988 tmSrc
.tm_mon
-= 1; // month of year is 0-based
989 tmSrc
.tm_wday
-= 1; // day of week is 0-based
990 tmSrc
.tm_yday
-= 1; // day of year is 0-based
993 double DoubleFromDate(DATE dt
)
995 // No problem if positive
999 // If negative, must convert since negative dates not continuous
1000 // (examples: -1.25 to -.75, -1.50 to -.50, -1.75 to -.25)
1001 double temp
= ceil(dt
);
1002 return temp
- (dt
- temp
);
1005 DATE
DateFromDouble(double dbl
)
1007 // No problem if positive
1011 // If negative, must convert since negative dates not continuous
1012 // (examples: -.75 to -1.25, -.50 to -1.50, -.25 to -1.75)
1013 double temp
= floor(dbl
); // dbl is now whole part
1014 return temp
+ (temp
- dbl
);
1021 * Zeros a variant structure without regard to current contents
1023 static void ClearVariant(VARIANTARG
*pvarg
)
1025 pvarg
->vt
= VT_EMPTY
;
1026 pvarg
->wReserved1
= 0;
1027 pvarg
->wReserved2
= 0;
1028 pvarg
->wReserved3
= 0;
1035 * Clears a particular variant structure and releases any external objects
1036 * or memory contained in the variant. Supports the data types listed above.
1038 static void ReleaseVariant(VARIANTARG
*pvarg
)
1041 VARIANTARG _huge
*pvargArray
;
1042 long lLBound
, lUBound
, l
;
1044 vt
= pvarg
->vt
& 0xfff; // mask off flags
1046 // check if an array. If so, free its contents, then the array itself.
1047 if (V_ISARRAY(pvarg
))
1049 // variant arrays are all this routine currently knows about. Since a
1050 // variant can contain anything (even other arrays), call ourselves
1052 if (vt
== VT_VARIANT
)
1054 SafeArrayGetLBound(pvarg
->parray
, 1, &lLBound
);
1055 SafeArrayGetUBound(pvarg
->parray
, 1, &lUBound
);
1057 if (lUBound
> lLBound
)
1061 SafeArrayAccessData(pvarg
->parray
, (void**)&pvargArray
);
1063 for (l
= 0; l
< lUBound
; l
++)
1065 ReleaseVariant(pvargArray
);
1069 SafeArrayUnaccessData(pvarg
->parray
);
1074 wxLogWarning(wxT("ReleaseVariant: Array contains non-variant type"));
1077 // Free the array itself.
1078 SafeArrayDestroy(pvarg
->parray
);
1085 if (pvarg
->pdispVal
)
1086 pvarg
->pdispVal
->Release();
1090 SysFreeString(pvarg
->bstrVal
);
1096 case VT_ERROR
: // to avoid erroring on an error return from Excel
1097 // no work for these types
1101 wxLogWarning(wxT("ReleaseVariant: Unknown type"));
1106 ClearVariant(pvarg
);
1111 void ShowException(LPOLESTR szMember
, HRESULT hr
, EXCEPINFO
*pexcep
, unsigned int uiArgErr
)
1115 switch (GetScode(hr
))
1117 case DISP_E_UNKNOWNNAME
:
1118 wsprintf(szBuf
, L
"%s: Unknown name or named argument.", szMember
);
1121 case DISP_E_BADPARAMCOUNT
:
1122 wsprintf(szBuf
, L
"%s: Incorrect number of arguments.", szMember
);
1125 case DISP_E_EXCEPTION
:
1126 wsprintf(szBuf
, L
"%s: Error %d: ", szMember
, pexcep
->wCode
);
1127 if (pexcep
->bstrDescription
!= NULL
)
1128 lstrcat(szBuf
, pexcep
->bstrDescription
);
1130 lstrcat(szBuf
, L
"<<No Description>>");
1133 case DISP_E_MEMBERNOTFOUND
:
1134 wsprintf(szBuf
, L
"%s: method or property not found.", szMember
);
1137 case DISP_E_OVERFLOW
:
1138 wsprintf(szBuf
, L
"%s: Overflow while coercing argument values.", szMember
);
1141 case DISP_E_NONAMEDARGS
:
1142 wsprintf(szBuf
, L
"%s: Object implementation does not support named arguments.",
1146 case DISP_E_UNKNOWNLCID
:
1147 wsprintf(szBuf
, L
"%s: The locale ID is unknown.", szMember
);
1150 case DISP_E_PARAMNOTOPTIONAL
:
1151 wsprintf(szBuf
, L
"%s: Missing a required parameter.", szMember
);
1154 case DISP_E_PARAMNOTFOUND
:
1155 wsprintf(szBuf
, L
"%s: Argument not found, argument %d.", szMember
, uiArgErr
);
1158 case DISP_E_TYPEMISMATCH
:
1159 wsprintf(szBuf
, L
"%s: Type mismatch, argument %d.", szMember
, uiArgErr
);
1163 wsprintf(szBuf
, L
"%s: Unknown error occured.", szMember
);
1167 wxLogWarning(szBuf
);
1172 #endif // __WATCOMC__