STDMETHODIMP CPmcDB::readArchiveValue(
BSTR tagName,
VARIANT date,
VARIANT * tagValue
)
{
SYSTEMTIME st;
FILETIME ft;
TAG_NAME tn;
hislog_item_t value;
VARIANT dd;
HRESULT hr;
if(date.vt != VT_DATE){
// BUGBUG: not tested
hr = VariantChangeType(&dd, &date, 0, VT_DATE);
if(FAILED(hr)){
return hr;
}
date = dd;
}
VariantTimeToSystemTime(date.date, &st);
SystemTimeToFileTime(&st, &ft);
tagname_by_textW(&tn, tagName);
queryHisData(&tn, &ft, 1, 1);
getHisData(&value);
pmc_value_to_variant(&value, tagValue);
return S_OK;
}
void MAPIAppointment::SetEndDate(FILETIME ft, bool bAllday)
{
SYSTEMTIME st, localst;
BOOL bUseLocal = false;
FileTimeToSystemTime(&ft, &st);
if (bAllday) // if AllDay appt, subtract one from the end date for Zimbra friendliness
{
double dat = -1;
if (SystemTimeToVariantTime(&st, &dat))
{
dat -= 1;
VariantTimeToSystemTime(dat, &st);
}
}
else
{
if ((m_bIsRecurring) || (m_iExceptionType == NORMAL_EXCEPTION))
{
TIME_ZONE_INFORMATION localTimeZone = {0};
//GetTimeZoneInformation(&localTimeZone);
pInvTz->PopulateTimeZoneInfo(localTimeZone);
bUseLocal = SystemTimeToTzSpecificLocalTime(&localTimeZone, &st, &localst);
}
}
m_pEndDate = (bUseLocal) ? Zimbra::Util::FormatSystemTime(localst, FALSE, TRUE)
: Zimbra::Util::FormatSystemTime(st, TRUE, TRUE);
}
bool CAdminPageThreadWnd::VariantTimeToLocalTime(DATE date, SYSTEMTIME* psystime)
{
// Convert the VARIANT time to a SYSTEMTIME structure
SYSTEMTIME systimeUTC, systime;
if (!VariantTimeToSystemTime(date, &systimeUTC))
return false;
// Convert the SYSTEMTIME from UTC to the local time zone
if (!SystemTimeToTzSpecificLocalTime(NULL, &systimeUTC, &systime))
{
TIME_ZONE_INFORMATION tz;
DWORD zone = GetTimeZoneInformation(&tz);
if (zone != TIME_ZONE_ID_UNKNOWN)
{
LONG lBias = tz.Bias;
if (zone == TIME_ZONE_ID_STANDARD)
lBias += tz.StandardBias;
else //TIME_ZONE_ID_DAYLIGHT:
lBias += tz.DaylightBias;
FILETIME ft;
VERIFY(SystemTimeToFileTime(&systimeUTC, &ft));
__int64 time64 = ((__int64)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
__int64 bias = (__int64)lBias * (__int64)600000000;
time64 -= bias;
ft.dwHighDateTime = (DWORD)(time64 >> 32);
ft.dwLowDateTime = (DWORD)time64;
VERIFY(FileTimeToSystemTime(&ft,&systime));
}
void CSiteDir::BuildFromDatabase()
{
WCHAR sql[256];
swprintf(sql, L"SELECT id,filename,type,file_size,file_date FROM files WHERE parent_id = %d", m_dbid);
_variant_t va;
ADODB::_RecordsetPtr recordset = m_pWebSite->m_siteDataConnection->Execute(sql, &va, ADODB::adCmdText);
CArray<CSiteDir*,CSiteDir*> dirs;
while (recordset->EndOfFile == false)
{
CSiteItem* pItem;
BYTE type = recordset->Fields->Item[_bstr_t("type")]->Value.lVal;
if (type == 1) // Directory
{
CSiteDir* pDir = new CSiteDir;
pItem = pDir;
strcpy(pDir->m_wfd.cFileName, _bstr_t(recordset->Fields->Item[_bstr_t("filename")]->Value));
_makepath(pDir->m_pathName.GetBuffer(512), NULL, m_pathName, pDir->m_wfd.cFileName, NULL);
pDir->m_pathName.ReleaseBuffer();
dirs.Add(pDir);
}
else if (type == 2) // File
{
CSiteFile* pFile = new CSiteFile;
pItem = pFile;
strcpy(pFile->m_wfd.cFileName, _bstr_t(recordset->Fields->Item[_bstr_t("filename")]->Value));
pFile->m_wfd.nFileSizeLow = recordset->Fields->Item[_bstr_t("file_size")]->Value.lVal;
}
else
ATLASSERT(0);
if (pItem)
{
pItem->m_pWebSite = m_pWebSite;
pItem->m_dbid = recordset->Fields->Item[_bstr_t("id")]->Value.lVal;
// pItem->m_name = pItem->m_wfd.cFileName; // ??
// lastWriteDate
double lastWriteTime = recordset->Fields->Item[_bstr_t("file_date")]->Value;
SYSTEMTIME systime;
VariantTimeToSystemTime(lastWriteTime, &systime);
SystemTimeToFileTime(&systime, &pItem->m_wfd.ftLastWriteTime);
AddChildTail(pItem);
}
recordset->MoveNext();
}
for (int i = 0; i < dirs.GetSize(); i++)
{
dirs[i]->BuildFromDatabase(); // Recurse
}
}
BOOL CADORecordset::GetFieldValue(int nIndex, SYSTEMTIME& time)
{
_variant_t vtFld;
_variant_t vtIndex;
DOUBLE vt;
vtIndex.vt = VT_I2;
vtIndex.iVal = nIndex;
try
{
vtFld = m_pRecordset->Fields->GetItem(vtIndex)->Value;
switch(vtFld.vt)
{
case VT_DATE:
{
vt = vtFld.date;
VariantTimeToSystemTime(vt,&time);
}
break;
case VT_EMPTY:
case VT_NULL:
memset(&time,0,sizeof(SYSTEMTIME));
/*time.SetStatus(COleDateTime::null);**/
break;
default:
return FALSE;
}
return TRUE;
}
catch(_com_error &e)
{
dump_com_error(e);
return FALSE;
}
}
HRESULT
ceDateToFileTime(
IN DATE const *pDate,
OUT FILETIME *pft)
{
SYSTEMTIME st;
HRESULT hr = S_OK;
if (*pDate == 0.0)
{
GetSystemTime(&st);
}
else
{
if (!VariantTimeToSystemTime(*pDate, &st))
{
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
_JumpError(hr, error, "VariantTimeToSystemTime");
}
}
if (!SystemTimeToFileTime(&st, pft))
{
hr = ceHLastError();
_JumpError(hr, error, "SystemTimeToFileTime");
}
error:
return(hr);
}
// 通过ole的方式读取单元格内容，由于ole才支持公式，所以tokit只在单元格含公式时才调用本接口，除此之外通过libxl库来调用，因为libxl读取速度快很多
std::string& ole_get_cell_str(COleSafeArray &ole_safe_array, int row, int col)
{
static const int prec=std::numeric_limits<long long>::digits10 + 10; // 18
static COleVariant vResult;
static CString str;
//字符串
static long read_address[2];
static VARIANT val;
static std::string result;
read_address[0] = row;
read_address[1] = col;
ole_safe_array.GetElement(read_address, &val);
vResult = val;
switch(vResult.vt){
case VT_BSTR:
{
//字符串
const wchar_t *w = vResult.bstrVal;
// const std::wstring wstr(w);
return strtool::wstring2string(w);
}
//单元格空的
case VT_EMPTY:
//整数
case VT_INT:
result = "";
break;
//8字节的数字
case VT_R8:
{
static std::ostringstream oss;
oss.str("");
oss.precision(prec);//覆盖默认精度
oss << vResult.dblVal;
result = oss.str();
break;
}
//时间格式
case VT_DATE:
{
SYSTEMTIME st;
VariantTimeToSystemTime(vResult.date, &st);
CTime tm(st);
str = tm.Format("%Y-%m-%d");
break;
}
default:
result = "";
break;
}
return result;
}
wchar_t *Date2String(DATE date){
wchar_t *buf;
SYSTEMTIME st;
VariantTimeToSystemTime(date, &st);
buf = (wchar_t*)malloc(20 * sizeof(wchar_t));
//swprintf(buf,L"%04d/%02d/%02d %02d:%02d:%02d",st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);
return buf;
}
CString Illusion_ExcelFile::get_cell_cstring(long iline, long icolumn)
{
COleVariant vResult ;
CString str;
//字符串
if (already_preload_ == FALSE)
{
CRange range;
_variant_t v_row(iline);
_variant_t v_column(icolumn);
range.AttachDispatch(excel_current_range_.get_Item(v_row, v_column).pdispVal, true);
vResult = range.get_Value2();
range.ReleaseDispatch();
}
//如果数据依据预先加载了
else
{
long read_address[2];
VARIANT val;
read_address[0] = iline;
read_address[1] = icolumn;
ole_safe_array_.GetElement(read_address, &val);
vResult = val;
}
if (vResult.vt == VT_BSTR)
{
str = vResult.bstrVal;
}
//整数
else if (vResult.vt == VT_INT)
{
str.Format(_T("%d"), vResult.pintVal);
}
//8字节的数字
else if (vResult.vt == VT_R8)
{
str.Format(_T("%.6f"), vResult.dblVal);
}
//时间格式
else if (vResult.vt == VT_DATE)
{
SYSTEMTIME st;
VariantTimeToSystemTime(vResult.date, &st);
CTime tm(st);
str = tm.Format(_T("%Y-%m-%d"));
}
//单元格空的
else if (vResult.vt == VT_EMPTY)
{
str = "";
}
return str;
}
void CBoxHttpResponse::put_ExpiresAbsolute(DATE dateExpires)
{
SYSTEMTIME st;
CString strTime;
VariantTimeToSystemTime(dateExpires, &st);
TimeToString(st, strTime);
m_pAccept->SetHeader(_T("Expires"), strTime);
}
static QDateTime DATEToQDateTime(DATE ole)
{
SYSTEMTIME stime;
if (ole >= 949998 || VariantTimeToSystemTime(ole, &stime) == false)
return QDateTime();
QDate date(stime.wYear, stime.wMonth, stime.wDay);
QTime time(stime.wHour, stime.wMinute, stime.wSecond, stime.wMilliseconds);
return QDateTime(date, time);
}
CString IllusionExcelFile::GetCellString(long irow, long icolumn)
{
COleVariant vResult;
CString str;
//字符串
if (already_preload_ == FALSE)
{
excel_current_range_.ReleaseDispatch();
excel_current_range_.AttachDispatch(excel_current_ranges_.get_Item (COleVariant((long)irow),COleVariant((long)icolumn)).pdispVal, true);
vResult =excel_current_range_.get_Value2();
}
//如果数据依据预先加载了
else
{
long read_address[2];
VARIANT val;
read_address[0] = irow;
read_address[1] = icolumn;
ole_safe_array_.GetElement(read_address, &val);
vResult = val;
}
if(vResult.vt == VT_BSTR)
{
str=vResult.bstrVal;
}
//整数
else if (vResult.vt==VT_INT)
{
str.Format(_T("%d"),vResult.pintVal);
}
//8字节的数字
else if (vResult.vt==VT_R8)
{
str.Format(_T("%0.0f"),vResult.dblVal);
}
//时间格式
else if(vResult.vt==VT_DATE)
{
SYSTEMTIME st;
VariantTimeToSystemTime(vResult.date, &st);
CTime tm(st);
str=tm.Format(_T("%Y-%m-%d"));
}
//单元格空的
else if(vResult.vt==VT_EMPTY)
{
str=_T("");
}
return str;
}
CTime MyTools::GetTimeFromString(CString timerStr){
//CString strCString="2011-03-24 14:45:22";
COleVariant vtime(timerStr);
vtime.ChangeType(VT_DATE);
COleDateTime oletime = vtime;
SYSTEMTIME systime;
VariantTimeToSystemTime(oletime, &systime);
//return CTime(oletime);
CTime time(oletime);
return time;
}
TSystemTime::TSystemTime(const tstring& s, LCID locale)
{
_USES_CONVERSION_A;
LPCOLESTR olestr = _A2W_A(s.c_str());
const LCID lcid = locale ? locale : GetUserDefaultLCID();
const ULONG flags = 0;
DATE date;
HRESULT hr = VarDateFromStr(VARDATEFROMSTR_PARAM1(olestr), lcid, flags, &date);
if (hr != S_OK) TXOwl::Raise(IDS_SYSTEMTIMEPARSEFAIL);
int r = VariantTimeToSystemTime(date, this);
if (r == FALSE) TXOwl::Raise(IDS_SYSTEMTIMEPARSEFAIL);
}
static BOOL VariantTimeToSystemTimeWithMsec(const double ft, SYSTEMTIME* st)
{
BOOL rc = FALSE;
double halfsecond = MSFT_FLOAT_1000MILLISECONDS / 2.0; // a half of 1000 msec
if ( VariantTimeToSystemTime(ft - halfsecond, st) != FALSE )
{
double fraction = ft - (unsigned long)ft; // extracts the fraction part
double hours;
hours = fraction = (fraction - (int)fraction) * 24;
double minutes;
minutes = (hours - (int)hours) * 60;
double seconds;
seconds = (minutes - (int)minutes) * 60;
double milliseconds;
milliseconds = (seconds - (int)seconds) * 1000;
milliseconds = milliseconds + 0.5; // rounding off millisecond to the nearest millisecond
if ( milliseconds < 1.0 || milliseconds > 999.0 ) //Fractional calculations may yield in results like
milliseconds = 0; // 0.00001 or 999.9999 which should actually be zero (slightly above or below limits are actually zero)
if ( milliseconds )
{
st->wMilliseconds = (WORD) milliseconds;
rc = TRUE;
}
else
{
rc = VariantTimeToSystemTime(ft, st); //if there is 0 milliseconds, then we don't have the problem
}
}
return rc;
}
CString GetCollectDate(_RecordsetPtr m_pRecordset, char* key)
{
try{
VARIANT var = m_pRecordset->GetCollect(key);
if(var.vt == VT_NULL)
return "";
SYSTEMTIME st;
VariantTimeToSystemTime(var.date, &st);
CString date;
date.Format("%d-%02d-%02d %02d:%02d", st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute);
return date;
}
catch(_com_error& e){
AfxMessageBox(e.ErrorMessage());
}
return "";
}
void CNHSQLServerDBO::SynchronizeDBTime()
{
_ConnectionPtr pConnection(NULL);
if (0x00 == CNHSQLServerDBO::OpenDB(pConnection))
{
wchar_t wchSql[1024] = {L'\0'};
ZeroMemory(wchSql, sizeof(wchSql));
_snwprintf_s(wchSql,_countof(wchSql) ,_TRUNCATE, L"select GETDATE() as DateTime;");
_RecordsetPtr pRecordset(NULL);
if (0x00 == CNHSQLServerDBO::OpenQuery(pConnection, pRecordset, wchSql))
{
if (!pRecordset->adoEOF)
{
_variant_t v;
v.ChangeType(VT_NULL);
CNHSQLServerDBO::GetFieldValue(pRecordset, v, L"DateTime");
if (v.vt == VT_DATE)
{
HANDLE token;
//提升权限
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&token))
{
}
TOKEN_PRIVILEGES tkp;
tkp.PrivilegeCount = 1;
::LookupPrivilegeValue(NULL,SE_SYSTEMTIME_NAME,&tkp.Privileges[0].Luid);
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if(!AdjustTokenPrivileges(token,FALSE,&tkp,sizeof(tkp),NULL,NULL))
{
}
CloseHandle(token);
DATE dt = static_cast<DATE>(v);
SYSTEMTIME st;
VariantTimeToSystemTime(dt, &st);
SetLocalTime(&st);
}
}
}
CNHSQLServerDBO::CloseQuery(pRecordset);
CNHSQLServerDBO::CloseDB(pConnection);
}
}
static int calcAgeFromBirthDate(double dDate)
{
if (dDate > 0)
{ // date is stored as double with unit equal to a day, incrementing since 1/1/1900 0:00 GMT
SYSTEMTIME sDate = {0};
if (VariantTimeToSystemTime(dDate + 2, &sDate))
{
SYSTEMTIME sToday = {0};
GetLocalTime(&sToday);
int nAge = sToday.wYear - sDate.wYear;
if (sToday.wMonth < sDate.wMonth || (sToday.wMonth == sDate.wMonth && sToday.wDay < sDate.wDay))
nAge--;
return nAge;
}
}
return 0;
}
bool CAdoRecordset::GetValue(char* strFieldName, tm& time, bool &nIsNull)
{
_variant_t vt;
bool rtn= GetValue(strFieldName,vt,nIsNull);
if(vt.vt == VT_NULL || vt.vt == VT_EMPTY)
{
nIsNull = true;
return true;
}
SYSTEMTIME dt;
VariantTimeToSystemTime(vt.date, &dt);
time.tm_year = dt.wYear;
time.tm_mon = dt.wMonth;
time.tm_mday = dt.wDay;
time.tm_hour = dt.wHour;
time.tm_min = dt.wMinute;
time.tm_sec = dt.wSecond;
time.tm_isdst = dt.wMilliseconds;
return rtn;
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
// Compute the total number of elements in all array dimensions
int cElements = 1;
for ( int cDims = 0; cDims < oleVariant.parray->cDims; cDims++ )
cElements *= oleVariant.parray->rgsabound[cDims].cElements;
// Get a pointer to the data
void* pvdata;
HRESULT hr = SafeArrayAccessData(oleVariant.parray, &pvdata);
if ( FAILED(hr) )
return false;
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_VARIANT:
{
variant.ClearList();
VARIANTARG *variant_data=(VARIANTARG*)pvdata;
for ( int i = 0; i < cElements; i++ )
{
VARIANTARG& oleElement = variant_data[i];
wxVariant vElement;
if ( !wxConvertOleToVariant(oleElement, vElement) )
{
ok = false;
variant.ClearList();
break;
}
variant.Append(vElement);
}
}
break;
case VT_BSTR:
{
wxArrayString strings;
BSTR *string_val=(BSTR*)pvdata;
for ( int i = 0; i < cElements; ++i )
{
wxString str=wxConvertStringFromOle(*string_val);
strings.Add(str);
++string_val;
}
variant=strings;
}
break;
default:
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
ok = false;
break;
}
SafeArrayUnaccessData(oleVariant.parray);
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
variant.MakeNull();
break;
case VT_EMPTY:
break; // Ignore Empty Variant, used only during destruction of objects
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
// 数据加载操作
bool DBRankThread::LoadRanks(tagRankInfo *pRankInfo)
{
if(NULL == pRankInfo)
return false;
// DWORD dwBegin = timeGetTime();
map<long, tagRankConfig>::iterator itor = GetGame()->GetEntityManager()->GetRankMap().find(pRankInfo->lRankID);
if(itor != GetGame()->GetEntityManager()->GetRankMap().end())
{
tagRankConfig stRankConfig = itor->second;
_RecordsetPtr rs;
try
{
GetAdoBasePtr()->CreateRs(rs);
GetAdoBasePtr()->OpenRs(stRankConfig.strCurSQL.c_str(), rs);
}
catch (_com_error &e)
{
// _com_issue_error(E_FAIL);
// 发生异常,通常表现为所连数据库的机子断网了(若数据库和程序在同一机器上不会，除非数据库宕了)
// 这个时候连接指针已经失效了，需要关闭重新创建
// 当然这种修复只有在下一次轮询中才会得到成功所用
GetAdoBasePtr()->PrintErr("LoadRanks Error!!!",e);
GetAdoBasePtr()->CloseCn();
GetAdoBasePtr()->OpenCn();
return false;
}
pRankInfo->EnterCS();
// clear data first
pRankInfo->Clear();
// then begin update data
pRankInfo->ulUpdateTime = timeGetTime();
for(long l=0; l < rs->GetFields()->GetCount(); l++)
{
tagColInfo tgColInfo;
tgColInfo.strColName = rs->GetFields()->GetItem(l)->GetName();
strlwr((char*)tgColInfo.strColName.c_str());
DataTypeEnum dt = rs->GetFields()->GetItem(l)->GetType();
switch(dt)
{
case adChar:
case adBSTR:
case adVarChar:
case adLongVarChar:
case adWChar:
case adVarWChar:
case adLongVarWChar:
{
tgColInfo.dt = CT_STRING;
}
break;
case adGUID:
{
tgColInfo.dt = CT_GUID;
}
break;
case adTinyInt:
case adSmallInt:
case adBigInt:
case adUnsignedTinyInt:
case adUnsignedSmallInt:
case adUnsignedInt:
case adUnsignedBigInt:
case adSingle:
case adInteger:
case adNumeric:
case adDecimal:
{
tgColInfo.dt = CT_LONG;
}
break;
case adDouble:
{
tgColInfo.dt = CT_FLOAT;
}
break;
case adDate:
case adDBDate:
case adDBTime:
case adDBTimeStamp:
{
tgColInfo.dt = CT_TIME;
}
break;
case adBinary:
case adVarBinary:
case adLongVarBinary:
{
tgColInfo.dt = CT_BUFFER;
}
break;
default:
{
tgColInfo.dt = CT_UNKNOWN;
}
break;
}
pRankInfo->vecColInfo.push_back(tgColInfo);
}
long lCurLvl = 1;
while(!rs->GetadoEOF())
{
CTableManager* pDataManager = new CTableManager;
long lAttrNum = 0;
for(size_t lVecCol = 0; lVecCol < pRankInfo->vecColInfo.size(); lVecCol++)
{
tagColInfo stInfo = pRankInfo->vecColInfo[lVecCol];
variant_t var = rs->GetCollect(stInfo.strColName.c_str());
CDataObject* pEntity = pDataManager->CreateColumnData(lAttrNum);
switch(stInfo.dt)
{
// case DATA_OBJECT_BYTE:
case CT_STRING:
{
// pEntity->SetDataType(DATA_OBJECT_STRING);
pEntity->SetStringValue(string((_bstr_t)var).c_str(), (long)string((_bstr_t)var).size());
}
break;
case CT_GUID:
{
// pEntity->SetDataType(DATA_OBJECT_GUID);
CGUID tGUID(string(_bstr_t(var)).c_str());
pEntity->SetGUIDValue(tGUID);
}
break;
case CT_LONG:
{
long lVal = var.lVal;
pEntity->SetLongValue(lVal);
}
break;
case CT_FLOAT:
{
float fValue = var.fltVal;
pEntity->SetBufValue((void*)&fValue, sizeof(float));
}
break;
case CT_TIME:
{
// pEntity->SetDataType(DATA_OBJECT_TIME);
long timeBuf[6] = {0};
SYSTEMTIME st;
VariantTimeToSystemTime(var.date, &st);
timeBuf[0] = st.wYear;
timeBuf[1] = st.wMonth;
timeBuf[2] = st.wDay;
timeBuf[3] = st.wHour;
timeBuf[4] = st.wMinute;
timeBuf[5] = st.wSecond;
if(timeBuf[0] == 1900 && timeBuf[1] == 1 && timeBuf[2] == 1)
memset(timeBuf, 0, sizeof(timeBuf));
pEntity->SetBufValue((void*)&timeBuf[0], sizeof(long)*6);
}
break;
case CT_BUFFER:
{
// pEntity->SetBufAttr()
}
break;
}
lAttrNum++;
}
pRankInfo->vecColData.push_back(pDataManager);
rs->MoveNext();
lCurLvl++;
}
// update data end
GetAdoBasePtr()->ReleaseRs(rs);
pRankInfo->LeaveCS();
}
else
{
return false;
}
SendRanksToWS(pRankInfo->lRankID);
UpdateRanks(pRankInfo->lRankID);
return true;
}
// **************************************************************************
// GetValue ()
//
// Description:
// Return a string representing the value of a variant.
//
// Parameters:
// VARIANT &vtVal Input variant.
// TCHAR *pBuffer Pointer to buffer for output string.
// int nBufLen Size of output buffer.
//
// Returns:
// void
// **************************************************************************
void CKItemPropertiesDlg::GetValue (VARIANT &vtVal, // [in]
TCHAR *pBuffer, // [out]
int nBufLen) // [in]
{
ASSERT (pBuffer != NULL);
ASSERT (nBufLen > 0);
// Declare a CString to help construct result string:
CString strVal;
// Format string according to data type:
switch (vtVal.vt)
{
case VT_BOOL:
strVal.Format (_T("%d"), vtVal.boolVal);
break;
case VT_UI1:
strVal.Format (_T("%u"), vtVal.bVal);
break;
case VT_I1:
strVal.Format (_T("%d"), vtVal.cVal);
break;
case VT_UI2:
strVal.Format (_T("%u"), vtVal.uiVal);
break;
case VT_I2:
strVal.Format (_T("%d"), vtVal.iVal);
break;
case VT_UI4:
strVal.Format (_T("%u"), vtVal.ulVal);
break;
case VT_I4:
strVal.Format (_T("%d"), vtVal.lVal);
break;
case VT_R4:
strVal.Format (_T("%G"), vtVal.fltVal);
break;
case VT_R8:
strVal.Format (_T("%G"), vtVal.dblVal);
break;
case VT_BSTR:
strVal = vtVal.bstrVal;
break;
case VT_DATE:
{
bool bSuccess = false;
// Cariant time to system time (UTC):
SYSTEMTIME systime;
if (VariantTimeToSystemTime (vtVal.dblVal, &systime))
{
// Get time zone information:
TIME_ZONE_INFORMATION tTZI;
if (GetTimeZoneInformation (&tTZI) != TIME_ZONE_ID_INVALID)
{
// Localize system time:
SYSTEMTIME systimelocal;
if (SystemTimeToTzSpecificLocalTime (&tTZI, &systime, &systimelocal))
{
strVal.Format (_T("%02d:%02d:%02d"),
systimelocal.wHour, systimelocal.wMinute, systimelocal.wSecond);
bSuccess = true;
}
}
}
if (!bSuccess)
strVal = _T("???");
}
break;
case VT_UI1 | VT_ARRAY:
case VT_I1 | VT_ARRAY:
case VT_UI2 | VT_ARRAY:
case VT_I2 | VT_ARRAY:
case VT_UI4 | VT_ARRAY:
case VT_I4 | VT_ARRAY:
case VT_R4 | VT_ARRAY:
case VT_R8 | VT_ARRAY:
{
CSafeArray *pSafeArr = (CSafeArray *) vtVal.parray;
DWORD dwCols = pSafeArr->GetNumCols ();
DWORD dwSize = pSafeArr->GetByteLength ();
ULONG cbElements = pSafeArr->cbElements;
LPBYTE lpByte = (LPBYTE)pSafeArr->pvData;
DWORD dwCol = 0;
// Start row delimiter:
strVal = _T("[ ");
// Cycle through the elements:
for (DWORD i = 0; i < dwSize; i += cbElements, lpByte += cbElements)
{
TCHAR szNum[32];
// Format element according to data size:
if (cbElements == 1)
{
if (vtVal.vt == (VT_UI1 | VT_ARRAY))
_stprintf (szNum, _T("%u"), *lpByte);
else
_stprintf (szNum, _T("%d"), *(char *)lpByte);
}
else if (cbElements == 2)
{
if (vtVal.vt == (VT_UI2 | VT_ARRAY))
_stprintf (szNum, _T("%u"), *(WORD *)lpByte);
else
_stprintf (szNum, _T("%d"), *(short *)lpByte);
}
else if (cbElements == 4)
{
if (vtVal.vt == (VT_R4 | VT_ARRAY))
_stprintf (szNum, _T("%G"), *(float *)lpByte);
else if (vtVal.vt == (VT_UI4 | VT_ARRAY))
_stprintf (szNum, _T("%u"), *(DWORD *)lpByte);
else if (vtVal.vt == (VT_I4 | VT_ARRAY))
_stprintf (szNum, _T("%d"), *(DWORD *)lpByte);
}
else if (cbElements == 8)
_stprintf (szNum, _T("%G"), *(double *)lpByte);
else
{
ASSERT (FALSE);
}
// Delimit each element within the row with a comma:
if (dwCol != 0)
strVal += _T(", ");
// Append the formatted element data:
strVal += szNum;
// Terminate each row (except the last):
if (++dwCol == dwCols)
{
if (i < dwSize - cbElements)
strVal += _T(" ] [ ");
dwCol = 0;
}
}
// End delimiter:
strVal += _T(" ]");
}
break;
default:
// Unsupported datatype:
strVal = _T ("<Bad VARTYPE>");
break;
}
// Copy value to output buffer:
lstrcpyn (pBuffer, strVal, nBufLen);
}
void WMICOL::ReadColumn(PGLOBAL g)
{
// Get the value of the Name property
Res = Tdbp->ClsObj->Get(_bstr_t(Name), 0, &Prop, &Ctype, 0);
switch (Prop.vt) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
Value->Reset();
break;
case VT_BSTR:
Value->SetValue_psz(_com_util::ConvertBSTRToString(Prop.bstrVal));
break;
case VT_I4:
case VT_UI4:
Value->SetValue(Prop.lVal);
break;
case VT_I2:
case VT_UI2:
Value->SetValue(Prop.iVal);
break;
case VT_INT:
case VT_UINT:
Value->SetValue((int)Prop.intVal);
break;
case VT_BOOL:
Value->SetValue(((int)Prop.boolVal) ? 1 : 0);
break;
case VT_R8:
Value->SetValue(Prop.dblVal);
break;
case VT_R4:
Value->SetValue((double)Prop.fltVal);
break;
case VT_DATE:
switch (Value->GetType()) {
case TYPE_DATE:
{SYSTEMTIME stm;
struct tm ptm;
int rc = VariantTimeToSystemTime(Prop.date, &stm);
ptm.tm_year = stm.wYear;
ptm.tm_mon = stm.wMonth;
ptm.tm_mday = stm.wDay;
ptm.tm_hour = stm.wHour;
ptm.tm_min = stm.wMinute;
ptm.tm_sec = stm.wSecond;
((DTVAL*)Value)->MakeTime(&ptm);
}break;
case TYPE_STRING:
{SYSTEMTIME stm;
char buf[24];
int rc = VariantTimeToSystemTime(Prop.date, &stm);
sprintf(buf, "%02d/%02d/%d %02d:%02d:%02d",
stm.wDay, stm.wMonth, stm.wYear,
stm.wHour, stm.wMinute, stm.wSecond);
Value->SetValue_psz(buf);
}break;
default:
Value->SetValue((double)Prop.fltVal);
} // endswitch Type
break;
default:
// This will reset numeric column value
Value->SetValue_psz("Type not supported");
break;
} // endswitch vt
VariantClear(&Prop);
} // end of ReadColumn
void CDlgHistory::OnBnClickedButtonExport()
{
// TODO: 在此添加控件通知处理程序代码
UpdateData(TRUE);
GetDlgItem(IDC_BUTTON_EXPORT)->EnableWindow(FALSE);
COleVariant covTrue((short)TRUE),covFalse((short)FALSE),covOptional((long)DISP_E_PARAMNOTFOUND,VT_ERROR);
book.PrintPreview(_variant_t(false));
CFileDialog FileDialog(FALSE,"xlsx",NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, _T("Microsoft Excel 2007(*.xlsx)|*.xlsx|所有文件(*.*)"),this);
if(FileDialog.DoModal()!=IDOK)
{
GetDlgItem(IDC_BUTTON_EXPORT)->EnableWindow(TRUE);
return;
}
CString cStrFile=FileDialog.GetPathName(); //选择保存路径名称
if(::PathFileExists(cStrFile))
DeleteFile(cStrFile);
CString AntID,SensorID,StrStartTime,StrStopTime,tmpData,passWord,StartTime,StopTime,message,strRecordTime,rowCount,strRow,strLimit;
StrStartTime.Format("%f",m_DataBegin);
StrStopTime.Format("%f",m_DataEnding);
CTime m_Startdate;
m_CtlDateTimeStartTime.GetTime(m_Startdate);
StartTime.Format("%d%02d%02d",m_Startdate.GetYear(), m_Startdate.GetMonth(),m_Startdate.GetDay());
_RecordsetPtr m_pRecordsetch;
m_pRecordsetch.CreateInstance(__uuidof(Recordset));
books = app.get_Workbooks();
book = books.Add(covOptional);
sheets = book.get_Worksheets();
sheets.Add(vtMissing,vtMissing,vtMissing,vtMissing);
int nCount;
char cCell;
for(int i=1;i<5;i++)
{
tmpData.Format("%d",i);
AntID = "天线"+tmpData;
sheet = sheets.get_Item(COleVariant((short)i)); //得到第一个工作表
sheet.put_Name(AntID);
for(int j=1;j<13;j++)
{
nCount = 3;
tmpData.Format("%d",j);
SensorID = "传感器"+tmpData;
cCell = 'A' + 2*(j-1);
rowCount.Format(_T("%c"),cCell);
rowCount+="1";
range = sheet.get_Range(COleVariant(rowCount),COleVariant(rowCount));
range.put_Value2(COleVariant(SensorID));
rowCount.Format(_T("%c"),cCell);
rowCount+="2";
range = sheet.get_Range(COleVariant(rowCount),COleVariant(rowCount));
range.put_Value2(COleVariant("时间"));
rowCount.Format(_T("%c"),cCell+1);
rowCount+="2";
range = sheet.get_Range(COleVariant(rowCount),COleVariant(rowCount));
range.put_Value2(COleVariant("温度"));
_bstr_t bstrSQLdata ="SELECT Temperature,RecordTime FROM DB_Data where ReaderID='"+strReader+"' and AntID='"+AntID+"' and SensorID='"+SensorID+"' and RecordTime<"+StrStopTime+" and RecordTime>"+StrStartTime+" and (Notes='正常' or Notes='超限') order by DataID;";
m_pRecordsetch->Open(bstrSQLdata,m_pConnection.GetInterfacePtr(),adOpenDynamic,adLockOptimistic,adCmdText);
while(!m_pRecordsetch->adoEOF)
{
CString temper=(LPCSTR)(_bstr_t)m_pRecordsetch->GetCollect("Temperature");
CString time=(LPCSTR)(_bstr_t)m_pRecordsetch->GetCollect("RecordTime");
COleDateTime t=atof(time);
strRecordTime=t.Format("%Y-%m-%d %H:%M:%S");
rowCount.Format(_T("%c"),cCell);
strRow.Format(_T("%d"),nCount);
rowCount+=strRow;
range = sheet.get_Range(COleVariant(rowCount),COleVariant(rowCount));
range.put_NumberFormat(COleVariant("hh:mm:ss"));
range.put_Value2(COleVariant(strRecordTime)); //设置时间
rowCount.Format(_T("%c"),cCell+1);
rowCount+=strRow;
range = sheet.get_Range(COleVariant(rowCount),COleVariant(rowCount));
range.put_Value2(COleVariant(temper)); //设置温度
time.ReleaseBuffer();
temper.ReleaseBuffer();
m_pRecordsetch->MoveNext();
nCount++;
}
m_pRecordsetch->Close();
}
range = sheet.get_Range(COleVariant("A3"),COleVariant("A3"));
COleVariant vResult =range.get_Value2();
if(vResult.vt==VT_EMPTY)
{
passWord="******";
}
else
{
SYSTEMTIME st;
VariantTimeToSystemTime(vResult.date, &st);
passWord.Format("%d%02d%02d",st.wYear,st.wMonth,st.wDay);
passWord+="hshiot";
}
sheet.Protect(_variant_t(passWord),vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing,vtMissing);
}
book.SaveCopyAs(COleVariant(cStrFile)); //保存到cStrFile文件
book.put_Saved(true);
books.Close();
book.ReleaseDispatch();
books.ReleaseDispatch();
app.ReleaseDispatch();
app.Quit();
message = "已导出数据，文件位置 :"+cStrFile;
AfxMessageBox(message);
GetDlgItem(IDC_BUTTON_EXPORT)->EnableWindow(TRUE);
}
static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
DBTYPE src_type, DBTYPE dst_type,
DBLENGTH src_len, DBLENGTH *dst_len,
void *src, void *dst,
DBLENGTH dst_max_len,
DBSTATUS src_status, DBSTATUS *dst_status,
BYTE precision, BYTE scale,
DBDATACONVERT flags)
{
convert *This = impl_from_IDataConvert(iface);
HRESULT hr;
TRACE("(%p)->(%d, %d, %ld, %p, %p, %p, %ld, %d, %p, %d, %d, %x)\n", This,
src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
src_status, dst_status, precision, scale, flags);
*dst_status = DBSTATUS_E_BADACCESSOR;
if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
{
return DB_E_UNSUPPORTEDCONVERSION;
}
if(src_type == DBTYPE_STR)
{
BSTR b;
DWORD len;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
else
len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
b = SysAllocStringLen(NULL, len);
if(!b) return E_OUTOFMEMORY;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
else
MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
&b, dst, dst_max_len, src_status, dst_status,
precision, scale, flags);
SysFreeString(b);
return hr;
}
if(src_type == DBTYPE_WSTR)
{
BSTR b;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
b = SysAllocString(src);
else
b = SysAllocStringLen(src, src_len / 2);
if(!b) return E_OUTOFMEMORY;
hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
&b, dst, dst_max_len, src_status, dst_status,
precision, scale, flags);
SysFreeString(b);
return hr;
}
switch(dst_type)
{
case DBTYPE_I2:
{
signed short *d = dst;
VARIANT tmp;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: *d = *(signed short*)src; hr = S_OK; break;
case DBTYPE_I4: hr = VarI2FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarI2FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarI2FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarI2FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarI2FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarI2FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarI2FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarI2FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarI2FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarI2FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarI2FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarI2FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarI2FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_VARIANT:
VariantInit(&tmp);
if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I2)) == S_OK)
*d = V_I2(&tmp);
break;
default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_I4:
{
signed int *d = dst;
VARIANT tmp;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarI4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: *d = *(signed int*)src; hr = S_OK; break;
case DBTYPE_R4: hr = VarI4FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarI4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarI4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarI4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarI4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarI4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarI4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarI4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarI4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarI4FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarI4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarI4FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_VARIANT:
VariantInit(&tmp);
if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I4)) == S_OK)
*d = V_I4(&tmp);
break;
default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_R4:
{
FLOAT *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarR4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarR4FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: *d = *(FLOAT*)src; hr = S_OK; break;
case DBTYPE_R8: hr = VarR4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarR4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarR4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarR4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarR4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarR4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarR4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarR4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarR4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarR4FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarR4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarR4FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> R4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_R8:
{
DOUBLE *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarR8FromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarR8FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarR8FromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarR8FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarR8FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarR8FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarR8FromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarR8FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarR8FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: *d = *(DOUBLE*)src; hr = S_OK; break;
case DBTYPE_CY: hr = VarR8FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarR8FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarR8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarR8FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarR8FromDec((DECIMAL*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> R8\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_BOOL:
{
VARIANT_BOOL *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarBoolFromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarBoolFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarBoolFromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarBoolFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarBoolFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarBoolFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarBoolFromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarBoolFromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarBoolFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarBoolFromR8(*(DOUBLE*)src, d); break;
case DBTYPE_CY: hr = VarBoolFromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarBoolFromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarBoolFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: *d = *(VARIANT_BOOL*)src; hr = S_OK; break;
case DBTYPE_DECIMAL: hr = VarBoolFromDec((DECIMAL*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_DATE:
{
DATE *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarDateFromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarDateFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarDateFromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarDateFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarDateFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarDateFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarDateFromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarDateFromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarDateFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarDateFromR8(*(DOUBLE*)src, d); break;
case DBTYPE_CY: hr = VarDateFromCy(*(CY*)src, d); break;
case DBTYPE_DATE: *d = *(DATE*)src; hr = S_OK; break;
case DBTYPE_BSTR: hr = VarDateFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarDateFromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarDateFromDec((DECIMAL*)src, d); break;
case DBTYPE_DBTIMESTAMP:
{
SYSTEMTIME st;
DBTIMESTAMP *ts=(DBTIMESTAMP*)src;
st.wYear = ts->year;
st.wMonth = ts->month;
st.wDay = ts->day;
st.wHour = ts->hour;
st.wMinute = ts->minute;
st.wSecond = ts->second;
st.wMilliseconds = ts->fraction/1000000;
hr = (SystemTimeToVariantTime(&st, d) ? S_OK : E_FAIL);
break;
}
default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_DBTIMESTAMP:
{
DBTIMESTAMP *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: memset(d, 0, sizeof(DBTIMESTAMP)); hr = S_OK; break;
case DBTYPE_DBTIMESTAMP: memcpy(d, src, sizeof(DBTIMESTAMP)); hr = S_OK; break;
case DBTYPE_DATE:
{
SYSTEMTIME st;
hr = (VariantTimeToSystemTime(*(double*)src, &st) ? S_OK : E_FAIL);
d->year = st.wYear;
d->month = st.wMonth;
d->day = st.wDay;
d->hour = st.wHour;
d->minute = st.wMinute;
d->second = st.wSecond;
d->fraction = st.wMilliseconds * 1000000;
break;
}
default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_CY:
{
CY *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: d->int64 = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarCyFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarCyFromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarCyFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarCyFromR8(*(double*)src, d); break;
case DBTYPE_CY: *d = *(CY*)src; hr = S_OK; break;
case DBTYPE_DATE: hr = VarCyFromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarCyFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarCyFromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarCyFromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarCyFromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarCyFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarCyFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarCyFromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarCyFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarCyFromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> CY\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_BSTR:
{
BSTR *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY; break;
case DBTYPE_I2: hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I4: hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_R4: hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_R8: hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_CY: hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_DATE: hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BSTR: *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY; break;
case DBTYPE_BOOL: hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_DECIMAL: hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I1: hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI1: hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI2: hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI4: hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I8: hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI8: hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_GUID:
{
WCHAR szBuff[39];
const GUID *id = (const GUID *)src;
WCHAR format[] = {
'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X','-',
'%','0','2','X','%','0','2','X','-',
'%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','}',0};
wsprintfW(szBuff, format,
id->Data1, id->Data2, id->Data3,
id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
*d = SysAllocString(szBuff);
hr = *d ? S_OK : E_OUTOFMEMORY;
}
break;
case DBTYPE_BYTES:
{
*d = SysAllocStringLen(NULL, 2 * src_len);
if (*d == NULL)
hr = E_OUTOFMEMORY;
else
{
const char hexchars[] = "0123456789ABCDEF";
WCHAR *s = *d;
unsigned char *p = src;
while (src_len > 0)
{
*s++ = hexchars[(*p >> 4) & 0x0F];
*s++ = hexchars[(*p) & 0x0F];
src_len--; p++;
}
hr = S_OK;
}
}
break;
default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI1:
{
BYTE *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI1FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI1FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI1FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI1FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI1FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI1FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI1FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI1FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI1FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: *d = *(BYTE*)src; hr = S_OK; break;
case DBTYPE_UI2: hr = VarUI1FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarUI1FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI1FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI1FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI2:
{
WORD *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI2FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI2FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI2FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI2FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI2FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI2FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI2FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI2FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI2FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI2FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: *d = *(WORD*)src; hr = S_OK; break;
case DBTYPE_UI4: hr = VarUI2FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI2FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI2FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI4:
{
DWORD *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI4FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI4FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarUI4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: *d = *(DWORD*)src; hr = S_OK; break;
case DBTYPE_I8: hr = VarUI4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI4FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI8:
{
ULONGLONG *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI8FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: {LONGLONG s = *(signed int*)src; hr = VarUI8FromI8(s, d); break;}
case DBTYPE_R4: hr = VarUI8FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI8FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI8FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI8FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI8FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI8FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI8FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI8FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarUI8FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarUI8FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI8FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: *d = *(ULONGLONG*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_FILETIME:
{
FILETIME *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK; break;
case DBTYPE_FILETIME: *d = *(FILETIME*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_GUID:
{
GUID *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = GUID_NULL; hr = S_OK; break;
case DBTYPE_GUID: *d = *(GUID*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_WSTR:
{
BSTR b;
DBLENGTH bstr_len;
INT bytes_to_copy;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b);
*dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
*dst_status = DBSTATUS_S_OK;
bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
if(dst)
{
if(bytes_to_copy >= sizeof(WCHAR))
{
memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
*((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
if(bytes_to_copy < *dst_len + sizeof(WCHAR))
*dst_status = DBSTATUS_S_TRUNCATED;
}
else
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
hr = DB_E_ERRORSOCCURRED;
}
}
SysFreeString(b);
return hr;
}
case DBTYPE_STR:
{
BSTR b;
DBLENGTH bstr_len;
INT bytes_to_copy;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b);
*dst_len = bstr_len * sizeof(char); /* Doesn't include size for '\0' */
*dst_status = DBSTATUS_S_OK;
bytes_to_copy = min(*dst_len + sizeof(char), dst_max_len);
if(dst)
{
if(bytes_to_copy >= sizeof(char))
{
WideCharToMultiByte(CP_ACP, 0, b, bytes_to_copy - sizeof(char), dst, dst_max_len, NULL, NULL);
*((char *)dst + bytes_to_copy / sizeof(char) - 1) = 0;
if(bytes_to_copy < *dst_len + sizeof(char))
*dst_status = DBSTATUS_S_TRUNCATED;
}
else
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
hr = DB_E_ERRORSOCCURRED;
}
}
SysFreeString(b);
return hr;
}
case DBTYPE_BYREF | DBTYPE_WSTR:
{
BSTR b;
WCHAR **d = dst;
DBLENGTH bstr_len;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b) * sizeof(WCHAR);
*dst_len = bstr_len; /* Doesn't include size for '\0' */
*d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
else hr = E_OUTOFMEMORY;
SysFreeString(b);
return hr;
}
default:
FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
return E_NOTIMPL;
}
if(hr == DISP_E_OVERFLOW)
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
*dst_len = get_length(dst_type);
hr = DB_E_ERRORSOCCURRED;
}
else if(hr == S_OK)
{
*dst_status = DBSTATUS_S_OK;
*dst_len = get_length(dst_type);
}
return hr;
}
CXMiLFilesControl::CSiteItem * CXMiLFilesControl::FromElement(CSiteDir* pParentDir, ILDOMElement* recordset)
{
CSiteItem* pItem;
BSTR b;
recordset->getAttribute(L"type", &b);
BYTE type = (long)_variant_t(_bstr_t(b, false));
recordset->getAttribute(L"filename", &b);
_bstr_t filename = _bstr_t(b, false);
if (type == 1) // Directory
{
CSiteDir* pDir = new CSiteDir;
pItem = pDir;
}
else if (type == 2) // File
{
CSiteFile* pFile = new CSiteFile;
pItem = pFile;
}
else
ATLASSERT(0);
if (pItem)
{
pItem->m_parent = pParentDir;
//pItem->m_pWebSite = m_pWebSite;
strcpy(pItem->m_wfd.cFileName, filename);
// recordset->getAttribute(L"file_id", &b);
// pItem->m_dbid = (long)_variant_t(_bstr_t(b, false));
recordset->getAttribute(L"file_size", &b);
pItem->m_wfd.nFileSizeLow = (long)_variant_t(_bstr_t(b, false));
// lastWriteDate
recordset->getAttribute(L"file_date", &b);
double lastWriteTime = _variant_t(_bstr_t(b, false));
SYSTEMTIME systime;
VariantTimeToSystemTime(lastWriteTime, &systime);
SystemTimeToFileTime(&systime, &pItem->m_wfd.ftLastWriteTime);
SHFILEINFO sfi;
::SHGetFileInfo(
pItem->m_wfd.cFileName,
(pItem->m_type == 1)? FILE_ATTRIBUTE_DIRECTORY: FILE_ATTRIBUTE_NORMAL,
&sfi,
sizeof(SHFILEINFO),
SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
pItem->m_iIcon = sfi.iIcon;
if (pItem->m_type == 1)
{
CSiteDir* pDir = (CSiteDir*)pItem;
pItem->m_cChildren = _variant_t(_bstr_t(b, false));
}
}
return pItem;
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
// TODO: We currently return arrays as wxVariant of the list type
// containing the flattened form of array but we should allow
// getting it as wxVariantDataSafeArray instead. Doing this is
// simple, we'd just need to do something like this:
//
// if ( oleVariant.parray && SafeArrayGetDim(oleVariant.parray) > 1 )
// {
// variant.SetData(new wxVariantDataSafeArray(oleVariant.parray));
// }
//
// but currently we don't do it for compatibility reasons.
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_I2:
ok = wxSafeArray<VT_I2>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_I4:
ok = wxSafeArray<VT_I4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R4:
ok = wxSafeArray<VT_R4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R8:
ok = wxSafeArray<VT_R8>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_VARIANT:
ok = wxSafeArray<VT_VARIANT>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_BSTR:
{
wxArrayString strings;
if ( wxSafeArray<VT_BSTR>::ConvertToArrayString(oleVariant.parray, strings) )
variant = strings;
else
ok = false;
}
break;
default:
ok = false;
break;
}
if ( !ok )
{
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
}
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_ERROR:
variant.SetData(new wxVariantDataErrorCode(oleVariant.scode));
break;
case VT_CY:
variant.SetData(new wxVariantDataCurrency(oleVariant.cyVal));
break;
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
// See the comment before the __VISUALC6__ test above.
#if wxUSE_LONGLONG && !defined(__VISUALC6__)
case VT_I8:
variant = wxLongLong(oleVariant.llVal);
break;
#endif // wxUSE_LONGLONG
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R4:
variant = oleVariant.fltVal;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
variant.MakeNull();
break;
case VT_EMPTY:
break; // Ignore Empty Variant, used only during destruction of objects
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
void enumerateTasksForFolder(std::string path, QueryData& results) {
void* vpService = nullptr;
auto ret = CoCreateInstance(CLSID_TaskScheduler,
nullptr,
CLSCTX_INPROC_SERVER,
IID_ITaskService,
&vpService);
if (FAILED(ret)) {
VLOG(1) << "Failed to create COM instance " << ret;
return;
}
auto pService = static_cast<ITaskService*>(vpService);
ret =
pService->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());
if (FAILED(ret)) {
VLOG(1) << "Failed to connect to TaskService " << ret;
pService->Release();
return;
}
ITaskFolder* pRootFolder = nullptr;
auto widePath = stringToWstring(path);
ret = pService->GetFolder(BSTR(widePath.c_str()), &pRootFolder);
pService->Release();
if (FAILED(ret)) {
VLOG(1) << "Failed to get root task folder " << ret;
return;
}
IRegisteredTaskCollection* pTaskCollection = nullptr;
ret = pRootFolder->GetTasks(TASK_ENUM_HIDDEN, &pTaskCollection);
pRootFolder->Release();
if (FAILED(ret)) {
VLOG(1) << "Failed to get task collection for root folder " << ret;
return;
}
long numTasks = 0;
pTaskCollection->get_Count(&numTasks);
for (size_t i = 0; i < numTasks; i++) {
IRegisteredTask* pRegisteredTask = nullptr;
// Collections are 1-based lists
ret = pTaskCollection->get_Item(_variant_t(i + 1), &pRegisteredTask);
if (FAILED(ret)) {
VLOG(1) << "Failed to process task";
continue;
}
Row r;
BSTR taskName;
ret = pRegisteredTask->get_Name(&taskName);
std::wstring wTaskName(taskName, SysStringLen(taskName));
r["name"] = ret == S_OK ? SQL_TEXT(wstringToString(wTaskName.c_str())) : "";
VARIANT_BOOL enabled = false;
pRegisteredTask->get_Enabled(&enabled);
r["enabled"] = enabled ? INTEGER(1) : INTEGER(0);
TASK_STATE taskState;
pRegisteredTask->get_State(&taskState);
r["state"] = kStateMap.count(taskState) > 0
? kStateMap.at(taskState)
: kStateMap.at(TASK_STATE_UNKNOWN);
BSTR taskPath;
ret = pRegisteredTask->get_Path(&taskPath);
std::wstring wTaskPath(taskPath, SysStringLen(taskPath));
r["path"] = ret == S_OK ? wstringToString(wTaskPath.c_str()) : "";
VARIANT_BOOL hidden = false;
pRegisteredTask->get_Enabled(&hidden);
r["hidden"] = hidden ? INTEGER(1) : INTEGER(0);
HRESULT lastTaskRun = E_FAIL;
pRegisteredTask->get_LastTaskResult(&lastTaskRun);
_com_error err(lastTaskRun);
r["last_run_message"] = err.ErrorMessage();
r["last_run_code"] = INTEGER(lastTaskRun);
// We conver the COM Date type to a unix epoch timestamp
DATE dRunTime;
SYSTEMTIME st;
FILETIME ft;
FILETIME locFt;
pRegisteredTask->get_LastRunTime(&dRunTime);
VariantTimeToSystemTime(dRunTime, &st);
SystemTimeToFileTime(&st, &ft);
LocalFileTimeToFileTime(&ft, &locFt);
r["last_run_time"] = INTEGER(filetimeToUnixtime(locFt));
pRegisteredTask->get_NextRunTime(&dRunTime);
VariantTimeToSystemTime(dRunTime, &st);
SystemTimeToFileTime(&st, &ft);
LocalFileTimeToFileTime(&ft, &locFt);
r["next_run_time"] = INTEGER(filetimeToUnixtime(locFt));
ITaskDefinition* taskDef = nullptr;
IActionCollection* tActionCollection = nullptr;
pRegisteredTask->get_Definition(&taskDef);
if (taskDef != nullptr) {
taskDef->get_Actions(&tActionCollection);
}
long actionCount = 0;
if (tActionCollection != nullptr) {
tActionCollection->get_Count(&actionCount);
}
std::vector<std::string> actions;
// Task collections are 1-indexed
for (auto j = 1; j <= actionCount; j++) {
IAction* act = nullptr;
IExecAction* execAction = nullptr;
tActionCollection->get_Item(j, &act);
if (act == nullptr) {
continue;
}
act->QueryInterface(IID_IExecAction,
reinterpret_cast<void**>(&execAction));
if (execAction == nullptr) {
continue;
}
BSTR taskExecPath;
execAction->get_Path(&taskExecPath);
std::wstring wTaskExecPath(taskExecPath, SysStringLen(taskExecPath));
BSTR taskExecArgs;
execAction->get_Arguments(&taskExecArgs);
std::wstring wTaskExecArgs(taskExecArgs, SysStringLen(taskExecArgs));
BSTR taskExecRoot;
execAction->get_WorkingDirectory(&taskExecRoot);
std::wstring wTaskExecRoot(taskExecRoot, SysStringLen(taskExecRoot));
auto full = wTaskExecRoot + L" " + wTaskExecPath + L" " + wTaskExecArgs;
actions.push_back(wstringToString(full.c_str()));
act->Release();
}
if (tActionCollection != nullptr) {
tActionCollection->Release();
}
if (taskDef != nullptr) {
taskDef->Release();
}
r["action"] = !actions.empty() ? osquery::join(actions, ",") : "";
results.push_back(r);
pRegisteredTask->Release();
}
pTaskCollection->Release();
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant, long flags)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
if ( flags & wxOleConvertVariant_ReturnSafeArrays )
{
variant.SetData(new wxVariantDataSafeArray(oleVariant.parray));
}
else
{
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_I2:
ok = wxSafeArray<VT_I2>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_I4:
ok = wxSafeArray<VT_I4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R4:
ok = wxSafeArray<VT_R4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R8:
ok = wxSafeArray<VT_R8>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_VARIANT:
ok = wxSafeArray<VT_VARIANT>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_BSTR:
{
wxArrayString strings;
if ( wxSafeArray<VT_BSTR>::ConvertToArrayString(oleVariant.parray, strings) )
variant = strings;
else
ok = false;
}
break;
default:
ok = false;
break;
}
if ( !ok )
{
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
}
}
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_ERROR:
variant.SetData(new wxVariantDataErrorCode(oleVariant.scode));
break;
case VT_CY:
variant.SetData(new wxVariantDataCurrency(oleVariant.cyVal));
break;
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
#if wxUSE_LONGLONG
case VT_I8:
variant = wxLongLong(oleVariant.llVal);
break;
#endif // wxUSE_LONGLONG
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R4:
variant = oleVariant.fltVal;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
case VT_EMPTY:
variant.MakeNull();
break;
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
HRESULT CXMLExporterBase::WriteOption(BSTR name, _variant_t value)
{
HRESULT hr;
_bstr_t bName(name, true);
switch( value.vt )
{
case VT_I4:
case VT_I2:
Write("<Option name=\"%s\" value=\"%d\" />\n",
(const char*)bName, (long)value);
break;
case VT_R4:
case VT_R8:
Write("<Option name=\"%s\" value=\"%g\" />\n",
(const char*)bName, (double)value);
break;
case VT_BOOL:
Write("<Option name=\"%s\" value=\"%s\" />\n",
(const char*)bName, BoolToText((bool)value));
break;
case VT_BSTR:
{
_bstr_t bValue = (_bstr_t) value.bstrVal;
Write("<Option name=\"%s\" value=\"%s\" />\n",
(const char*)bName, (const char*)bValue);
}
break;
case VT_DATE:
{
#ifdef _WIN32
DATE time = (DATE)value;
SYSTEMTIME sysTime;
if( VariantTimeToSystemTime(time, &sysTime) )
{
TCHAR dateStr[16], timeStr[16];
GetDateFormat(NULL, 0, &sysTime, _T("MM'/'dd'/'yyyy"), dateStr, 16);
GetTimeFormat(NULL, 0, &sysTime, _T("HH':'mm':'ss"), timeStr, 16);
Write("<Option name=\"%s\" value=\"%s %s\" />\n",
(const char*)bName, dateStr, timeStr);
}
else
{
Write("<Option name=\"%s\" value=\"invalid time\" />\n",
(const char*)bName);
}
#else
// On the Mac, DATE == time_t
DATE date = value.date;
Write("<Option name=\"%s\" value=\"%s\" />\n",
(const char*)bName, asctime(gmtime((time_t*)&date)));
#endif
}
break;
case VT_UNKNOWN:
// The unknown can be either a point or a vector
{
IUnknown* pUnk = value.punkVal;
ISkpPoint3d* pPoint = NULL;
hr = pUnk->QueryInterface(IID_ISkpPoint3d, (void**)&pPoint);
if( SUCCEEDED(hr) )
{
double p[3];
pPoint->Get(p, p+1, p+2);
WritePosition( (const char*)bName , p);
RELEASE(pPoint);
}
else
{
ISkpVector3d* pVec = NULL;
hr = pUnk->QueryInterface(IID_ISkpVector3d, (void**)&pVec);
if( SUCCEEDED(hr) )
{
double v[3];
pVec->Get(v,v+1,v+2);
WriteVector( (const char*)bName , v);
RELEASE(pVec);
}
}
}
break;
default:
Write("<Option name=\"%s\" value=\"unknown type\" />\n", (const char*)bName);
}
return S_OK;
}
