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; }