STDMETHODIMP COleObjectPropertyDual::HelpInfo (
LPSTR pBuffer, ULONG ulLen, LPSTR pHelpFile, ULONG *pulHelpCtx)
{
HRESULT result = S_OK;
try {
CComBSTR bstrInfo;
CComVariant vHelpFile;
CComVariant vHelpCtx;
THROW_FAILED_HRESULT(m_ObjProp -> HelpInfo(&vHelpFile, &vHelpCtx, CLEARED(&bstrInfo)));
USES_CONVERSION;
if (NULL != pBuffer && ulLen > 0) {
ULONG ulT = min (ulLen-1, (ULONG)SysStringLen(bstrInfo));
strncpy (pBuffer, OLE2A(bstrInfo), ulT);
pBuffer[ulT] = '\0';
}
if (NULL != pHelpFile && VT_BSTR == vHelpFile.vt)
strcpy (pHelpFile, OLE2A(V_BSTR(&vHelpFile)));
if (NULL != pulHelpCtx && VT_I4 == vHelpCtx.vt)
*pulHelpCtx = V_I4(&vHelpCtx);
} catch (_com_error& hr) {
result = _COM_ERROR(hr);
}
return result;
}
HRESULT CCoordTransService::FindCTF (void)
{
USES_CONVERSION;
char cbCTFName[_MAX_PATH];
CComBSTR bstr (GetProperty (m_Props, g_cbCoordTransform, A2OLE(g_cbDefault)));
strcpy (cbCTFName, OLE2A(bstr));
if (!stricmp (cbCTFName, g_cbDefault))
m_fIsDefault = true;
// CTFService's über CATID enumerieren, CTFService wiederfinden
try {
WEnumGUID EnumGuids; // Enumerator der CTFService-Objekte
WCatInformation CatInfo (CLSID_StdComponentCategoriesMgr); // throws hr
GUID guidImpl[1];
guidImpl[0] = CATID_TRiASCoordsystem;
THROW_FAILED_HRESULT(CatInfo -> EnumClassesOfCategories (1, guidImpl, 0, NULL, EnumGuids.ppi()));
GUID guid;
LPOLESTR lpGuid = NULL;
bool fFoundGuid = false;
for (EnumGuids -> Reset(); S_OK == EnumGuids -> Next (1, &guid, NULL); /**/)
{
THROW_FAILED_HRESULT(StringFromCLSID (guid, &lpGuid));
CClassesRoot regClsID (OLE2A(lpGuid));
char cbBuffer[_MAX_PATH];
LONG lSize = sizeof(cbBuffer);
if (NULL != lpGuid) {
CoTaskMemFree (lpGuid);
lpGuid = NULL;
}
if (regClsID.isValid() && regClsID.GetSZ (g_cbOldName, cbBuffer, lSize))
{
if (!stricmp (cbBuffer, cbCTFName)) {
fFoundGuid = true;
m_strCTF = cbBuffer;
break;
}
}
}
if (!fFoundGuid) {
TX_ASSERT(fFoundGuid);
return E_FAIL; // snh!
}
} catch (_com_error &e) {
TX_ASSERT(S_OK == _COM_ERROR(e));
return _COM_ERROR(e);
}
return S_OK;
}
STDMETHODIMP CInOutParams::mVT_BSTR_LONG(VARIANT a, VARIANT* b)
{
USES_CONVERSION;
VariantInit(b);
b->vt = VT_I4;
if (0==strcmp( OLE2A( a.bstrVal), "hello"))
b->lVal = 100;
else if (0==strcmp( OLE2A( a.bstrVal), "world"))
b->lVal = 200;
return S_OK;
}
HRESULT PrintManager::PopulateBookmark(BSTR BookMarkName, BSTR Text)
{
USES_CONVERSION;
try
{
if (TerQuickPosBookmark4(m_hWnd, (LPBYTE)OLE2A(BookMarkName), -1, FALSE, TRUE, FALSE, FALSE))
TerInsertText(m_hWnd, (LPBYTE)OLE2A(Text), -1, -1, TRUE);
}
catch (...)
{
LOG_WS_ERROR( _T("PopulateBookmark failed"));
return E_FAIL;
}
return S_OK;
}
long WMIUtil::WMICollectAuto (IWbemClassObject *Obj, NVDataItem * TargetData, WMIObjValueEntry * AutoAttr)
{
USES_CONVERSION;
if (AutoAttr == NULL)
return ERROR_SUCCESS;
WMIObjValueEntry * CurrEntry;
long Status;
char * ResolvedDataName;
for (CurrEntry = AutoAttr; CurrEntry->ObjAttr != (BSTR) NULL; CurrEntry ++) {
if (CurrEntry->DataName == NULL)
ResolvedDataName = OLE2A(CurrEntry->ObjAttr);
else
ResolvedDataName = CurrEntry->DataName;
Status = WMIObjAddNVItem( Obj, CurrEntry->ObjAttr, TargetData, ResolvedDataName, CurrEntry->DefaultVal);
//W32_RETURN_ON_ERROR(Status);
}
return ERROR_SUCCESS;
}
STDMETHODIMP CPigMissionParams::put_GameName(BSTR bstrGameName)
{
XLock lock(this);
USES_CONVERSION;
Strcpy(m_mp.strGameName,OLE2A(bstrGameName));
return S_OK;
}
STDMETHODIMP CPigMissionParams::put_CoreName(BSTR bstrCoreName)
{
XLock lock(this);
USES_CONVERSION;
Strcpy(m_mp.szIGCStaticFile,OLE2A(bstrCoreName));
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// Korrektur des Namens, der am TRiAS-Objekt geschrieben werden soll
// Für DLK wird am Objekt geschrieben:
// LetztesUnterVerzeichnis@@BildName
STDMETHODIMP CMapGeoPunktDLK::CorrectName (BSTR bstrDestDir, BSTR bstrName, BSTR *pbstrToWrite)
{
CHECKINPOINTER(pbstrToWrite);
*pbstrToWrite = NULL;
CHECKINPOINTER(bstrDestDir);
CHECKINPOINTER(bstrName);
USES_CONVERSION;
// String erzeugen, der am Objekt gespeichert werden soll
os_path path = OLE2A(bstrDestDir);
CString strT;
if (path.levels() > 1)
strT = path[path.levels()-1].c_str();
if (-1 != strT.Find(' '))
strT = "\"" + strT + "\"";
strT += "@@@";
if (::SysStringLen(bstrName) > 0)
strT += bstrName;
else
return E_UNEXPECTED;
*pbstrToWrite = strT.AllocSysString();
return S_OK;
}
// Besorgen des Tabellennamens (sofern einer exitiert)
HRESULT DatenBasisObjekt::GetTableName (TABLENAME *pTableName)
{
// Rückgabewerte initialisieren
int iLen = pTableName -> iLen;
pTableName -> pBuffer[0] = '\0';
pTableName -> iLen = 0;
// Objektmenge aus globaler Tabelle lesen
WTRiASObjects Objs;
HRESULT hr = S_OK;
if (FAILED(hr = GetObjectsFromMap (pTableName -> lIdent, Objs)))
return hr;
CComBSTR bstrName;
RETURN_FAILED_HRESULT(hr = Objs -> get_TableName (CLEARED(&bstrName)));
int iToCopy = min ((int)bstrName.Length(), iLen -1);
USES_CONVERSION;
strncpy (pTableName -> pBuffer, OLE2A(bstrName), iToCopy);
pTableName -> pBuffer[iToCopy] = '\0';
pTableName -> iLen = iToCopy;
return hr;
}
HRESULT CFastdbFeature::OnChangedName()
{
USES_CONVERSION;
COM_TRY {
// neuen Namen vom Bezugsobjekt besorgen
CComBSTR bstrName;
WTRiASFeature BaseFeat;
THROW_FAILED_HRESULT(m_BaseUnk -> QueryInterface (BaseFeat.ppi()));
THROW_FAILED_HRESULT(BaseFeat -> get_Name(CLEARED(&bstrName)))
// zugehöriges DB-Objekt referenzieren
LONG lCursor (GetPropertyFrom (BaseFeat, g_cbFeatureCursor, 0L));
if (0 != lCursor) { // Objekt fertig initialisiert
dbCursor<CDBFeatureDesc> cursor (GetRelatedDatabase(GetUnknown()), dbCursorForUpdate);
CDBFeatureDesc *pFeatDesc = cursor.at (dbReference<CDBFeatureDesc>(oid_t(lCursor)));
if (NULL == pFeatDesc || cursor.isEmpty())
THROW_FAILED_HRESULT(FASTDB_E_FEATURE_BADREFERENCE);
cursor -> m_pName = OLE2A(bstrName);
cursor.update();
}
} COM_CATCH;
return S_OK;
}
// die folgende Funktion ist das konkrete äquivalent für 'OleLoadFromStream' --
HRESULT CreateStringFromStream (IStream *pIStream, LPSTR lpstr, int iLen)
{
ASSERT(pIStream);
ASSERT(lpstr);
ASSERT(0 < iLen);
if (NULL == lpstr) return E_POINTER;
if (0 == iLen) return E_INVALIDARG;
USES_CONVERSION;
*lpstr = '\0';
try
{ // Variant liest sich selbst vom Stream
CComVariant cv;// VariantInit()
HRESULT hr = cv.ReadFromStream (pIStream);
if (FAILED(hr)) _com_issue_error(hr);
// Richtigen Typ rausholen
hr = cv.ChangeType (VT_BSTR);
if (FAILED(hr)) _com_issue_error(hr);
// Wert lesen
CComBSTR bstr = cv.bstrVal; // SysAllocString(...
LPSTR lpstrName = OLE2A(bstr.m_str);
if (iLen < strlen(lpstrName)) _com_issue_error(E_INVALIDARG);
strcpy(lpstr, lpstrName);
// in ~CComVariant() VariantClear()
} // in ~CComBSTR() SysFreeString(m_str)
catch (_com_error& e)
{
return _COM_ERROR(e);
}
return NOERROR;
}
HRESULT CBlobService::MakeTextVertices (BYTE *pBlob, double_v &rX, double_v &rY, void *pData)
{
USES_CONVERSION;
TEXTBLOBDATA *pTBD = (TEXTBLOBDATA *)pData;
pBlob += sizeof(GUID); // GUID übergehen
rX.push_back (((POINTBASE *)pBlob) -> X); // Koordinaten lesen
rY.push_back (((POINTBASE *)pBlob) -> Y);
pBlob += sizeof(POINTBASE);
RetrieveAndAdvance(pTBD -> dRotation, pBlob);
pBlob += sizeof(POINTBASE); // Normale übergehen
RetrieveAndAdvance(pTBD -> lFlags, pBlob);
// Text einlesen
ULONG uiTextSize = 0;
LPOLESTR pText = NULL;
RetrieveAndAdvance(uiTextSize, pBlob);
ATLTRY(pText = new OLECHAR[uiTextSize]);
if (NULL == pText) return E_OUTOFMEMORY;
RetrieveAndAdvance(pText, pBlob, uiTextSize);
pTBD -> strText = OLE2A(pText);
DELETE_OBJ(pText);
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// Wiederfinden einer bestimmten Tablasche
HRESULT CDockingTabFrame::FindTabWindow(BSTR bstrName, INT_PTR *phHandle)
{
if (NULL == phHandle)
return E_POINTER;
*phHandle = NULL;
USES_CONVERSION;
BOOL fFound = FALSE;
LPCSTR pcToFind = OLE2A(bstrName);
COM_TRY {
for (int nIndex = 0; nIndex < m_wndTab.GetTabCount(); ++nIndex) {
LPSTR pcLabel = NULL;
BOOL fSelected = FALSE;
CWnd *pWnd = NULL;
void *pExtra = NULL;
if (!m_wndTab.GetTabInfo(nIndex, pcLabel, fSelected, pWnd, pExtra))
break;
if (!strcmp (pcLabel, pcToFind)) {
*phHandle = reinterpret_cast<INT_PTR>(pWnd -> GetSafeHwnd());
fFound = TRUE;
break;
}
}
} COM_CATCH;
return fFound ? S_OK : E_INVALIDARG;
}
char * CCoordTransService::CoordTransToStringEx (
double dX, double dY, bool isX, char *pBuffer, int iLen)
{
if (m_fIsInitialized) {
try {
CComBSTR bstr;
CCSPoint pt (dX, dY);
if (isX) {
THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, &bstr, NULL, NULL));
} else {
THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, NULL, &bstr, NULL));
}
USES_CONVERSION;
iLen = min(bstr.Length(), iLen-1);
strncpy (pBuffer, OLE2A(bstr), iLen);
pBuffer[iLen] = '\0';
return pBuffer;
} catch (_com_error &e) {
ShowError (_COM_ERROR(e), IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx);
return NULL;
}
}
ShowError (TRIAS02_E_CSSNOTINITIALIZED, IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx);
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
// Ausgewählten Importmodul auffordern das Verzeichnis zu korrigieren (ggf.)
void CMapImportDlg::CorrectDirectory()
{
CComBSTR bstrToWrite;
USES_CONVERSION;
if (SUCCEEDED(m_pTopoMap->CorrectDirectory(CComBSTR(m_strDstDir), &bstrToWrite)))
m_strDstDir = OLE2A(bstrToWrite);
}
/*-------------------------------------------------------------------------
* SetDetailsFiles()
*-------------------------------------------------------------------------
*/
STDMETHODIMP CAdminGame::SetDetailsFiles(BSTR bstrName)
{
assert(GetIGC());
assert(GetHostIGC());
USES_CONVERSION;
GetHostIGC()->SetDetailsFiles(OLE2A(bstrName));
return S_OK;
}
HRESULT CDockingTabFrame::AddTabWindow(INT_PTR hWnd, BSTR bstrName, VARIANT vPict, INT_PTR *phHandle)
{
if (NULL == phHandle)
return E_POINTER;
*phHandle = NULL;
USES_CONVERSION;
COM_TRY {
if (SUCCEEDED(FindTabWindow(bstrName, phHandle)) && hWnd == *phHandle)
return S_FALSE; // existierte bereits
*phHandle = NULL; // doch nichts
// neue TablaschenDaten erzeugen
_ASSERTE(::IsWindow(reinterpret_cast<HWND>(hWnd)));
CTabData *pTabData = new CTabData;
CWnd *pWnd = CWnd::FromHandlePermanent(reinterpret_cast<HWND>(hWnd));
if (NULL == pWnd) {
// hWnd ist kein MFC-Fenster
pWnd = new CWnd;
pWnd -> Attach(reinterpret_cast<HWND>(hWnd)); // trägt hWnd in CWndMap ein
pTabData -> m_fIsAttached = true;
pTabData -> m_pWnd = pWnd;
pTabData -> m_hOldParentWnd = ::GetParent(reinterpret_cast<HWND>(hWnd));
pWnd -> SetParent(&m_wndTab);
}
else {
pTabData -> m_fIsAttached = false;
pTabData -> m_pWnd = pWnd;
pTabData -> m_hOldParentWnd = NULL;
}
// erzeugen der TabLasche, speichern der eigenen Daten
SECTab *pTab = m_wndTab.AddTab(pWnd, OLE2A(bstrName));
pTab -> m_pExtra = pTabData;
// ggf. Bildchen hinzufügen
WPictureDisp PictDisp;
if (SUCCEEDED(RetrievePicture(vPict, PictDisp.ppi()))) {
CPicture Pict (PictDisp, false);
_ASSERTE(NULL != Pict.GetHandle());
m_wndTab.SetTabIcon(m_wndTab.GetTabCount()-1, reinterpret_cast<HICON>(Pict.GetHandle()));
}
// Erfolg: Fensterhandle wieder zurückliefern
*phHandle = hWnd;
} COM_CATCH;
return S_OK;
}
HRESULT CPigEngine::EnsureScriptsAreLoaded()
{
// Return immediately if this initialization has already completed
XLock lock(this);
if (!m_hDirChange.IsNull() && m_pth)
return S_OK;
// Open the registry key of the AppID
CRegKey key;
RETURN_FAILED(_Module.OpenAppIDRegKey(key, KEY_READ));
// Initialize the art path
TCHAR szArtPath[_MAX_PATH];
DWORD cch = sizeofArray(szArtPath);
long lr = key.QueryValue(szArtPath, TEXT("ArtPath"), &cch);
if (ERROR_SUCCESS != lr)
return HRESULT_FROM_WIN32(lr);
UTL::SetArtPath(szArtPath);
// Convert the directory name to ANSI
USES_CONVERSION;
LPSTR pszScriptDir = OLE2A(m_bstrScriptDir);
// Remove the whack at the end of the string
cch = strlen(pszScriptDir);
assert('\\' == pszScriptDir[cch - 1]);
pszScriptDir[cch - 1] = '\0';
// Ensure that the directory exists
WIN32_FIND_DATA ffd;
TCFileFindHandle hff = FindFirstFile(pszScriptDir, &ffd);
if(hff.IsNull() || INVALID_HANDLE_VALUE == hff)
return HRESULT_FROM_WIN32(GetLastError());
// Initialize our record of the directory contents
ProcessScriptDirChanges();
// Create a directory change notification object
const DWORD dwFilter = FILE_NOTIFY_CHANGE_FILE_NAME |
FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_LAST_WRITE;
m_hDirChange = FindFirstChangeNotification(pszScriptDir, false, dwFilter);
if (INVALID_HANDLE_VALUE == m_hDirChange)
return HRESULT_FROM_WIN32(GetLastError());
// Create the thread that monitors the ProfileScriptDir folder
m_pth = TCThread::BeginMsgThread(ScriptDirThunk, this,
THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
if (!m_pth)
return E_FAIL;
m_pth->ResumeThread();
// TODO: Create the thread that monitors the CLSID registry key
// Indicate success
return S_OK;
}
/*-------------------------------------------------------------------------
* SetTeamName()
*-------------------------------------------------------------------------
*/
STDMETHODIMP CAdminGame::SetTeamName(int iSideID, BSTR bstrName)
{
assert(GetIGC());
assert(GetHostIGC());
if(!GetIGC()->GetSide(iSideID))
return S_OK;
USES_CONVERSION;
GetHostIGC()->SetSideName(iSideID, OLE2A(bstrName));
return S_OK;
}
HRESULT COpenNewPropertySheet::HandleConnectString (void)
{
if (!m_ExtPages && !m_Pairs)
return S_FALSE;
USES_CONVERSION;
CComBSTR bstrPairs;
RETURN_FAILED_HRESULT(m_Pairs -> get_ComposedData (CComBSTR(g_cbPattern), CLEARED(&bstrPairs)));
m_Params.m_strConnect = OLE2A(bstrPairs);
return S_OK;
}
STDMETHODIMP COleObjectPropertyDual::GetPropInfo (LPSTR pBuffer, WORD wLen, DWORD *pdwFlags)
{
HRESULT result = S_OK;
try {
// get_PropertyName
if (NULL != pBuffer && wLen > 0) {
CComBSTR bstrName;
THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyName(CLEARED(&bstrName)));
ULONG ulT = min ((ULONG)wLen-1, (ULONG)SysStringLen(bstrName));
USES_CONVERSION;
strncpy (pBuffer, OLE2A(bstrName), ulT);
pBuffer[ulT] = '\0';
}
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
try {
PROPERTYCAPS lFlags = PROPERTYCAPS_NONE;
// get_PropertyFlags
if (NULL != pdwFlags) {
THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyFlags(&lFlags));
if (m_fWriteAble)
lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_NOTREADONLY);
else
lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_NOTREADONLY);
if (m_fSearchAble)
lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_SEARCHABLE);
else
lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_SEARCHABLE);
*pdwFlags = DWORD(lFlags);
}
} catch (_com_error&) {
*pdwFlags = DWORD(PROPERTYCAPS_NONE);
if (m_fWriteAble)
*pdwFlags |= DWORD(PROPERTYCAPS_NOTREADONLY);
if (m_fSearchAble)
*pdwFlags |= DWORD(PROPERTYCAPS_SEARCHABLE);
}
return S_OK;
}
STDMETHODIMP CID3Field::CopyDataFromFile(BSTR FileName)
{
USES_CONVERSION;
try
{
m_Field->FromFile(OLE2A(FileName));
return S_OK;
}
catch (...)
{
return Error(IDS_UNEXPECTED_ERROR, IID_IID3ComField, E_UNEXPECTED);
}
}
// eine neue Objekteigenschaft soll erzeugt werden
STDMETHODIMP CFastdbFeatures::OnCreate (VARIANT Name, BSTR Type, FEATURETYPE rgType, ITRiASFeature **ppIFeat)
{
CHECKOUTPOINTER(ppIFeat);
USES_CONVERSION;
COM_TRY {
// jetzt wirklich erzeugen
CIID ClsId (Type, CIID::INITCIID_InitFromProgId);
if (!ClsId) ClsId = CLSID_FastdbFeature; // default ClsId
WTRiASFeatures BaseFeats;
WDispatch Parent;
THROW_FAILED_HRESULT(m_BaseUnk -> QueryInterface (BaseFeats.ppi()));
THROW_FAILED_HRESULT(BaseFeats -> get_Parent (Parent.ppi()));
// Parent muß hier Objektklasse sein
WTRiASObjects Objs;
THROW_FAILED_HRESULT(Parent -> QueryInterface (Objs.ppi()));
// neuen Satz erzeugen und zu der Objektklasse hinzufügen
LONG lCursor (GetPropertyFrom (Objs, g_cbObjectsCursor, 0L));
_ASSERTE(0 != lCursor);
dbDatabase *pdb = GetRelatedDatabase(GetUnknown());
dbCursor<CDBClass> cursor (pdb);
CDBClass *pClass = cursor.at (dbReference<CDBClass>(oid_t(lCursor)));
if (NULL == pClass || cursor.isEmpty())
THROW_FAILED_HRESULT(FASTDB_E_OBJECTS_BADREFERENCE);
CComVariant vVal;
CDBFeatureDesc FDesc;
THROW_FAILED_HRESULT(vVal.ChangeType (VT_BSTR, &Name));
FDesc.m_pName = OLE2A(V_BSTR(&vVal));
FDesc.m_rgType = rgType;
FDesc.objclass = cursor.currentId();
dbCursor<CDBFeatureDesc> featuredesc (GetRelatedDatabase(GetUnknown()));
featuredesc.at (pdb -> insert (FDesc));
THROW_FAILED_HRESULT(SetupFeature (ClsId, BaseFeats, featuredesc, Parent, ppIFeat));
} COM_CATCH;
return S_OK;
}
STDAPI DllRegisterServer(void)
{
CComBSTR bstrPath;
if (SUCCEEDED(EnsureXmlPath(&bstrPath))) {
USES_CONVERSION;
bstrPath.Append(L"\\GeoComponentSequence.dtd");
DeleteFile(OLE2A(bstrPath));
}
// registers object, typelib and all interfaces in typelib
return _Module.RegisterServer(TRUE);
}
void in_BSTR2sz(BSTR copyFrom, char **copyTo)
///////////////////////////////////////////////////////////////////
{
unsigned int newLen = SysStringLen(copyFrom);
if (*copyTo != (char*)0)
delete *copyTo;
if (newLen > 0) {
USES_CONVERSION;
*copyTo = new char[newLen + 1];
lstrcpyA(*copyTo, OLE2A(copyFrom));
}
}
std::string MiscUtil::getString( const VARIANT &var ){
std::string output;
if( var.vt == VT_I4 ){ // Long
output = std::to_string((long long)var.lVal); // VC++ 2010 - Initial C++11
} // std::to_string - long long but not long
else if( var.vt == VT_R8 ){ // Double
output = std::to_string((long double)var.dblVal) ;
}
else if( var.vt == VT_BSTR){
USES_CONVERSION;
output = std::string ( OLE2A(var.bstrVal)) ; // OLE2A dangerous - always copy output
}
return output;
}
// Implementation of TransformLineOfText
STDMETHODIMP CConvertAscCoords::TransformLineOfText(BSTR bstrIn, BSTR *pbstrOut)
{
ATLTRACE(_T("CConvertAscCoords::TransformLineOfText\n"));
if (!pbstrOut) return E_POINTER;
*pbstrOut = NULL;
USES_CONVERSION;
COM_TRY {
string strIn (OLE2A(bstrIn));
CComBSTR bstrOut (bstrIn);
if ('G' == strIn[0]) {
// Koordinatenzeile
double dX[3] ={ 0.0, 0.0, 0.0 };
double dY[3] ={ 0.0, 0.0, 0.0 };
size_t iNL = strIn.find_last_of('\n');
if (os_npos != iNL)
strIn.resize(iNL);
// aial 3 Koordinatenpaare sind auf einer Geoetriezeile
int iCount = sscanf (strIn.c_str(), "G %lf%lf%lf%lf%lf%lf",
&dX[0], &dY[0], &dX[1], &dY[1], &dX[2], &dY[2]);
if (2 == iCount || 4 == iCount || 6 == iCount) {
bstrOut = L"G ";
for (int iIndex = 0; iIndex < iCount/2; ++iIndex) {
RETURN_FAILED_HRESULT(m_Callback->TransformCoords(
&dX[iIndex], &dY[iIndex]));
char cbBuffer[_MAX_PATH];
sprintf(cbBuffer, "%lf %lf ", dX[iIndex], dY[iIndex]);
bstrOut += cbBuffer;
}
bstrOut += L"\n";
}
}
*pbstrOut = bstrOut.Detach();
} COM_CATCH;
return S_OK;
}
STDMETHODIMP CSubIndicator :: ChangeText (PIFLAGS fWhichText, BSTR bstrNewText)
{
TX_ASSERT (NULL != (IProgressIndicator2 *) m_wPI);
// erstmal generell die verlangte Aktion ausführen
HRESULT hr = m_wPI -> ChangeText (fWhichText, bstrNewText);
// wenn der Statustext geändert wird, dann diesen Text ab sofort von hier aus handeln
if (fWhichText & PIFLAG_ADJUSTPERCENT || fWhichText & PIFLAG_STATUS)
{
USES_CONVERSION;
m_strPercentText = OLE2A(bstrNewText);
RETURN_FAILED_HRESULT(SetStatusText());
}
return hr;
}
bool CCoordTransService::Reload (bool fRefresh)
{
USES_CONVERSION;
CComBSTR bstr (GetProperty (m_Props, g_cbCoordTransform, A2OLE(g_cbDefault)));
if (!stricmp(OLE2A(bstr), m_strCTF.c_str())) {
return true; // muß neu initialisiert werden
} else if (!m_fIsDefault) {
m_fIsDefault = true;
return true; // war nicht DEFAULT und ist jetzt nichts mehr
}
if (fRefresh)
Refresh();
return false; // muß nicht neu geladen werden
}
HRESULT CToolBarButton::RetrieveBitmap (VARIANT &vPicture)
{
CComVariant vArg;
HRESULT hr = vArg.ChangeType (VT_DISPATCH, &vPicture);
if (SUCCEEDED(hr)) {
hr = V_DISPATCH(&vArg) -> QueryInterface(IID_IPictureDisp, m_PictDisp.ppv());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
hr = vArg.ChangeType (VT_I4, &vPicture); // BitmapHandle ?
if (SUCCEEDED(hr)) {
hr = CreatePicture ((HBITMAP)V_I4(&vArg), NULL, false, m_PictDisp.ppi());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
hr = vArg.ChangeType (VT_BSTR, &vPicture); // DateiName ?
if (SUCCEEDED(hr)) {
CBildObjekt bmp;
USES_CONVERSION;
HBITMAP hBmp = bmp.ReadFile (OLE2A(V_BSTR(&vArg)));
if (NULL != hBmp) {
hr = CreatePicture (bmp.Detach(), bmp.DetachHPal(), true, m_PictDisp.ppi());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
}
return E_INVALIDARG;
}
