const char* error_msg(void)
{
static char buf[512];
int code = sErrno;
snprintf(buf, sizeof(buf), "error %d: %s", code, sErr(code));
return buf;
}
void frmMain::requestTimeout()
{
// Останавливаем запрос:
reply->abort();
// Останавливаем таймер:
timer.stop();
// Ошибка - превышен интервал запроса. Сообщаем пользвателю. Если поднят флаг
// выхода - предлагаем пользователю настроить параметры соединения. Если флаг
// выхода не поднять - значит, пользовательский интерфейс уже открыт,
// и смысла предлагать пользователю его открыть нет.
QString sMsg(tr("Failed to get version info from site."));
QString sErr(tr("Request timeout."));
if (bExitOnReply)
{
sMsg.append(tr(" Open connection settings?"));
if (MsgUtilsMy::showQuestion(this, false, sMsg,
QString(), sErr))
bExitOnReply = false;
}
else
MsgUtilsMy::showErrorMsg(this, sMsg, QString(), sErr);
// Если установлен флаг выхода - выходим из программы, иначе показываем
// основную форму:
if (bExitOnReply)
qApp->exit(0);
else
this->show();
// Завершаем функцию:
return;
}
//********************************************** COARfile
wxString COARfile::FindAnalysisFile(
const wxString &sDir, const wxString &sSampleName)
{
wxDir dir(sDir);
wxString sRtn;
if(dir.IsOpened())
{
wxString sFileName;
wxString sFileLower;
const wxString sFileSpec(_T("*.o?r"));
bool b;
const int flags = wxDIR_FILES | wxDIR_HIDDEN;
multimap<wxDateTime,wxString> mapDateName;
multimap<wxDateTime,wxString>::reverse_iterator itr;
for(b = dir.GetFirst(&sFileName,sFileSpec,flags);
b; b = dir.GetNext(&sFileName))
{
wxFileName fn(sDir,sFileName);
if(!IS_ANALYSIS_FILE(sFileName))
{}
else if(fn.FileExists())
{
mapDateName.insert(
multimap<wxDateTime,wxString>::value_type(
fn.GetModificationTime(),fn.GetFullPath()) );
}
#ifdef _DEBUG
else
{
wxString sErr(_T("File: "));
sErr.Append(sFileName);
sErr.Append(_T(" is not found."));
wxASSERT_MSG(0,sErr);
}
#endif
}
if(mapDateName.empty()) {}
else if(sSampleName.IsEmpty())
{
sRtn = mapDateName.rbegin()->second;
}
else
{
for(itr = mapDateName.rbegin();
itr != mapDateName.rend();
++itr)
{
COARfile oar;
if( oar.LoadFile(itr->second) &&
(oar.GetSampleByName(sSampleName) != NULL) )
{
sRtn = itr->second;
break;
}
}
}
}
return sRtn;
}
BOOL CalculateExpression_Ole(CString& sExpr, CString sLang, BOOL bInSilence, int iEntryPoint)
{
cs.Lock();
int iRes=0;
::CoInitialize(NULL);
BOOL bJScriptLang=(sLang=="JScript" || sLang=="");
BOOL bVBScriptLang=(sLang=="VBScript");
if(bJScriptLang || bVBScriptLang)
{// Создаем область видимости чтобы разрушение ком-объекта было нормальным
MSScriptControl::IScriptControlPtr ScriptEngine;
ScriptEngine.CreateInstance("MSScriptControl.ScriptControl");
if(bJScriptLang){
ScriptEngine->Language="JScript";
}else if(bVBScriptLang){
ScriptEngine->Language="VBScript";
}else{
ScriptEngine->Language=(const char*)sLang;
}
ScriptEngine->Timeout = -1;//No timeout
try {//RET_FAIL(spAS->AddNamedItem(OLESTR("MyObject"), SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE), "IActiveScript::AddNamedItem()");
_variant_t result;
if(!bJScriptLang){
sExpr=CString("Dim OUTPUT\r\n")+sExpr;
ScriptEngine->ExecuteStatement(bstr_t(sExpr));
sExpr="OUTPUT";
result=ScriptEngine->Eval(bstr_t(sExpr));
}else{
result=ScriptEngine->Eval(bstr_t(sExpr));
}
sExpr=(const char*)_bstr_t(result);
iRes=1;
}catch(_com_error err){
if(!bInSilence){
//FLOG1("Script error: \n%s\n",sExpr)
CString sErr((BSTR)err.Description());
CString sErrSource((BSTR)err.Source());
if(sErrSource!=""){
sErr+="\n";
sErr+=sErrSource;
}
if(sErr==""){
sErr=GetCOMError(err.Error());
}
AfxMessageBox(sErr);
}
iRes=-1;
};
}else
{// Загружаем дллку
iRes=FALSE;
}
::CoUninitialize();
cs.Unlock();
return iRes;
}
HRESULT DMSHelper::GetDocument(CStdStringW sDocID, WSDocNonCom& docInfo, long lFlags)
{
LOG_WS_FUNCTION_SCOPE_MSG(sDocID);
USES_CONVERSION;
try
{
WSDOCUMENTPROVIDERLib::tagWSDOCUMENT wsDoc;
HRESULT hr = GetDocProvProxy()->GetDocument(_bstr_t(sDocID), lFlags, &wsDoc);
if (FAILED(hr))
{
//log
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("GetDocument failed for %s, error code %08x, %s"), CStdString(sDocID).c_str(), hr, sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
return hr;
}
docInfo = WSDocNonCom((WSDOCUMENT*)&wsDoc);
if (docInfo.GetDescription().IsEmpty())
{
CStdStringW sDescription;
GetDocIDDescription(docInfo.GetDocId(), sDescription);
docInfo.SetDescription(sDescription);
}
WSDocCleaner::CleanWSDoc(wsDoc);
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
std::vector<WSDocNonCom> DMSHelper::GetSynergyRelatedDocs(CStdStringW sDocID)
{
LOG_WS_FUNCTION_SCOPE_MSG(sDocID);
try
{
LONG lSize = 0;
WSDOCUMENTPROVIDERLib::tagWSDOCUMENT* pWSRelDocs = NULL;
HRESULT hr = GetDocProvProxy()->GetSynergyRelatedDocuments(_bstr_t(sDocID), &lSize, &pWSRelDocs);
if (FAILED(hr))
{
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("GetSynergyRelatedDocuments failed, error code %08x, %s"),hr,sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
if (hr == E_SYNERGY_SHARE_NOT_CONFIGURED)
return std::vector<WSDocNonCom>();
throw _com_error(hr);
}
std::vector<WSDocNonCom> vRelations;
for (int i=0; i<lSize; i++)
{
vRelations.push_back(WSDocNonCom((tagWSDOCUMENT*) &pWSRelDocs[i]));
}
::CoTaskMemFree(pWSRelDocs);
return vRelations;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
std::vector<WSDocumentVersionNoCom> DMSHelper::GetVersionsFromDMS(CStdStringW sDocID)
{
LONG lSize = 0;
WSDOCUMENTPROVIDERLib::tagWSDOCUMENTVERSION* pWSDocVers = NULL;
HRESULT hr = GetDocProvProxy()->GetVersions(_bstr_t(sDocID), &lSize, &pWSDocVers);
if (FAILED(hr))
{
//log
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("GetVersions failed, error code %08x, %s"),hr,sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
throw _com_error(hr);
}
try
{
std::vector<WSDocumentVersionNoCom> vVersions;
for (int i=0; i<lSize; i++)
{
vVersions.push_back(WSDocumentVersionNoCom((tagWSDOCUMENTVERSION*) &pWSDocVers[i]));
WSDocCleaner::CleanWSDocVer(pWSDocVers[i]);
}
::CoTaskMemFree(pWSDocVers);
return vVersions;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
void TestDocProvider5::TestPromote()
{
CStdString sDocumentName = _T("TestDocument for PromoteToSynergy");
CStdString sTestDocID;
m_pTestHelper->SaveDocument(sDocumentName, sTestDocID);
try
{
BSTR sDocID = ::SysAllocString(CT2CW(sTestDocID.c_str()));
m_pIDocProvider5->PromoteToSynergy(&sDocID);
::SysFreeString(sDocID);
}
catch(_com_error& e)
{
CStdString sErr(e.ErrorMessage());
assertMessage(false, sErr.c_str());
}
}
HRESULT DMSHelper::GetFolderEmailAddresses(CStdString sDocumentID, CStdString& sMailList)
{
USES_CONVERSION;
try
{
LOG_WS_FUNCTION_SCOPE_MSG(sDocumentID);
CComBSTR bstrMailList;
CStdString sMsg(_T("DistributionData::SetFolderEmailAddresses() : DOcID "));
sMsg += sDocumentID;
LOG_WS_INFO(sMsg.c_str());
HRESULT hr = GetDocProvProxy()->GetFolderEmailAddresses(_bstr_t(sDocumentID), &bstrMailList);
if (FAILED(hr))
{
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("GetFolderMailAddresses failed for %s, error code %08x, %s"), sDocumentID.c_str(), hr, sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
return hr;
}
sMailList = OLE2A(bstrMailList.m_str);
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
std::vector<WSDocNonCom> DMSHelper::GetAllRelatedDocs(CStdStringW sDocID)
{
LOG_WS_FUNCTION_SCOPE_MSG(sDocID);
try
{
std::vector<WSDocNonCom> vRelations;
if(GetCapabilities(sDocID) & WS_VERSION_INDEPENDENT_RELATED_DOCUMENTS)
{
vRelations = GetRelatedDocs(sDocID);
}
else
{
std::vector<WSDocumentVersionNoCom> vVersions = GetVersions(sDocID);
for (unsigned int i=0; i<vVersions.size(); i++)
{
std::vector<WSDocNonCom> vSomeRelations = GetRelatedDocs(vVersions[i].GetWSDocument().GetDocId());
vRelations.insert(vRelations.end(), vSomeRelations.begin(), vSomeRelations.end());
}
}
return vRelations;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
HRESULT DMSHelper::IsDmsInOfflineMode(const CStdStringW& sDocID, bool& bOffline)
{
try
{
VARIANT_BOOL vbOffline = VARIANT_FALSE;
HRESULT hr = GetDocProvProxy()->IsDmsInOfflineMode(_bstr_t(sDocID), &vbOffline);
if(hr == E_NOINTERFACE)
{
bOffline = false;
return S_OK;
}
if (FAILED(hr))
{
CStdString sError, sErrorReason;
GetDocProvProxy()->GetErrorDescription(hr, sErrorReason);
sError.Format(_T("IsDmsInOfflineMode failed, error code 0x%08x, %s"), hr, sErrorReason.c_str());
LOG_WS_ERROR(sError.c_str());
}
bOffline = vbOffline != VARIANT_FALSE;
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
ret_ CXMLLoaderManager::Stop()
{
_DEL(m_pErrorHandle);
_DEL(m_pParser);
try
{
XMLPlatformUtils::Terminate();
}
catch (const XMLException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
return XML_UNINITIALIZE_ERROR;
}
return SUCCESS;
}
HRESULT DMSHelper::IsCC(CStdStringW sDocID, bool& bIsCC)
{
USES_CONVERSION;
try
{
VARIANT_BOOL vbIsCC;
HRESULT hr = GetDocProvProxy()->IsCC(_bstr_t(sDocID), &vbIsCC);
if (FAILED(hr))
{
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("IsCC failed , error code %08x, %s"), hr, sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
return hr;
}
bIsCC = vbIsCC != 0;
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
//so you must call save first if you dont want to lose your changes
//returns the DocID of the newly created version
HRESULT DMSHelper::VersionDocument(CStdStringW& szDocumentID, const CStdStringW& sComment)
{
LOG_WS_FUNCTION_SCOPE_MSG(szDocumentID);
BSTR bstrDocumentID = szDocumentID.AllocSysString();
HRESULT hRes = GetDocProvProxy()->VersionDocument(&bstrDocumentID, _bstr_t(sComment));
if(FAILED(hRes))
{
CStdString sErr(_T("DMSHelper::VersionDocument failed on document : "));
sErr+= szDocumentID;
LOG_WS_ERROR(sErr.c_str());
}
if(bstrDocumentID != NULL)
{
szDocumentID = bstrDocumentID;
::SysFreeString(bstrDocumentID);
}
return hRes;
}
std::vector<WSDocNonCom> DMSHelper::GetAllRelatedDraftsForUser(CStdStringW sDocID)
{
try
{
std::vector<WSDocNonCom> vsAllRelations = GetAllRelatedSynergyDocs(sDocID);
std::vector<WSDocNonCom> vsAllRelationsForUser;
CStdString sCurrentUser = GetCurrentDmsUser(sDocID);
for (unsigned int i=0; i<vsAllRelations.size(); i++)
{
WSDocNonCom& wsdThis = vsAllRelations[i];
if ((wsdThis.GetExtension().CompareNoCase(CStdString(DRAFT_FILE_EXTENSION)) == 0) &&
IncludeThisDraftForUser(wsdThis.GetAuthor(), sCurrentUser))
{
vsAllRelationsForUser.push_back(wsdThis);
}
}
return vsAllRelationsForUser;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
HRESULT DMSHelper::DocumentHasMatterID(CStdString sDocumentID, bool& bDocumentHasMatterID)
{
try
{
VARIANT_BOOL vHasMatterId;
HRESULT hr = GetDocProvProxy()->DocumentHasMatterID(_bstr_t(sDocumentID), &vHasMatterId);
if (FAILED(hr))
{
CStdString sErr;
CStdString sErrReason(_T(""));
GetDocProvProxy()->GetErrorDescription(hr,sErrReason);
sErr.Format(_T("DocumentHasMatterID failed , error code %08x, %s"), hr, sErrReason.c_str());
LOG_WS_ERROR(sErr.c_str());
return hr;
}
bDocumentHasMatterID = (vHasMatterId == VARIANT_TRUE);
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
HRESULT DMSHelper::RelateDocument(WSDocNonCom& wsdoc, CStdStringW sExistingDocID)
{
LOG_WS_FUNCTION_SCOPE_MSG(sExistingDocID);
try
{
WSDOCUMENTPROVIDERLib::tagWSDOCUMENT wsDocument;
wsdoc.InitializeWSDOCUMENT((WSDOCUMENT*) &wsDocument);
HRESULT hr = GetDocProvProxy()->RelateDocument(&wsDocument, _bstr_t(sExistingDocID));
if (SUCCEEDED(hr))
{
wsdoc = WSDocNonCom((WSDOCUMENT*)&wsDocument);
GetRelatedListCache()->RemoveCachedAssociatedDocs(sExistingDocID);
}
WSDocCleaner::CleanWSDoc(wsDocument);
return hr;
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
std::vector<CStdStringW> DMSHelper::GetAllRelatedSynergyDocsWithExtension(CStdStringW sDocID, CStdStringW sExtension)
{
try
{
return FilterVectorByExtension(GetAllRelatedSynergyDocs(sDocID), sExtension);
}
catch(_com_error& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(std::exception& e)
{
LOG_WS_ERROR_RESULT(e);
throw;
}
catch(TCHAR*& e)
{
CStdString sErr(e);
sErr.append(_T("(TCHAR*): This exception was thrown"));
LOG_WS_ERROR(sErr);
throw;
}
}
bool SubrasterByVector(wxGISFeatureDatasetSPtr pSrcFeatureDataSet, wxGISRasterDatasetSPtr pSrcRasterDataSet, CPLString &szDstFolderPath, wxGxRasterFilter* pFilter, GDALDataType eOutputType, int nBandCount, int *panBandList, bool bUseCounter, int nCounterBegin, int nFieldNo, double dfOutResX, double dfOutResY, bool bCopyNodata, bool bSkipSourceMetadata, char** papszOptions, ITrackCancel* pTrackCancel)
{
//check if openned or/and open dataset
if(!pSrcFeatureDataSet->IsOpened())
{
if(!pSrcFeatureDataSet->Open(true))
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source vector dataset open failed"), -1, enumGISMessageErr);
return false;
}
}
if(!pSrcRasterDataSet->IsOpened())
{
if(!pSrcRasterDataSet->Open(true))
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source raster dataset open failed"), -1, enumGISMessageErr);
return false;
}
}
const OGRSpatialReferenceSPtr pSrsSRS = pSrcFeatureDataSet->GetSpatialReference();
const OGRSpatialReferenceSPtr pDstSRS = pSrcRasterDataSet->GetSpatialReference();
OGRCoordinateTransformation *poCT(NULL);
bool bSame = pSrsSRS == NULL || pDstSRS == NULL || pSrsSRS->IsSame(pDstSRS.get());
if( !bSame )
{
poCT = OGRCreateCoordinateTransformation( pSrsSRS.get(), pDstSRS.get() );
if(poCT == NULL)
{
const char* err = CPLGetLastErrorMsg();
wxString sWarn = wxString::Format(_("Create OGRCreateCoordinateTransformation failed! GDAL error: %s"), wxString(err, wxConvUTF8).c_str());
wxLogWarning(sWarn);
if(pTrackCancel)
pTrackCancel->PutMessage(sWarn, -1, enumGISMessageWarning);
}
}
IProgressor* pProgressor(NULL);
if(pTrackCancel)
{
pProgressor = pTrackCancel->GetProgressor();
pTrackCancel->PutMessage(wxString::Format(_("Start clip '%s' by geometry from '%s'"), wxString(pSrcRasterDataSet->GetPath(), wxConvUTF8).c_str(), wxString(pSrcFeatureDataSet->GetPath(), wxConvUTF8).c_str()), -1, enumGISMessageNorm);
}
int nCounter(0);
if(pProgressor)
pProgressor->SetRange(pSrcFeatureDataSet->GetFeatureCount());
/* -------------------------------------------------------------------- */
/* Build band list to translate */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 )
{
nBandCount = pSrcRasterDataSet->GetBandCount();
if( nBandCount == 0 )
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Input file has no bands, and so cannot be translated."), -1, enumGISMessageErr);
return false;
}
panBandList = (int *) CPLMalloc(sizeof(int)*nBandCount);
for(size_t i = 0; i < nBandCount; ++i )
panBandList[i] = i + 1;
}
else
{
for(size_t i = 0; i < nBandCount; ++i )
{
if( panBandList[i] > pSrcRasterDataSet->GetBandCount() )
{
if(pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("Band %d requested, but only bands 1 to %d available."), panBandList[i], pSrcRasterDataSet->GetBandCount()), -1, enumGISMessageErr);
return false;
}
}
}
bool bDefaultfilter(false);
if(pFilter == NULL)
{
pFilter = new wxGxRasterFilter(enumRasterTiff);
bDefaultfilter = true;
}
CPLString szDriver(pFilter->GetDriver().mb_str());
CPLString szExt(pFilter->GetExt().mb_str());
CPLString szBaseName = CPLGetBasename(pSrcRasterDataSet->GetPath());
GDALDriver* pDriver = (GDALDriver*)GDALGetDriverByName( szDriver );
if( pDriver == NULL )
{
if(pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("Output driver '%s' not recognised."), szDriver.c_str()), -1, enumGISMessageErr);
if(bDefaultfilter)
wxDELETE(pFilter);
return false;
}
pSrcFeatureDataSet->Reset();
OGRFeatureSPtr pFeature;
size_t nNameCounter(nCounterBegin);
while((pFeature = pSrcFeatureDataSet->Next()) != NULL)
{
if(pTrackCancel && !pTrackCancel->Continue())
{
wxString sErr(_("Interrupted by user"));
CPLString sFullErr(sErr.mb_str());
CPLError( CE_Warning, CPLE_AppDefined, sFullErr );
if(pTrackCancel)
pTrackCancel->PutMessage(wxString(sFullErr, wxConvLocal), -1, enumGISMessageErr);
if(bDefaultfilter)
wxDELETE(pFilter);
return false;
}
OGRGeometry *pGeom = pFeature->GetGeometryRef();
if(wkbFlatten(pSrcFeatureDataSet->GetGeometryType()) != wkbUnknown && !pGeom)
continue;
OGRGeometry *pNewGeom(NULL);
if( !bSame && poCT )
{
if(pGeom)
{
pNewGeom = pGeom->clone();
OGRErr eErr = pNewGeom->transform(poCT);
if(eErr != OGRERR_NONE)
wxDELETE(pNewGeom);
}
}
else
pNewGeom = pGeom->clone();
OGREnvelope GeomEnv;
pNewGeom->getEnvelope(&GeomEnv);
OGREnvelope RasterEnv = pSrcRasterDataSet->GetEnvelope();
GeomEnv.Intersect(RasterEnv);
if(GeomEnv.IsInit())
{
CPLString szPath;
if(bUseCounter)
{
szPath.Printf("%s_%d", szBaseName.c_str(), nNameCounter++);
CPLString sNewName(CheckUniqName(szDstFolderPath, szPath, szExt).mb_str(wxConvUTF8));
szPath = CPLFormFilename(szDstFolderPath, sNewName, szExt);
}
else
{
CPLString szName = pFeature->GetFieldAsString(nFieldNo);
CPLString sNewName(CheckUniqName(szDstFolderPath, szName, szExt).mb_str(wxConvUTF8));
szPath = CPLFormFilename(szDstFolderPath, sNewName, szExt);
}
CreateSubRaster(pSrcRasterDataSet, GeomEnv, pNewGeom, pDriver, szPath, eOutputType, nBandCount, panBandList, dfOutResX, dfOutResY, bCopyNodata, bSkipSourceMetadata, papszOptions, pTrackCancel);
}
nCounter++;
if(pProgressor)
pProgressor->SetValue(nCounter);
}
if(poCT)
OCTDestroyCoordinateTransformation(poCT);
if(bDefaultfilter)
wxDELETE(pFilter);
return true;
}
ret_ CXMLLoaderActions::Load(XercesDOMParser *pParser,
const ch_1 *pszEnvironmentPath)
{
#ifdef _DEBUG_
if (!pParser)
return PARAMETER_NULL | PARAMETER_1;
if (!pszEnvironmentPath)
return PARAMETER_NULL | PARAMETER_2;
if (null_v == pszEnvironmentPath[0])
return PARAMETER_EMPTY | PARAMETER_2;
#endif
SetParser(pParser);
ch_1 sActions[ENVIRONMENT_PATH_LENGTH];
memset(sActions, 0, ENVIRONMENT_PATH_LENGTH);
sprintf(sActions, "%s%s", pszEnvironmentPath, ACTIONS_XML_FILE);
DOMDocument *pActionsDoc = null_v;
try
{
GetParser()->parse(sActions);
pActionsDoc = GetParser()->getDocument();
}
catch (const OutOfMemoryException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
return XML_LOADER_ERROR;
}
catch (const XMLException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
return XML_LOADER_ERROR;
}
catch (const DOMException &err)
{
auto_xerces_str sErr(err.msg);
printf("%s\n", (const ch_1 *)sErr);
return XML_LOADER_ERROR;
}
catch (...)
{
printf("Unexpected error during parsing.\n");
return XML_LOADER_ERROR;
}
if (!pActionsDoc)
return XML_LOADER_ERROR;
DOMElement *pRoot = pActionsDoc->getDocumentElement();
if (!pRoot)
return XML_LOADER_ERROR;
DOMElement *pChild = (DOMElement *)pRoot->getFirstChild();
if (!pChild)
return XML_LOADER_ERROR;
auto_xerces_str wsDataBlock("data_block");
auto_xerces_str wsStart("start");
auto_xerces_str wsProcessor("processor");
auto_xerces_str wsEnd("end");
while (pChild)
{
if (0 == XMLString::compareString(pChild->getNodeName(),
wsDataBlock))
{
if (SUCCESS != LoadDataBlock(CUIManager::Instance()->Data(),
pChild))
{
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsStart))
{
if (SUCCESS != LoadProgram(&CUIManager::Instance()->Data(),
CUIManager::Instance()->StartProgram(),
pChild))
{
return XML_LOADER_ERROR;
}
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsProcessor))
{
if (SUCCESS != LoadProcessor(pChild))
return XML_LOADER_ERROR;
m_pTmpContainer = null_v;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsEnd))
{
if (SUCCESS != LoadProgram(&CUIManager::Instance()->Data(),
CUIManager::Instance()->EndProgram(),
pChild))
{
return XML_LOADER_ERROR;
}
}
pChild = (DOMElement *)pChild->getNextSibling();
}
return SUCCESS;
}
bool AP_Win32App::initialize(void)
{
bool bSuccess = true;
const char * szUserPrivateDirectory = getUserPrivateDirectory();
bool bVerified = s_createDirectoryIfNecessary(szUserPrivateDirectory);
UT_return_val_if_fail (bVerified, false);
// load the preferences.
m_prefs = new AP_Win32Prefs();
UT_return_val_if_fail (m_prefs, false);
m_prefs->fullInit();
// now that preferences are established, let the xap init
m_pClipboard = new AP_Win32Clipboard();
UT_return_val_if_fail (m_pClipboard, false);
m_pEMC = AP_GetEditMethods();
UT_return_val_if_fail (m_pEMC, false);
m_pBindingSet = new AP_BindingSet(m_pEMC);
UT_return_val_if_fail (m_pBindingSet, false);
m_pMenuActionSet = AP_CreateMenuActionSet();
UT_return_val_if_fail (m_pMenuActionSet,false);
m_pToolbarActionSet = AP_CreateToolbarActionSet();
UT_return_val_if_fail (m_pToolbarActionSet,false);
//////////////////////////////////////////////////////////////////
// load the dialog and message box strings
//////////////////////////////////////////////////////////////////
{
// assume we will be using the builtin set (either as the main
// set or as the fallback set).
AP_BuiltinStringSet * pBuiltinStringSet = new AP_BuiltinStringSet(this,AP_PREF_DEFAULT_StringSet);
UT_return_val_if_fail (pBuiltinStringSet, false);
m_pStringSet = pBuiltinStringSet;
// see if we should load an alternate set from the disk
const char * szDirectory = NULL;
const char * szStringSet = NULL;
if ( (getPrefsValue(AP_PREF_KEY_StringSet,&szStringSet))
&& (szStringSet)
&& (*szStringSet)
&& (g_ascii_strcasecmp(szStringSet,AP_PREF_DEFAULT_StringSet) != 0))
{
getPrefsValueDirectory(true,AP_PREF_KEY_StringSetDirectory,&szDirectory);
UT_return_val_if_fail ((szDirectory) && (*szDirectory), false);
char * szPathname = (char *)UT_calloc(sizeof(char),strlen(szDirectory)+strlen(szStringSet)+100);
UT_return_val_if_fail (szPathname, false);
sprintf(szPathname,"%s%s%s.strings",
szDirectory,
((szDirectory[strlen(szDirectory)-1]=='\\') ? "" : "\\"),
szStringSet);
AP_DiskStringSet * pDiskStringSet = new AP_DiskStringSet(this);
UT_return_val_if_fail (pDiskStringSet, false);
if (pDiskStringSet->loadStringsFromDisk(szPathname))
{
pDiskStringSet->setFallbackStringSet(m_pStringSet);
m_pStringSet = pDiskStringSet;
UT_Language_updateLanguageNames();
UT_DEBUGMSG(("Using StringSet [%s]\n",szPathname));
}
else
{
UT_DEBUGMSG(("Unable to load StringSet [%s] -- using builtin strings instead.\n",szPathname));
DELETEP(pDiskStringSet);
}
g_free(szPathname);
}
}
// AP_App::initilize() calls for us XAP_Win32App::initialize()
if (! AP_App::initialize())
return false;
// let various window types register themselves
if (!AP_Win32Frame::RegisterClass(this))
{
UT_DEBUGMSG(("couldn't register class\n"));
return false;
}
//////////////////////////////////////////////////////////////////
// Initialize the importers/exporters
//////////////////////////////////////////////////////////////////
IE_ImpExp_RegisterXP ();
//////////////////////////////////////////////////////////////////
// initializes the spell checker.
//////////////////////////////////////////////////////////////////
{
#if ENABLE_SPELL
SpellManager::instance();
#endif
}
// Now we have the strings loaded we can populate the field names correctly
int i;
for (i = 0; fp_FieldTypes[i].m_Type != FPFIELDTYPE_END; i++)
{
(&fp_FieldTypes[i])->m_Desc = m_pStringSet->getValue(fp_FieldTypes[i].m_DescId);
UT_DEBUGMSG(("Setting field type desc for type %d, desc=%s\n", fp_FieldTypes[i].m_Type, fp_FieldTypes[i].m_Desc));
}
for (i = 0; fp_FieldFmts[i].m_Tag != NULL; i++)
{
(&fp_FieldFmts[i])->m_Desc = m_pStringSet->getValue(fp_FieldFmts[i].m_DescId);
UT_DEBUGMSG(("Setting field desc for field %s, desc=%s\n", fp_FieldFmts[i].m_Tag, fp_FieldFmts[i].m_Desc));
}
///////////////////////////////////////////////////////////////////////
/// Build a labelset so the plugins can add themselves to something ///
///////////////////////////////////////////////////////////////////////
const char * szMenuLabelSetName = NULL;
if (getPrefsValue( AP_PREF_KEY_StringSet, (const gchar**)&szMenuLabelSetName)
&& (szMenuLabelSetName) && (*szMenuLabelSetName))
{
;
}
else
szMenuLabelSetName = AP_PREF_DEFAULT_StringSet;
getMenuFactory()->buildMenuLabelSet(szMenuLabelSetName);
//////////////////////////////////////////////////////////////////
// Check for necessary DLLs now that we can do localized error messages
//////////////////////////////////////////////////////////////////
#if 0 /* re-enable once we use unicows again */
// Ensure that we have Unicows dll
if (!UT_IsWinNT())
{
HMODULE hModule = LoadLibrary("unicows.dll");
if (!hModule)
{
UT_String sErr(UT_String_sprintf(m_pStringSet->getValue(AP_STRING_ID_WINDOWS_NEED_UNICOWS),
"Unicows"));
MessageBox(NULL, sErr.c_str(), NULL, MB_OK);
bSuccess = false;
}
else
FreeLibrary(hModule);
}
#endif
// Ensure that common control DLL is loaded
HINSTANCE hinstCC = LoadLibrary("comctl32.dll");
UT_return_val_if_fail (hinstCC, false);
InitCommonControlsEx_fn pInitCommonControlsEx = NULL;
if( hinstCC != NULL )
pInitCommonControlsEx = (InitCommonControlsEx_fn)GetProcAddress( hinstCC, "InitCommonControlsEx" );
if( pInitCommonControlsEx != NULL )
{
INITCOMMONCONTROLSEX icex;
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES // load the rebar and toolbar
| ICC_TAB_CLASSES | ICC_UPDOWN_CLASS // and tab and spin controls
;
pInitCommonControlsEx(&icex);
}
else
{
InitCommonControls();
UT_String sErr(UT_String_sprintf(m_pStringSet->getValue(AP_STRING_ID_WINDOWS_COMCTL_WARNING),
"Unicows"));
MessageBox(NULL, sErr.c_str(), NULL, MB_OK);
}
//////////////////////////////////////////////////////////////////
// load the all Plugins from the correct directory
//////////////////////////////////////////////////////////////////
#ifndef DISABLE_BUILTIN_PLUGINS
abi_register_builtin_plugins();
#endif
bool bLoadPlugins = true;
bool bFound = getPrefsValueBool(XAP_PREF_KEY_AutoLoadPlugins,&bLoadPlugins);
if(bLoadPlugins || !bFound)
{
char szPath[PATH_MAX];
char szPlugin[PATH_MAX];
_getExeDir( szPath, PATH_MAX);
#ifdef _MSC_VER
strcat(szPath, "..\\plugins\\*.dll");
#else
strcat(szPath, "..\\lib\\" PACKAGE "-" ABIWORD_SERIES "\\plugins\\*.dll");
#endif
struct _finddata_t cfile;
long findtag = _findfirst( szPath, &cfile );
if( findtag != -1 )
{
do
{
_getExeDir( szPlugin, PATH_MAX );
#ifdef _MSC_VER
strcat( szPlugin, "..\\plugins\\" );
#else
strcat( szPlugin, "..\\lib\\" PACKAGE "-" ABIWORD_SERIES "\\plugins\\" );
#endif
strcat( szPlugin, cfile.name );
XAP_ModuleManager::instance().loadModule( szPlugin );
} while( _findnext( findtag, &cfile ) == 0 );
}
_findclose( findtag );
UT_String pluginName( getUserPrivateDirectory() );
UT_String pluginDir( getUserPrivateDirectory() );
pluginDir += "\\AbiWord\\plugins\\*.dll";
findtag = _findfirst( pluginDir.c_str(), &cfile );
if( findtag != -1 )
{
do
{
pluginName = getUserPrivateDirectory();
pluginName += "\\AbiWord\\plugins\\";
pluginName += cfile.name;
XAP_ModuleManager::instance().loadModule( pluginName.c_str() );
} while( _findnext( findtag, &cfile ) == 0 );
}
_findclose( findtag );
}
return bSuccess;
}
void frmMain::readReply(QNetworkReply * replyIn)
{
// Проверяем, не произошло ли ошибки при выполнении запроса:
if (replyIn->error() != QNetworkReply::NoError)
{
// Ошибка произошла - сообщаем о ней. Если поднят флаг выхода -
// предлагаем пользователю настроить параметры соединения. Если флаг
// выхода не поднять - значит, пользовательский интерфейс уже открыт,
// и смысла предлагать пользователю его открыть нет.
QString sMsg(tr("Failed to get version info from site."));
QString sErr(replyIn->errorString());
if (bExitOnReply)
{
sMsg.append(tr(" Open connection settings?"));
if (MsgUtilsMy::showQuestion(this, false, sMsg,
QString(), sErr))
bExitOnReply = false;
}
else
MsgUtilsMy::showErrorMsg(this, sMsg, QString(), sErr);
// Если установлен флаг выхода - выходим из программы, иначе показываем
// основную форму:
if (bExitOnReply)
qApp->exit(0);
else
this->show();
// Завершаем функцию:
return;
}
// Получаем текст полученного ответа на запрос:
QString sVer(replyIn->readAll());
// Маркер начала версии программы:
QString sVerStartMark(VERSION_START);
// Маркер окончания версии программы:
QString sVerEndMark(VERSION_END);
// Проверка наличия версии программы в нужном формате.
// Ищем маркер начала строки версии:
int iVStart = sVer.indexOf(sVerStartMark, 0, Qt::CaseInsensitive);
// Позиция маркера окончания строки версии:
int iVEnd = -1;
// В случае, если маркер начала версии найден - ищем маркер окончания версии:
if (iVStart > -1)
iVEnd = sVer.indexOf(sVerEndMark, iVStart, Qt::CaseInsensitive);
// В случае, если маркер начала или маркер окончания строки версии не найден -
// сообщаем об ошибке и завершаем функцию:
if (iVStart == -1 || iVEnd == -1)
{
// Ошибка произошла - сообщаем о ней:
MsgUtilsMy::showErrorMsg(this, tr("Error while readin version from site."),
QString(), tr("Version start or version end marker is not found."));
// Если установлен флаг выхода - выходим из программы, иначе показываем
// основную форму:
if (bExitOnReply)
qApp->exit(0);
else
this->show();
// Завершаем функцию:
return;
}
// Убираем окончание строки, начиная с первого символа маркера окончания строки версии:
sVer.remove(iVEnd, sVer.length() - iVEnd);
// Убираем начало строки до версии, включая маркер начала версии:
sVer.remove(0, iVStart + sVerStartMark.length());
// Создаём объекты версий:
LWVersion verCurrent(sCurVer);
LWVersion verSite(sVer);
// Если версия на сайте больше - сообщаем об этом и предлагаем перейти на сайт:
if (verSite.isHigherThan(verCurrent))
{
if (MsgUtilsMy::showQuestion(this, false,
tr("New %1 version is available. Open download page?").arg(sProg)))
QDesktopServices::openUrl(QUrl(sPageGoTo));
}
// Установлена последняя версия. В случае, если поднят флаг выхода
// после проверки - сообщать о наличии последней версии пользователю
// не нужно. В случае, если флаг выхода не поднят - значит, проверка
// запущена пользователем, и надо сообщить ему, что у него самая
// последняя версия:
else
{
// Сообщаем об отстутствии обновлений в случае, если вывод
// таких сообщений явно включен, и в случае, если вывод
// не выключен и не поднят флаг выхода после проверки:
if ((iNupMsg == 2) || ((iNupMsg != 1) && !bExitOnReply))
// Сообщаем, что установлена последняя версия:
MsgUtilsMy::showInfoMsg(this,
tr("Latest %1 version is installed.").arg(sProg));
}
// Если поднят флаг завершения работы приложения после получения ответа -
// завершаем работу приложения, иначе показываем главное окно:
if (bExitOnReply)
qApp->exit(0);
else
this->show();
}
ret_ CXMLLoaderNetwork::Load(XercesDOMParser *pParser,
const ch_1 *pszEnvironmentPath)
{
_START(LOAD);
#ifdef _DEBUG_
if (!pParser)
_RET(PARAMETER_NULL | PARAMETER_1);
if (!pszEnvironmentPath)
_RET(PARAMETER_NULL | PARAMETER_2);
if (null_v == pszEnvironmentPath[0])
_RET(PARAMETER_EMPTY | PARAMETER_2);
#endif
SetParser(pParser);
ch_1 sNetwork[ENVIRONMENT_PATH_LENGTH];
memset(sNetwork, 0, ENVIRONMENT_PATH_LENGTH);
strncpy(sNetwork, pszEnvironmentPath, ENVIRONMENT_PATH_LENGTH);
strncat(sNetwork, NETWORK_XML_FILE, ENVIRONMENT_PATH_LENGTH);
DOMDocument *pNetworkDoc = null_v;
try
{
GetParser()->parse(sNetwork);
pNetworkDoc = GetParser()->getDocument();
}
catch (const OutOfMemoryException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
_RET(XML_LOADER_ERROR);
}
catch (const XMLException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
_RET(XML_LOADER_ERROR);
}
catch (const DOMException &err)
{
auto_xerces_str sErr(err.getMessage());
printf("%s\n", (const ch_1 *)sErr);
_RET(XML_LOADER_ERROR);
}
catch (...)
{
printf("Unexpected error during parsing.\n");
_RET(XML_LOADER_ERROR);
}
DOMElement *pRoot = pNetworkDoc->getDocumentElement();
if (!pRoot)
_RET(XML_LOADER_ERROR);
DOMElement *pChild = (DOMElement *)pRoot->getFirstChild();
if (!pChild)
_RET(XML_LOADER_ERROR);
auto_xerces_str wsIdentity ("identity");
auto_xerces_str wsPDU ("pdu");
auto_xerces_str wsDirection ("direction");
auto_xerces_str wsName ("name");
auto_xerces_str wsProtocolName ("protocol");
auto_xerces_str wsCommandID ("command_id");
auto_xerces_str wsSizeID ("size_id");
auto_xerces_str wsLocalPort ("local_port");
auto_xerces_str wsAuto ("auto");
auto_xerces_str wsFilter ("filter");
auto_xerces_str wsMaxConnections("max_connections");
auto_xerces_str wsRemoteIP ("remote_ip");
auto_xerces_str wsRemotePort ("remote_port");
auto_xerces_str wsReconnect ("reconnect");
auto_xerces_str wsAcceptorName ("acceptor");
auto_xerces_str wsConnectorName ("connector");
auto_xerces_str wsReceiverName ("receiver");
auto_xerces_str wsSenderName ("sender");
auto_xerces_str wsType ("type");
while (pChild)
{
ENetworkType NetworkType = NETWORK_NONE;
CProtocolInfo *pProtocol = null_v;
CField *pCommandIDField = null_v;
CField *pSizeIDField = null_v;
bool_ bIsAutoStart = true_v;
if (0 == XMLString::compareString(pChild->getNodeName(),
wsAcceptorName))
{
NetworkType = NETWORK_ACCEPTOR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsConnectorName))
{
NetworkType = NETWORK_CONNECTOR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsReceiverName))
{
NetworkType = NETWORK_RECEIVER;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsSenderName))
{
NetworkType = NETWORK_SENDER;
}
else
{
pChild = (DOMElement *)pChild->getNextSibling();
continue;
}
auto_xerces_str sProtocolName(pChild->getAttribute(wsProtocolName));
if (SUCCESS != _ERR(
CXMLLoaderProtocol::Instance()->Load(pParser,
pszEnvironmentPath,
sProtocolName)))
{
_RET(XML_LOADER_ERROR);
}
//
if (SUCCESS != _ERR(
CProtocolManager::instance()->getProtocol(sProtocolName,
pProtocol)))
{
_RET(XML_LOADER_ERROR);
}
//
auto_xerces_str sCommandID(pChild->getAttribute(wsCommandID));
if (SUCCESS != _ERR(pProtocol->getHeadField(sCommandID,
pCommandIDField))
|| FIELD_NORMAL_STYLE !=
(pCommandIDField->type() & FIELD_NORMAL_STYLE)
|| 4 < _LEN(pCommandIDField->type()))
{
_RET(XML_LOADER_ERROR);
}
//
auto_xerces_str sSizeID(pChild->getAttribute(wsSizeID));
if (SUCCESS != _ERR(pProtocol->getHeadField(sSizeID,
pSizeIDField))
|| FIELD_NORMAL_STYLE !=
(pSizeIDField->type() & FIELD_NORMAL_STYLE)
|| 4 < _LEN(pSizeIDField->type()))
{
_RET(XML_LOADER_ERROR);
}
//
auto_xerces_str wsAutoFalse("false");
if (0 == XMLString::compareString(wsAutoFalse,
pChild->getAttribute(wsAuto)))
{
bIsAutoStart = false_v;
}
CNode *pNetwork = null_v;
auto_xerces_str sName(pChild->getAttribute(wsName));
switch (NetworkType)
{
case NETWORK_NONE:
_RET(XML_LOADER_ERROR);
case NETWORK_ACCEPTOR:
{
auto_xerces_str sLocalPort(pChild->getAttribute(wsLocalPort));
auto_xerces_str
sMaxConnections(pChild->getAttribute(wsMaxConnections));
pNetwork = new CAcceptor(pProtocol,
pCommandIDField,
pSizeIDField,
(ub_2)atoi(sLocalPort),
(size_)atoi(sMaxConnections),
bIsAutoStart);
}
break;
case NETWORK_CONNECTOR:
{
//
auto_xerces_str nLocalPort (pChild->getAttribute(wsLocalPort));
auto_xerces_str sRemoteIP (pChild->getAttribute(wsRemoteIP));
auto_xerces_str nRemotePort
(pChild->getAttribute(wsRemotePort));
auto_xerces_str sReconnect (pChild->getAttribute(wsReconnect));
pNetwork = new CConnector(pProtocol,
pCommandIDField,
pSizeIDField,
(ub_2)atoi(nLocalPort),
(const ch_1 *)sRemoteIP,
(ub_2)atoi(nRemotePort),
(b_4)atoi(sReconnect),
bIsAutoStart);
}
break;
case NETWORK_RECEIVER:
{
//
auto_xerces_str sLocalPort(pChild->getAttribute(wsLocalPort));
pNetwork = new CReceiver(pProtocol,
pCommandIDField,
pSizeIDField,
(ub_2)atoi(sLocalPort),
bIsAutoStart);
}
break;
case NETWORK_SENDER:
{
//
auto_xerces_str sLocalPort(pChild->getAttribute(wsLocalPort));
pNetwork = new CSender(pProtocol,
pCommandIDField,
pSizeIDField,
(ub_2)atoi(sLocalPort),
bIsAutoStart);
}
}
CNodeConf *pNetworkConf = (CNodeConf *) pNetwork->getConf();
//
DOMElement *pSub = (DOMElement *)pChild->getFirstChild();
if (!pSub)
_RET(XML_LOADER_ERROR);
while (pSub)
{
if (0 == XMLString::compareString(pSub->getNodeName(),
wsIdentity))
{
//
auto_xerces_str sIdentity(pSub->getAttribute(wsIdentity));
ch_1 *sIdentityName = null_v;
if (SUCCESS != _ERR(GetLastName(sIdentity, sIdentityName)))
_RET(XML_LOADER_ERROR);
v_ *pV = pProtocol->data().value(sIdentityName);
if (!pV)
_RET(XML_LOADER_ERROR);
//
auto_xerces_str sPDU(pSub->getAttribute(wsPDU));
CPduInfo *pPDU = null_v;
if (SUCCESS != _ERR(pProtocol->getPdu(sPDU, pPDU)))
_RET(XML_LOADER_ERROR);
//
auto_xerces_str sDirection(pSub->getAttribute(wsDirection));
EDirection Direction;
if (SUCCESS != _ERR(GetDirection(sDirection, Direction)))
_RET(XML_LOADER_ERROR);
//
if (SUCCESS != _ERR(pNetworkConf->ConfigPDU(*pV,
pPDU,
Direction)))
{
_RET(XML_LOADER_ERROR);
}
}
else if (0 == XMLString::compareString(pSub->getNodeName(),
wsFilter))
{
CIPFilter *pIPFilter = null_v;
if (NETWORK_ACCEPTOR == NetworkType)
{
pIPFilter =
&((CAcceptorConf *)pNetworkConf)->IPFilter();
}
else if (NETWORK_RECEIVER == NetworkType)
{
pIPFilter =
&((CReceiverConf *)pNetworkConf)->IPFilter();
}
else
{
_RET(XML_LOADER_ERROR);
}
auto_xerces_str sType(pSub->getAttribute(wsType));
if (0 == strcmp(sType, "forbid")) {
pIPFilter->setForbid(true_v);
} else if (0 == strcmp(sType, "permit")) {
pIPFilter->setForbid(false_v);
}
auto_xerces_str sIPGroup(pSub->getTextContent());
if (false_v == pIPFilter->addIpGroup((const ch_1 *) sIPGroup))
_RET(XML_LOADER_ERROR);
}
pSub = (DOMElement *)pSub->getNextSibling();
}
if (SUCCESS != _ERR(CNetworkManager::instance()->AddNetwork(
(const char *)sName,
NetworkType,
pNetwork)))
{
_RET(XML_LOADER_ERROR);
}
pChild = (DOMElement *)pChild->getNextSibling();
}
_RET(SUCCESS);
}
