#endif
#include "wx/log.h"
+
+#include <math.h>
+#include <time.h>
+
+// Watcom C++ gives a linker error if this is compiled in.
+#ifndef __WATCOMC__
+
#include "wx/msw/ole/automtn.h"
-#include <windows.h>
+#include "wx/msw/private.h"
+
+#include <wtypes.h>
+#include <unknwn.h>
+#include <ole2.h>
+#define _huge
#include <ole2ver.h>
#include <oleauto.h>
-#include <math.h>
-#include <time.h>
+
+// wrapper around BSTR type (by Vadim Zeitlin)
+
+class WXDLLEXPORT 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
+};
+
+// Convert variants
+static bool ConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant) ;
+static bool ConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant) ;
// Convert string to Unicode
static BSTR ConvertStringToOle(const wxString& str);
static BOOL OleDateFromTm(WORD wYear, WORD wMonth, WORD wDay,
WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest);
static BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest);
-static void TmConvertToStandardFormat(struct tm& tmSrc);
-static double DoubleFromDate(DATE dt);
-static DATE DateFromDouble(double dbl);
static void ClearVariant(VARIANTARG *pvarg) ;
static void ReleaseVariant(VARIANTARG *pvarg) ;
for (i = 0; i < noArgs; i++)
{
// Again, reverse args
- wxVariant& theVariant = INVOKEARG((noArgs-1) - i);
- if (!ConvertVariantToOle(theVariant, oleArgs[i]))
+ if (!ConvertVariantToOle(INVOKEARG((noArgs-1) - i), oleArgs[i]))
return FALSE; // TODO: clean up memory at this point
}
wxVariant retVariant;
if (Invoke(property, DISPATCH_PROPERTYGET, retVariant, noArgs, args))
{
- if (retVariant.GetType() == "void*")
+ if (retVariant.GetType() == wxT("void*"))
{
return (WXIDISPATCH*) retVariant.GetVoidPtr();
}
CLSID clsId;
IUnknown * pUnk = NULL;
- BasicString unicodeName((const char*) classId);
+ BasicString unicodeName(classId.mb_str());
if (FAILED(CLSIDFromProgID((BSTR) unicodeName, &clsId)))
{
- wxLogWarning("Cannot obtain CLSID from ProgID");
+ wxLogWarning(wxT("Cannot obtain CLSID from ProgID"));
return FALSE;
}
if (FAILED(GetActiveObject(clsId, NULL, &pUnk)))
{
- wxLogWarning("Cannot find an active object");
+ wxLogWarning(wxT("Cannot find an active object"));
return FALSE;
}
if (pUnk->QueryInterface(IID_IDispatch, (LPVOID*) &m_dispatchPtr) != S_OK)
{
- wxLogWarning("Cannot find IDispatch interface");
+ wxLogWarning(wxT("Cannot find IDispatch interface"));
return FALSE;
}
return FALSE;
CLSID clsId;
- IUnknown * pUnk = NULL;
- BasicString unicodeName((const char*) classId);
+ BasicString unicodeName(classId.mb_str());
if (FAILED(CLSIDFromProgID((BSTR) unicodeName, &clsId)))
{
- wxLogWarning("Cannot obtain CLSID from ProgID");
+ wxLogWarning(wxT("Cannot obtain CLSID from ProgID"));
return FALSE;
}
// start a new copy of Excel, grab the IDispatch interface
if (FAILED(CoCreateInstance(clsId, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void**)&m_dispatchPtr)))
{
- wxLogWarning("Cannot start an instance of this class.");
+ wxLogWarning(wxT("Cannot start an instance of this class."));
return FALSE;
}
}
-bool wxAutomationObject::ConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant)
+bool ConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant)
{
ClearVariant(&oleVariant);
if (variant.IsNull())
wxString type(variant.GetType());
- if (type == "long")
+ if (type == wxT("long"))
{
oleVariant.vt = VT_I4;
oleVariant.lVal = variant.GetLong() ;
}
- else if (type == "double")
+ else if (type == wxT("double"))
{
oleVariant.vt = VT_R8;
oleVariant.dblVal = variant.GetDouble();
}
- else if (type == "bool")
+ else if (type == wxT("bool"))
{
oleVariant.vt = VT_BOOL;
+ // 'bool' required for VC++ 4 apparently
+#if defined(__WATCOMC__) || (defined(__VISUALC__) && (__VISUALC__ <= 1000))
+ oleVariant.bool = variant.GetBool();
+#else
oleVariant.boolVal = variant.GetBool();
+#endif
}
- else if (type == "string")
+ else if (type == wxT("string"))
{
wxString str( variant.GetString() );
oleVariant.vt = VT_BSTR;
oleVariant.bstrVal = ConvertStringToOle(str);
}
- else if (type == "date")
+// For some reason, Watcom C++ can't link variant.cpp with time/date classes compiled
+#if wxUSE_TIMEDATE && !defined(__WATCOMC__)
+ else if (type == wxT("date"))
{
wxDate date( variant.GetDate() );
oleVariant.vt = VT_DATE;
0, 0, 0, oleVariant.date))
return FALSE;
}
- else if (type == "time")
+ else if (type == wxT("time"))
{
wxTime time( variant.GetTime() );
oleVariant.vt = VT_DATE;
time.GetHour(), time.GetMinute(), time.GetSecond(), oleVariant.date))
return FALSE;
}
- else if (type == "void*")
+#endif
+ else if (type == wxT("void*"))
{
oleVariant.vt = VT_DISPATCH;
oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr();
}
- else if (type == "list" || type == "stringlist")
+ else if (type == wxT("list") || type == wxT("stringlist"))
{
oleVariant.vt = VT_VARIANT | VT_ARRAY;
#define VT_TYPEMASK 0xfff
#endif
-bool wxAutomationObject::ConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
+bool ConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
{
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_BOOL:
{
+#if defined(__WATCOMC__) || (defined(_MSC_VER) && (_MSC_VER <= 1000) && !defined(__MWERKS__) ) //GC
+#ifndef HAVE_BOOL // Can't use bool operator if no native bool type
+ variant = (long) (oleVariant.bool != 0);
+#else
+ variant = (bool) (oleVariant.bool != 0);
+#endif
+#else
variant = (bool) (oleVariant.boolVal != 0);
+#endif
break;
}
case VT_R8:
}
default:
{
- wxLogError("wxAutomationObject::ConvertOleToVariant: Unknown variant value type");
+ wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type"));
return FALSE;
}
}
for (i=0; i < len; i++)
s[i*2] = str[i];
*/
- BasicString bstr((const char*) str);
+ BasicString bstr(str.mb_str());
return bstr.Get();
}
{
int len = SysStringLen(bStr) + 1;
char *buf = new char[len];
- int i = wcstombs( buf, bStr, len);
+ (void)wcstombs( buf, bStr, len);
wxString str(buf);
delete[] buf;
{
// get the size of required buffer
UINT lenAnsi = strlen(sz);
+ #ifdef __MWERKS__
+ UINT lenWide = lenAnsi * 2 ;
+ #else
UINT lenWide = mbstowcs(NULL, sz, lenAnsi);
+ #endif
if ( lenWide > 0 ) {
m_wzBuf = new OLECHAR[lenWide + 1];
return TRUE;
}
+// this function is not used
+#if 0
void TmConvertToStandardFormat(struct tm& tmSrc)
{
// Convert afx internal tm to format expected by runtimes (_tcsftime, etc)
double temp = floor(dbl); // dbl is now whole part
return temp + (temp - dbl);
}
+#endif // 0
/*
* ClearVariant
}
else
{
- wxLogWarning("ReleaseVariant: Array contains non-variant type");
+ wxLogWarning(wxT("ReleaseVariant: Array contains non-variant type"));
}
// Free the array itself.
break;
default:
- wxLogWarning("ReleaseVariant: Unknown type");
+ wxLogWarning(wxT("ReleaseVariant: Unknown type"));
break;
}
}
#endif
+#endif // __WATCOMC__
+
projects / wxWidgets.git / blobdiff