示例#1
0
CString ExtractTag(CString tag, CMapStringToString& attribs, bool& fClosing)
{
    tag.Trim();
    attribs.RemoveAll();

    fClosing = !tag.IsEmpty() ? tag[0] == '/' : false;
    tag.TrimLeft('/');

    int i = tag.Find(' ');
    if (i < 0) { i = tag.GetLength(); }
    CString type = tag.Left(i).MakeLower();
    tag = tag.Mid(i).Trim();

    while ((i = tag.Find('=')) > 0) {
        CString attrib = tag.Left(i).Trim().MakeLower();
        tag = tag.Mid(i + 1);
        for (i = 0; i < tag.GetLength() && _istspace(tag[i]); i++);
        tag = i < tag.GetLength() ? tag.Mid(i) : _T("");
        if (!tag.IsEmpty() && tag[0] == '\"') {tag = tag.Mid(1); i = tag.Find('\"');}
        else { i = tag.Find(' '); }
        if (i < 0) { i = tag.GetLength(); }
        CString param = tag.Left(i).Trim();
        if (!param.IsEmpty()) {
            attribs[attrib] = param;
        }
        tag = i + 1 < tag.GetLength() ? tag.Mid(i + 1) : _T("");
    }

    return (type);
}
示例#2
0
void CFileCache::Free()
{
	POSITION pos = mapFile.GetStartPosition();
	while (pos)
	{
		CString csURL;
		CString csLocal;

		mapFile.GetNextAssoc(pos, csURL, csLocal);
		
		if (!csLocal.IsEmpty())
		{
			::DeleteFile(csLocal);
		}
	}

	mapFile.RemoveAll();
}
示例#3
0
文件: OBJPOOL.CPP 项目: hkaiser/TRiAS
void CObjektPool :: BesondInfo( const short j, const short k, CAtkisSatz* pSatz )
{
	CCfg	*pConfiguration= &((CEDBSExtension*)g_pTE)->Configuration;
	CRule_Layer *pRule_Layer;
	CGeoObj		*pGOBI = NULL;
	CPunktFolge* pBIpoints1 = NULL;
	CPunktFolge* pBIpoints2 = NULL;
	CxString	strTemp;
	CxString	strText, txt;

	CRule_Info	*pRule_Info = NULL;

	CxString strRegeln("ALK-Regeln");
	CxString strRule;

	CxString strObjNum;
	CxString strAktualitaet;
	CxString strObjNumBI;
	CxString strInfoArt;
	CxString strArtBI;
	CxString strFolie, strObjArt, strObjArtBI;
	int iArtGeo;
	bool tText_erzeugt;
	
	try {

		strObjNum = pSatz->OF_Objektnummer( j );
		strAktualitaet = pSatz->OF_Aktuali( j );
	//	strObjNum.TrimAll();
		strFolie = pSatz -> OF_Folie(j);
		strFolie.TrimAll();
		
		pRule_Layer = g_pMetaData->GetRule_Layer( strFolie );
		if( NULL == pRule_Layer )
			return;

		if( 0 == pRule_Layer->ImportMode() ) 
			return;

		strObjArt = pSatz -> OF_Objektart( j );
		strObjArt.TrimAll();
		strObjArtBI = pSatz -> OF_BI_Objektart( j, k );
		strObjArtBI.TrimAll();
		strArtBI = pSatz -> OF_BI_Art( j, k );	
		strArtBI.TrimAll();
		strInfoArt = strArtBI;
		strInfoArt += "/";									//#FJE980805
		strInfoArt += strObjArtBI;
		
	/*
		if ( strArtBI == "44" ) {	// UNIX-Umlaute ausbauen
			strInfoArt = strText.Left( 2 );
			strText = strText.Mid( 2 );
			strText.Transform(2);
		}
	*/
	//	pGO = g_pObjektPool->GetGeoObj( strObjNum + "H" );
	//	pGO->Folie() = strFolie;
	//	pGO->Objektart() = strObjArt;
	//	pGO->Aktualitaet() = m_Aktuali;


//=== Regeln für besondere Informationen suchen ========================================

		strRule = strFolie + strObjArt + strObjArtBI + strArtBI;
		pRule_Info = g_pMetaData->GetRule_Info( strRule );
		if( NULL == pRule_Info )
			return;

		strText = pSatz -> OF_BI_Text( j, k );
		strText.TrimAll();
		if( pConfiguration->m_sCodePage )
			strText.Transform(pConfiguration->m_sCodePage);

		if( pRule_Info->ObjektartBI_bestimmt_Objektklasse_Hauptgeometrie() ) {
			CGeoObj	*pGO;

			pGO = g_pObjektPool->GetGeoObj( strObjNum + "H" );
			if( pConfiguration->m_tCreateAttributeRegeln )
				pGO->AddAttribute( strRegeln, strRule );
			pGO->Folie() = strFolie;
			pGO->Objektart() = strObjArtBI;
			g_pMetaData->ObjectClassesTRiAS().Lookup( pRule_Info->ObjectClassTRiAS_Hauptgeometrie(), (CObject*&)pGO->ObjectClassTRiAS() );
		}

	//=== Regeln für Texte ============================================================
		tText_erzeugt = false;
		if( pConfiguration->m_tCreateBItext) {
			if( 0 != pRule_Info->Importmodus_Attr() ) {
				CxString strTextToCreate;

				strTemp = pRule_Info->Konvertierung_Text().Left(1);
				if( strTemp == "\"" ) {
					strTextToCreate = pRule_Info->Konvertierung_Text().Mid( 1, pRule_Info->Konvertierung_Text().GetLength() - 2 );
				}
				else if( !strText.IsEmpty() ) { 
					if( strTemp == "§" ) {
	//--- Konvertierung für Hausnummern ------------------------------------------------
						if( "§Hausnummer" == pRule_Info->Konvertierung_Text() ) {
							if( strText.Left(2) == "HA" ) {
								CxString strHANR, strHANRZ, strArt, strObjArt;
								int ix1, ix2;
								strHANR = strText;
								strHANR = strHANR.Mid(23,3);
								if( strHANR == "P01" || strHANR == " 01" || strHANR == "001") {
									strHANR = strText;
									strHANR = strHANR.Mid(15,8);
									strHANRZ = strHANR;
									while( isdigit((int)*strHANRZ.Left(1)) )
										strHANRZ = strHANRZ.Mid(1);
									strHANRZ.TrimAll();
									strHANR.Format("%ld", strHANR.Long());
									if( !strHANRZ.IsEmpty() )
										strHANR += strHANRZ;
									for( ix1 = 0,ix2 = pSatz -> OF_AnzahlBesInfo( j );
										ix1 < ix2;
										ix1++ ) {
										strArt = pSatz -> OF_BI_Art( j, ix1 );
										strObjArt = pSatz -> OF_BI_Objektart( j, ix1 );
										if(  strArt == "21" ) {
											if( strObjArt == "  1031" ) {
												strHANR.Empty();
												break;
											}
										}
										else
											continue;
									}	
									strTextToCreate = strHANR;
								}
							}
							else
								strTextToCreate = strText;
						}
	//--- Konvertierung für Flurstückskennzeichen -------------------------------------
						else if( "§Flurstückskennzeichen" == pRule_Info->Konvertierung_Text() ) {
							if( strText.Left(2) == "FS" ) {
								long z, n;
								z = ((CxString)strText.Mid(11,5)).Long();
								n = ((CxString)strText.Mid(16,3)).Long();
								if( 0 == n )							
									strTextToCreate.printf( "%lu", z );
								else							
									strTextToCreate.printf( "%lu/%lu", z, n );
							}
							else
								strTextToCreate = strText;
						}
	//--- Konvertierung für Flurkennzeichen -------------------------------------
						else if( "§Flurkennzeichen" == pRule_Info->Konvertierung_Text() ) {
							if( strText.Left(2) == "FL" ) {
								long f;
								f = ((CxString)strText.Mid(8,3)).Long();
								strTextToCreate.printf( "Fl. %lu", f );
							}
							else
								strTextToCreate = strText;
						}
					}
					else {
						strTextToCreate = strText;
					}
				}

				if( strTextToCreate.IsEmpty() )
					tText_erzeugt = false;
				else {
					tText_erzeugt = true;
					strObjNumBI = strObjNum + "T";
					strObjNumBI += "_";
					txt.Format("%03d", j);
					strObjNumBI += txt;
					strObjNumBI += "_";
					txt.Format("%03d", k);
					strObjNumBI += txt;
	/*
					strObjNumBI = strObjNum;
					strObjNumBI += "_";
			//		txt.Format("%06ld", pSatz->m_lEDBSSatzNummer);
					txt.Format("%08ld", pSatz->m_lNumParserCalls);
					strObjNumBI += txt;
					strObjNumBI += "_";
					txt.Format("%03d", k);
					strObjNumBI += txt;
					strObjNumBI += "_";
					strObjNumBI += key;
					strObjNumBI += "T";
					strObjNumBI += pSatz->OF_BI_ArtGeo(j,k);
					strObjNumBI += "T";
	*/

					pBIpoints1 = pSatz -> OF_BI_Points( j, k );
					if( pBIpoints1 ) {
						pGOBI = g_pObjektPool->GetGeoObj( strObjNumBI );
						if( pConfiguration->m_tCreateAttributeRegeln )
							pGOBI->AddAttribute( strRegeln, strRule );
						pGOBI->tBI = true;
						pGOBI->Folie() = strFolie;
						pGOBI->Objektart() = strObjArtBI;
			//			pGOBI->Aktualitaet() = m_Aktuali;
						g_pMetaData->ObjectClassesTRiAS().Lookup( pRule_Info->Objektklasse_Text(), (CObject*&)pGOBI->ObjectClassTRiAS() );
						if( pBIpoints1->GetSize() > 1 ) {
							pBIpoints2 = new CPunktFolge( 1 );
							if(	pBIpoints1->GetPoint(1).Hoch() == pSatz -> GrundPunktHoch()
								&& pBIpoints1->GetPoint(1).Rechts() == pSatz -> GrundPunktRechts() ) {
								(*pBIpoints2)[0] = new CPunkt( pBIpoints1->GetPoint(0).Hoch(), pBIpoints1->GetPoint(1).Rechts(), pBIpoints1->GetPoint(1).Dreh() );
							}
							else {
								(*pBIpoints2)[0] = new CPunkt( pBIpoints1->GetPoint(0).Hoch(), pBIpoints1->GetPoint(0).Rechts(), pBIpoints1->GetPoint(0).Dreh() );
							}
							AddLineBI( strObjNumBI, pBIpoints2, pGOBI,
								"BI", strFolie, strObjArtBI );
							delete pBIpoints2;
							pBIpoints2 = NULL;
						}
						else
							AddLineBI( strObjNumBI, pBIpoints1, pGOBI,
								"BI", strFolie, strObjArtBI );

						pGOBI->ObjTyp() = 'T';
						pGOBI->ObjLabel() = strTextToCreate;
					}
				}
			}
		}

	//=== Regeln für Attribute ========================================================
		if( pConfiguration->m_tCreateBIattr && !strText.IsEmpty() ) {
			CMapStringToString	mapAttrToCreate;
			CxString	strAttrToCreate;

			if( 0 != pRule_Info->Importmodus_Attr() ) {
				strTemp = pRule_Info->Konvertierung_Attr().Left(1);
				if( strTemp == "\"" ) {
					strAttrToCreate = pRule_Info->Konvertierung_Attr().Mid( 1, pRule_Info->Konvertierung_Attr().GetLength() - 2 );
					mapAttrToCreate.SetAt( pRule_Info->AttributeName(), strAttrToCreate );
				}
				else if( strTemp == "§" ) {
	//--- Konvertierungen -------------------------------------------------------------
					if( "{" == pRule_Info->Konvertierung_Attr().Mid(1,1) ) { // Attributmenge
						CxString strAttrNames(pRule_Info->AttributeName() + ";");
						if( "§{Gebaeudekennzeichen}" == pRule_Info->Konvertierung_Attr() ) {
							if( strText.Left(2) == "HA" ) {
								if( 0 <= strAttrNames.Find("Laenderschluessel;") )
									mapAttrToCreate.SetAt( "Laenderschluessel", strText.Mid( 2, 2 ) );
								if( 0 <= strAttrNames.Find("Regierungsbeziksschluessel;") )
									mapAttrToCreate.SetAt( "Regierungsbeziksschluessel", strText.Mid( 4, 1 ) );
								if( 0 <= strAttrNames.Find("Kreisschluessel;") )
									mapAttrToCreate.SetAt( "Kreisschluessel", strText.Mid( 5, 2 ) );
								if( 0 <= strAttrNames.Find("Gemeindeschluessel;") )
									mapAttrToCreate.SetAt( "Gemeindeschluessel", strText.Mid( 7, 3 ) );
								if( 0 <= strAttrNames.Find("Strassenschluessel;") )
									mapAttrToCreate.SetAt( "Strassenschluessel", strText.Mid( 10, 5 ) );
								if( 0 <= strAttrNames.Find("Hausnummer;") )
									mapAttrToCreate.SetAt( "Hausnummer", strText.Mid( 15, 4 ) );
								if( 0 <= strAttrNames.Find("Hausnummernzusatz;") )
									mapAttrToCreate.SetAt( "Hausnummernzusatz", strText.Mid( 19, 4 ) );
								if( 0 <= strAttrNames.Find("Gebaeudenummer;") )
									mapAttrToCreate.SetAt( "Gebaeudenummer", strText.Mid( 23, 3 ) );
							}
						}	
						if( "§{Flurstueckskennzeichen}" == pRule_Info->Konvertierung_Attr() ) {
							if( strText.Left(2) == "FS" ) {
								if( 0 <= strAttrNames.Find("Bundeslandschluessel;") )
									mapAttrToCreate.SetAt( "Bundeslandschluessel", strText.Mid( 2, 2 ) );
								if( 0 <= strAttrNames.Find("Gemarkungsschluessel;") )
									mapAttrToCreate.SetAt( "Gemarkungsschluessel", strText.Mid( 4, 4 ) );
								if( 0 <= strAttrNames.Find("Flur;") )
									mapAttrToCreate.SetAt( "Flur", strText.Mid( 8, 3 ) );
								if( 0 <= strAttrNames.Find("Flurstueckszaehler;") )
									mapAttrToCreate.SetAt( "Flurstueckszaehler", strText.Mid( 11, 5 ) );
								if( 0 <= strAttrNames.Find("Flurstuecksnenner;") )
									mapAttrToCreate.SetAt( "Flurstuecksnenner", strText.Mid( 16, 3 ) );
								if( 0 <= strAttrNames.Find("Flurstuecksfolgenummer;") )
									mapAttrToCreate.SetAt( "Flurstuecksfolgenummer", strText.Mid( 19, 2 ) );
							}
						}	
					}
					else {										// Einzelattribut
						if( "§WLDGE-Flurstueckskennzeichen" == pRule_Info->Konvertierung_Attr() ) {
							strAttrToCreate = strText.Mid( 2, 6 )
								+ "-" + strText.Mid( 8, 3 ) + "-"
								+ strText.Mid( 11, 5 ) + "/" + strText.Mid( 16, 3 )
								+ "." + strText.Mid( 19, 2 );
							mapAttrToCreate.SetAt( pRule_Info->AttributeName(), strAttrToCreate );
						}	
					}
				}
				else
					mapAttrToCreate.SetAt( pRule_Info->AttributeName(), strText );

				if( !mapAttrToCreate.IsEmpty() ) {
					CGeoObj	*pGO;

					pGO = g_pObjektPool->GetGeoObj( strObjNum + "H" );
					if( pConfiguration->m_tCreateAttributeRegeln )
						pGO->AddAttribute( strRegeln, strRule );
					if( 0 == pGO->AnzahlLinien() && !tText_erzeugt ) {
						double dblH;
						double dblR; 

						if( pGO->Folie().IsEmpty() )
							pGO->Folie() = strFolie;
						if( pGO->Objektart().IsEmpty() )
							pGO->Objektart() = strObjArt;
	//					pGO->Aktualitaet() = m_Aktuali;
						dblH = pSatz -> GrundPunktHoch();
						dblR = pSatz -> GrundPunktRechts();
						if (( dblH != 0.0 ) && ( dblR != 0.0 ))
							pGO -> SetzPunkt( dblH, dblR );
					}

					POSITION pos;
					CString strAttrName;
					CString strAttrValue;
					for ( pos = mapAttrToCreate.GetStartPosition();
						pos != NULL; ) {
						mapAttrToCreate.GetNextAssoc( pos, strAttrName, strAttrValue  );
						pGO -> AddAttribute( strAttrName, strAttrValue );
						g_pTriasInterface -> NeuesMerkmal( strAttrName );
					}
					mapAttrToCreate.RemoveAll();
				}
			}
		}

	//=== Regeln für Geometrien =======================================================
		if( pConfiguration->m_tCreateBIgeom && strText.IsEmpty() && !tText_erzeugt ) {
			if( 0 != pRule_Info->Importmodus_Detailgeometrie() ) {
				strObjNumBI = strObjNum + "D";
				strObjNumBI += "_";
				txt.Format("%03d", j);
				strObjNumBI += txt;
				txt.Format("%03d", k);
				strObjNumBI += txt;
				strObjNumBI += strObjArtBI;
				txt.Format("%08ld", pSatz->m_lNumParserCalls);
				strObjNumBI += txt;
	/*
					strObjNumBI = strObjNum;
					strObjNumBI += "_";
			//		txt.Format("%06ld", pSatz->m_lEDBSSatzNummer);
					txt.Format("%08ld", pSatz->m_lNumParserCalls);
					strObjNumBI += txt;
					strObjNumBI += "_";
					txt.Format("%03d", k);
					strObjNumBI += txt;
					strObjNumBI += "_";
					strObjNumBI += strObjArt + strInfoArt;
					strObjNumBI += "T";
					strObjNumBI += pSatz->OF_BI_ArtGeo(j,k);
	*/
				pBIpoints1 = pSatz -> OF_BI_Points( j, k );
				if( pBIpoints1 ) {
					int iAnzahlPunkte = 0;

					iArtGeo = atoi(pSatz->OF_BI_ArtGeo(j,k));
					switch( iArtGeo ) {
					case _EinzelpunktInBesondererAusrichtung:
			#pragma message( "Einzelpunkte verarbeiten" )
						pBIpoints2 = new CPunktFolge( *pBIpoints1, false );
						break;
					case _Gerade:
						pBIpoints2 = new CPunktFolge( *pBIpoints1, false );
						break;
					case _Polygonzug:
						pBIpoints2 = new CPunktFolge( *pBIpoints1, false );
						break;
					case _Kreisbogen_rechts:
						{
							if( pBIpoints1->GetSize() == 3 ) {
								SAFEARRAY *psa = NULL;
								ConvertArc1(
										(pBIpoints1->GetPoint(1)).Hoch(), (pBIpoints1->GetPoint(1)).Rechts(),
										(pBIpoints1->GetPoint(2)).Hoch(), (pBIpoints1->GetPoint(2)).Rechts(),
										(pBIpoints1->GetPoint(0)).Hoch(), (pBIpoints1->GetPoint(0)).Rechts(),
										&psa );
								if( psa ) {
									iAnzahlPunkte = psa->rgsabound[0].cElements / 2;
									if( iAnzahlPunkte > 0 ) {
										pBIpoints2 = new CPunktFolge( iAnzahlPunkte );
										do {
											--iAnzahlPunkte;
											(*pBIpoints2)[iAnzahlPunkte] = new CPunkt( *(((double*)psa->pvData) + iAnzahlPunkte*2), *(((double*)psa->pvData) + iAnzahlPunkte*2 + 1) );
										} while( iAnzahlPunkte > 0);
									}
									SafeArrayDestroy( psa );
									psa = NULL;
								}
							}
							else {	//Korrektur für Kreise aus zwei Punkten
								pBIpoints2 = new CPunktFolge( *pBIpoints1, false );
							}
						}
						break;
					case _Kreisbogen_links:
						{
							if( pBIpoints1->GetSize() == 3 ) {
								SAFEARRAY *psa = NULL;
								ConvertArc1(
										(pBIpoints1->GetPoint(0)).Hoch(), (pBIpoints1->GetPoint(0)).Rechts(),
										(pBIpoints1->GetPoint(2)).Hoch(), (pBIpoints1->GetPoint(2)).Rechts(),
										(pBIpoints1->GetPoint(1)).Hoch(), (pBIpoints1->GetPoint(1)).Rechts(),
										&psa );
								if( psa ) {
									iAnzahlPunkte = psa->rgsabound[0].cElements / 2;
									if( iAnzahlPunkte > 0 ) {
										pBIpoints2 = new CPunktFolge( iAnzahlPunkte );
										do {
											--iAnzahlPunkte;
											(*pBIpoints2)[iAnzahlPunkte] = new CPunkt( *(((double*)psa->pvData) + iAnzahlPunkte*2), *(((double*)psa->pvData) + iAnzahlPunkte*2 + 1) );
										} while( iAnzahlPunkte > 0);
									}
									SafeArrayDestroy( psa );
									psa = NULL;
								}
							}
							else {	//Korrektur für Kreise aus zwei Punkten
								pBIpoints2 = new CPunktFolge( *pBIpoints1, false );
							}
						}
						break;
			/*
					case _Kurve:
						iAnzahlPunkte = 0;

						pPF = new CPunktFolge( iAnzahlPunkte + 2 );
						(*pPF)[0] = new CPunkt( pSatz -> GrundPunktHoch(), pSatz -> GrundPunktRechts());
						(*pPF)[iAnzahlPunkte + 1] = new CPunkt( pSatz -> EndPunktHoch( i ), pSatz -> EndPunktRechts( i ));
						break;
			*/		default:
			//			_ASSERT(0);
						break;
					}
				}
				if( pBIpoints2 ) {
					pGOBI = g_pObjektPool->GetGeoObj( strObjNumBI );
					if( pConfiguration->m_tCreateAttributeRegeln )
						pGOBI->AddAttribute( strRegeln, strRule );
					pGOBI->tBI = true;
					pGOBI->Folie() = strFolie;
					if( pRule_Info->Objektart_bestimmt_Objektklasse_Detailgeometrie() ) {
						pGOBI->Objektart() = strObjArt;
						g_pMetaData->ObjectClassesTRiAS().Lookup( g_pMetaData->m_strObjectClassesTRiAS + strFolie + strObjArt, (CObject*&)pGOBI->ObjectClassTRiAS() );
					}
					else {
						pGOBI->Objektart() = strObjArtBI;
						g_pMetaData->ObjectClassesTRiAS().Lookup( pRule_Info->Objektklasse_Detailgeometrie(), (CObject*&)pGOBI->ObjectClassTRiAS() );
					}
					AddLineBI( strObjNumBI, pBIpoints2, pGOBI,
						"BI", strFolie, strObjArtBI );
					delete pBIpoints2;
					pBIpoints2 = NULL;
				}
			}
		}


	/*		
		if( pConfiguration->m_tDefaultObjectMapping ) {
	//==========================================================================
	/ *		lH = pSatz -> GrundPunktHoch();
			lR = pSatz -> GrundPunktRechts();
			if (( lH != 0.0 ) && ( lR != 0.0 ))
				pGO -> SetzPunkt( lH, lR );

			if ( pGO -> Objektart().IsEmpty())
				pGO -> Objektart() = strObjArt;
			else if ( pGO -> Objektart().Find( strObjArt ) < 0 )	{
				txt = strObjArt;
				txt += ", ";
				txt += pGO -> Objektart();
				pGO -> Objektart() = txt;
			}
	* /
	//=== Standard D-Regeln =============================================================================
		}
		else {
			if ( !strText.IsEmpty() && ( strText != "NNNN" )) {
		//=== C-Regeln =============================================================================
		/ *
				key = strObjArt;
				key += strInfoArt;
				key += ":";
				key += strText;
				if ( g_pTriasInterface -> Get_C_Rule( key, newkey )) {
					if ( !newkey.IsEmpty())	{
						strNewKey = newkey;
						strNewKey.Teilen( newkey, strText, '#' );

						pGO -> AddAttribute( newkey, strText );
						g_pTriasInterface -> NeuesMerkmal( newkey );
					}
				}
		* /
			}
			lH = pSatz -> GrundPunktHoch();
			lR = pSatz -> GrundPunktRechts();
			if (( lH != 0.0 ) && ( lR != 0.0 ))
				pGO -> SetzPunkt( lH, lR );

			if ( pGO -> Objektart().IsEmpty())
				pGO -> Objektart() = strObjArt;
			else if ( pGO -> Objektart().Find( strObjArt ) < 0 )	{
				txt = strObjArt;
				txt += ", ";
				txt += pGO -> Objektart();
				pGO -> Objektart() = txt;
			}

		//=== D-Regeln =============================================================================
		}
	*/
	} 
	catch( ... ) {
		AfxMessageBox( "Unerwarteter Fehler in BesondInfo",0,0);
	}
}	// BesondInfo
示例#4
0
void CDownloadManager::GetSharedPaths(CMapStringToString& mapSharedPaths)
{
   char     chKey[MAX_PATH], szSharedPath[MAX_PATH];
   HKEY     hKey = NULL, hSharedKey = NULL;
   DWORD    retCode;
   DWORD    dwLength = 0;
   CString  csSharedPathKey;

	mapSharedPaths.RemoveAll();

   TRY
   {
      if ( (retCode = RegOpenKeyEx(
               HKEY_LOCAL_MACHINE,
               cbSharedKey,
               0,
               KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
               &hKey)) == ERROR_SUCCESS)
      {
         for(int i=0;retCode == ERROR_SUCCESS;i++)
            {
               retCode = RegEnumKey(hKey, i, chKey, MAX_PATH);
               if(retCode == (DWORD) ERROR_SUCCESS)
                  {
                     hSharedKey = NULL;
                     csSharedPathKey = cbSharedKey;
                     csSharedPathKey += "\\";
                     csSharedPathKey += chKey;
                     if ( (retCode = RegOpenKeyEx(
                              HKEY_LOCAL_MACHINE,
                              (LPCSTR)csSharedPathKey,
                              0,
                              KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                              &hSharedKey)) == ERROR_SUCCESS)
                     {
                        dwLength = sizeof(szSharedPath);
                        if ((retCode = RegQueryValueEx(
                                 hSharedKey,
                                 NULL,
                                 NULL,
                                 NULL,
                                 (LPBYTE)szSharedPath,
                                 &dwLength)) == ERROR_SUCCESS)
                           {
										CString csKey = chKey;
										csKey.MakeLower();
                              mapSharedPaths.SetAt(csKey, szSharedPath);
                           }
                        RegCloseKey(hSharedKey);
                     }
                  }

            }
         RegCloseKey(hKey);
      }
   }
   CATCH_ALL(e)
   {
      if (hKey != NULL)
      {
         RegCloseKey(hKey);
      }
      if (hSharedKey != NULL)
      {
         RegCloseKey(hSharedKey);
      }
      csSharedPathKey.Empty();
   }
   END_CATCH_ALL
}