Example #1
0
BOOL CGroupingDlg::ProcessUpdate(CXMLElement* pParent, LPCTSTR lpszMethod)
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", lpszMethod );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xphonemeetinggroupmore" );
	
	CXMLElement* pMap = pParent->GetFirstElement();
	ASSERT( pMap != NULL );
	
	CString str;
	FormatUpdate( pMap, str );
	
	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( "set " + str );
	
	str.Format( "xjsjbh in (select xjsjbh from xuser_info"
				" where xphone='%s')", Network.m_xUserId );
	FormatMapping( pParent, str );
	
	pSync = pXML->AddElement( "search_condition" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) ); delete pXML;
	
	return TRUE;
}
Example #2
0
BOOL CGroupingDlg::CreateGroup(LPCTSTR lpszName, CXMLElement* pParent)
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "insert into" );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xphonemeetinggroup" );
	
	CString str;
	str.Format( "(xjsjbh, xgroupnum, xgroupname)"
				" select a.xjsjbh, isnull(max(b.xgroupnum),0)+1, '%s' from xuser_info a"
				" left join xphonemeetinggroup b on b.xjsjbh = a.xjsjbh"
				" where a.xphone='%s'"
#if 0
				" group by a.xjsjbh", lpszName, Network.m_xUserId );
#else
				" and '%s' not in (select xgroupname from xphonemeetinggroup"
					" where xjsjbh in (select xjsjbh from xuser_info where xphone='%s'))"
				" group by a.xjsjbh", lpszName, Network.m_xUserId, lpszName, Network.m_xUserId );
#endif
	
	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) ); delete pXML;
	
	m_wndGroup.SetItemDataPtr( m_wndGroup.AddString( lpszName ), pParent );
	m_wndList.DeleteAllItems();
	
	return TRUE;
}
Example #3
0
BOOL CGroupingDlg::ProcessInsert(CXMLElement* pParent, LPCTSTR lpszMethod)
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", lpszMethod );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xphonemeetinggroupmore" );
	
	CString str;
	str.Format( "(xjsjbh,xgroupnum,xphone,xname,xgrouprow)"
				" select a.xjsjbh,a.xgroupnum,'%s','%s',isnull(max(b.xgrouprow),0)+1"
				" from xphonemeetinggroup a"
				" left join xphonemeetinggroupmore b on b.xjsjbh=a.xjsjbh and a.xgroupnum=b.xgroupnum"
				" where a.xgroupname = '%s' and a.xjsjbh in"
					" (select xjsjbh from xuser_info where xphone='%s')"
				" group by a.xjsjbh,a.xgroupnum",
				pParent->GetAttributeValue( _T("xphone") ),
				pParent->GetAttributeValue( _T("xname") ),
				pParent->GetAttributeValue( _T("xgroupname") ),
				Network.m_xUserId );

	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) ); delete pXML;
	
	return TRUE;
}
Example #4
0
void CUserMeetingDlg::OnCancel()
{
	if (AfxMessageBox(IDS_QUITPROMPT, MB_OKCANCEL | MB_ICONQUESTION | MB_DEFBUTTON2) != IDOK) return;
	
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "update" );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xmeetingroomlist" );
	
	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( "set xmeetingused = '0'" );
	
	CString str;
	str.Format( "xmeetingroomfee = '%s'", Network.m_xUserId );
	
	pSync = pXML->AddElement( "search_condition" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) );
	delete pXML;
#if 1
	pXML = new CXMLElement( NULL, ISyncHostFile );
	pXML->AddAttribute( "method", "bye" );
	
	Network.SendPacket( new CSyncHostFile(pXML) );
	delete pXML;
#endif
	
	CDialog::OnCancel();
}
Example #5
0
void CGroupingDlg::OnSyncOrderRelation()
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "select" );
	
	CXMLElement* pSync = pXML->AddElement( "column_expression" );
	pSync->SetValue( "a.xphone, a.xname, a.xgroupnum, b.xgroupname" );
	
	pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "from xphonemeetinggroupmore a"
		" inner join xphonemeetinggroup b on a.xjsjbh=b.xjsjbh"
			" and a.xgroupnum=b.xgroupnum" );
	
	CString str;
	str.Format( "a.xjsjbh in (select xjsjbh from xuser_info "
				"where xphone = '%s')", Network.m_xUserId );
	
	pSync = pXML->AddElement( "search_condition" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView(pXML) );
	delete pXML; pXML = NULL;
	
	if ( ! Network.CallWorker( &pXML, INFINITE ) )
	{
		OnSyncDataViewResp( pXML );
		//pXML->Delete();
	}
}
Example #6
0
BOOL CChannel::JoinTalk(LPCTSTR xRemoteId, LPCTSTR xCallerId)
{
	ASSERT( IsConnected() );
	
	CXMLElement* pXML = new CXMLElement( NULL, ISyncHostLink );
	pXML->AddAttribute( "method", "dial" );
	
	CXMLElement* pSync = pXML->AddElement( "RemoteId" );
	pSync->SetValue( xRemoteId );
	
	if ( xCallerId && _tcslen(xCallerId) )
	{
		pSync = pXML->AddElement( "CallerId" );
		pSync->SetValue( xCallerId );
	}
	
	SendPacket( new CSyncHostLink(pXML) );
	delete pXML;
	
	m_bNavigated = TRUE;
	m_tNavigated = GetTickCount();

	CopyMemory( m_xCallType, CA_TALK, MAX_CALLTYPE );
	
	return TRUE;
}
void CFileMetadataPage::OnOK()
{
	CLibraryList* pFiles = GetList();
	if ( pFiles == NULL ) return;

	if ( pFiles->GetCount() >= 10 )
	{
		CString strFormat, strMessage;
		LoadString( strFormat, IDS_LIBRARY_METADATA_MANY );
		strMessage.Format( strFormat, pFiles->GetCount() );
		if ( AfxMessageBox( strMessage, MB_YESNO|MB_ICONQUESTION ) != IDYES ) return;
	}

	if ( CSchema* pSchema = m_wndSchemas.GetSelected() )
	{
		CQuickLock oLock( Library.m_pSection );

		for ( POSITION pos1 = pFiles->GetIterator() ; pos1 ; )
		{
			if ( CLibraryFile* pFile = pFiles->GetNextFile( pos1 ) )
			{
				if ( pSchema->Equals( pFile->m_pSchema ) && pFile->m_pMetadata != NULL )
				{
					CXMLElement* pContainer	= pSchema->Instantiate( TRUE );
					CXMLElement* pXML		= pContainer->AddElement( pFile->m_pMetadata->Clone() );
					m_wndData.UpdateData( pXML, TRUE );
					if ( pContainer ) pFile->SetMetadata( pContainer );
					delete pContainer;
				}
				else
				{
					CXMLElement* pContainer	= pSchema->Instantiate( TRUE );
					CXMLElement* pXML		= pContainer->AddElement( pSchema->m_sSingular );
					m_wndData.UpdateData( pXML, TRUE );
					if ( pContainer ) pFile->SetMetadata( pContainer );
					delete pContainer;
				}
			}
		}
	}
	else
	{
		CQuickLock oLock( Library.m_pSection );

		for ( POSITION pos1 = pFiles->GetIterator() ; pos1 ; )
		{
			if ( CLibraryFile* pFile = pFiles->GetNextFile( pos1 ) )
			{
				pFile->SetMetadata( NULL );
			}
		}

		Library.Update();
	}

	CFilePropertiesPage::OnOK();
}
Example #8
0
void CGroupingDlg::AddMethod(CXMLElement* pXML, LPCTSTR pszMethod, CXMLElement* pXMLSwap)
{
	if ( ! m_pXMLMethod ) m_pXMLMethod = new CXMLElement;
	
	CXMLElement* pSync = m_pXMLMethod->AddElement( _T("SyncOrder") );
	pSync->AddAttribute( _T("method"), pszMethod );
	
	CXMLElement* pMap = pSync->AddElement( pXML->Clone() );
	if ( pXMLSwap ) pMap->AddElement( pXMLSwap );
}
Example #9
0
void CUserMeetingDlg::OnTimer(UINT nIDEvent) 
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "select" );
	
	CXMLElement* pSync = pXML->AddElement( "column_expression" );
	pSync->SetValue( "xmeetingphone, xmeetingphonestate=case"
					" when xmeetingphonestate='0' then '等待'"
					" when xmeetingphonestate='1' then '呼叫'"
					" when xmeetingphonestate='2' then '在线'"
					" else '其他' end" );
	
	pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "from xmeetingroom" );
	
	CString str;
	str.Format( "xmeetingroomcode=(select xmeetingroomcode"
		" from xmeetingroomlist where xmeetingroomfee='%s' and xmeetingused='1')", Network.m_xUserId );
	
	pSync = pXML->AddElement( "search_condition" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView(pXML) );
	delete pXML; pXML = NULL;
	
	if ( Network.CallWorker( &pXML, INFINITE ) ) return;
	
	int nItem = 0;
	POSITION posNext = pXML->GetElementIterator();
	for ( POSITION pos = posNext ; pos ; pos = posNext )
	{
		CXMLElement* pSync = pXML->GetNextElement( posNext );
		
		CString strDebug = pSync->GetAttributeValue( "xmeetingphone" );
		if ( m_wndList.GetItemText(nItem, 0).CompareNoCase( strDebug ) )
		{
			m_wndList.DeleteItem( nItem );
			posNext = pos; continue;
		}
		
		CString strValue = pSync->GetAttributeValue( "xmeetingphonestate" );
		m_wndList.SetItemText( nItem, 2, strValue );
		
		nItem++;
	}
	for ( ; nItem < m_wndList.GetItemCount(); nItem )
	{
		m_wndList.DeleteItem( nItem );
	}
	
	pXML->Delete();
}
Example #10
0
void CUserMeetingDlg::OnOK()
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "update" );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xmeetingroomlist" );
	
	CString str;
	str.Format( "set xmeetingused = '1', xmeetingroomfee = '%s'", Network.m_xUserId );
	
	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( (LPCTSTR)str );
#if 0
	str.Format( "xmeetingroomcode in (select top 1 xmeetingroomcode"
		" from xmeetingroomlist where xmeetingused!='1' and xmeetingroomcode"
		" not in (select xmeetingroomcode from xmeetingroom))" );
#else
	str.Format( "xmeetingroomcode in (select top 1 xmeetingroomcode"
		" from xmeetingroomlist where xmeetingused!='1')" );
#endif
	
	pSync = pXML->AddElement( "search_condition" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) );
	delete pXML;
#if 0
	pXML = new CXMLElement( NULL, ISyncHostFile );
	pXML->AddAttribute( "method", "meeting" );
	
	Network.SendPacket( new CSyncHostFile( pXML ) );
	delete pXML;
#else
	pXML = new CXMLElement( NULL, ISyncHostFile );
	pXML->AddAttribute( "method", "talk" );
	
	Network.SendPacket( new CSyncHostFile(pXML) );
	delete pXML;
#endif
	GetDlgItem( IDOK )->EnableWindow( FALSE );
	
	CGraphRender*& pRenderer = m_pRenderer;
	if ( ! pRenderer ) pRenderer = new CGraphRender( Network.m_xUserId );
	
	CDatagrams* pDatagram = Datagrams.SeekNext(Payload_Alaw);
	pRenderer->RenderPreview( PreviewPayload(PayloadMask_Audio), NULL, (DWORD)pDatagram );
	
	SetTimer( 1, 6000, NULL );
	PostMessage( WM_TIMER, 1 );
}
CG2Packet* CLocalSearch::AlbumToPacket(CAlbumFolder* pFolder)
{
	if ( pFolder == NULL ) return NULL;

	if ( pFolder->m_pSchema != NULL && pFolder->m_pSchema->m_bPrivate ) return NULL;
	if ( pFolder->GetSharedCount() == 0 ) return NULL;

	CG2Packet* pPacket = CG2Packet::New( "VF", TRUE );

	if ( pFolder->m_pSchema != NULL )
	{
		CXMLElement* pXML = pFolder->m_pSchema->Instantiate( TRUE );

		if ( pFolder->m_pXML != NULL )
		{
			pXML->AddElement( pFolder->m_pXML->Clone() );
		}
		else
		{
			CXMLElement* pBody = pXML->AddElement( pFolder->m_pSchema->m_sSingular );
			pBody->AddAttribute( pFolder->m_pSchema->GetFirstMemberName(), pFolder->m_sName );
		}

		CString strXML = pXML->ToString();
		delete pXML;

		pPacket->WritePacket( "MD", pPacket->GetStringLen( strXML ) );
		pPacket->WriteString( strXML, FALSE );
	}

	for ( POSITION pos = pFolder->GetFolderIterator() ; pos ; )
	{
		if ( CG2Packet* pChild = AlbumToPacket( pFolder->GetNextFolder( pos ) ) )
		{
			pPacket->WritePacket( pChild );
			pChild->Release();
		}
	}

	pPacket->WritePacket( "FILES", pFolder->GetFileCount() * 4 );

	for ( POSITION pos = pFolder->GetFileIterator() ; pos ; )
	{
		CLibraryFile* pFile = pFolder->GetNextFile( pos );
		pPacket->WriteLongBE( pFile->m_nIndex );
	}

	return pPacket;
}
BOOL CAlbumFolder::MetaToFiles(BOOL bAggressive)
{
	if ( m_pSchema == NULL || m_pXML == NULL ) return FALSE;

	for ( POSITION pos = GetFileIterator() ; pos ; )
	{
		CLibraryFile* pFile	= GetNextFile( pos );
		CSchema* pSchema	= pFile->m_pSchema;

		if ( pSchema == NULL ) continue;

		if ( CSchemaChild* pChild = m_pSchema->GetContained( pSchema->m_sURI ) )
		{
			CXMLElement* pXML = pFile->m_pMetadata->Clone();

			if ( pChild->MemberCopy( m_pXML, pXML, TRUE, bAggressive ) )
			{
				CXMLElement* pRoot = pSchema->Instantiate( TRUE );
				pRoot->AddElement( pXML );
				pFile->SetMetadata( pRoot );
				delete pRoot;
			}
			else
			{
				delete pXML;
			}
		}
	}

	return TRUE;
}
Example #13
0
int WINAPI XLoginHost(LPCTSTR xUserId, LPCTSTR xPassword, BOOL bTestor)
{
	CSingleLock pLock( &Network.m_pSection, TRUE );
	
	CXMLElement* pXML = new CXMLElement( NULL, ISyncOrderRelation );
	pXML->AddAttribute( "method", "login" );
	
	if ( bTestor ) pXML->AddAttribute( "operator" );
	
	CXMLElement* pSync = pXML->AddElement( "UserId" );
	pSync->SetValue( xUserId );
	
	CString strValue;
	int nLength	= CalcHashBytes( strValue.GetBuffer(32), xPassword );
	strValue.ReleaseBuffer( nLength );
	
	pSync = pXML->AddElement( "Hashing" );
	pSync->SetValue( strValue );
	
	Network.SendPacket( new CSyncOrderRelation(pXML) );
	delete pXML; pXML = NULL;
	
	Network.SetUserId( xUserId );
	pLock.Unlock();
	
	int nResult = Network.CallWorker( &pXML );
	if ( ! nResult ) nResult = ParseMatch( pXML, "Welcome" );
	
	pXML->Delete();
	if ( nResult ) {XDisconnect(); return nResult;}
	
	// Datagrams
	
	SOCKADDR_IN	pHost;
	CopyMemory( &pHost, &Network.m_pHost, sizeof(pHost) );
	
	CDatagrams* pDatagram = &Datagrams;
	pHost.sin_port = pDatagram->m_pHost.sin_port;
	pDatagram->JoinMirror( &pHost, Network.m_xUserId );
	
	pDatagram = pDatagram->m_pNext;
	pHost.sin_port = pDatagram->m_pHost.sin_port;
	pDatagram->JoinMirror( &pHost, Network.m_xUserId );
	
	return nResult;
}
Example #14
0
void CUserChannel::PutHangup()
{
	CXMLElement* pSync = new CXMLElement( NULL, "SyncOrderRelation" );
	
	CXMLElement* pSub = pSync->AddElement( "MsgType" );
	pSub->SetValue( "BYE" );
	
//	SendPacket( new CSyncOrderRelation( pSync ) ); delete pSync;
	
	m_bNavigated = FALSE;
	m_tNavigated = GetTickCount();
}
Example #15
0
void CUserMeetingDlg::PutIntoPhone(LPCTSTR lpszPhone, LPCTSTR lpszName)
{
	int nItem = m_wndList.InsertItem( m_wndList.GetItemCount(), lpszPhone );
	m_wndList.SetItemText( nItem, 1, lpszName );
	
	CXMLElement* pXML = new CXMLElement( NULL, ISyncDataView );
	pXML->AddAttribute( "method", "insert into" );
	
	CXMLElement* pSync = pXML->AddElement( "table_name" );
	pSync->SetValue( "xmeetingroom" );
	
	CString str;
	str.Format( "(xmeetingroomcode, xmeetingphone)"
				" select xmeetingroomcode, '%s' from xmeetingroomlist"
				" where xmeetingused='1' and xmeetingroomfee = '%s'", lpszPhone, Network.m_xUserId );
	
	pSync = pXML->AddElement( "column_name" );
	pSync->SetValue( (LPCTSTR)str );
	
	Network.SendPacket( new CSyncDataView( pXML ) );
	delete pXML;
}
Example #16
0
HRESULT WINAPI XDialupWith(LPCTSTR xRemoteId, LPCTSTR xCallerId)
{
	CXMLElement* pXML = new CXMLElement( NULL, ISyncHostFile );
	pXML->AddAttribute( "method", "dialup" );
	
	CXMLElement* pSync = pXML->AddElement( "RemoteId" );
	pSync->SetValue( xRemoteId );
	
	if ( xCallerId && _tcslen(xCallerId) )
	{
		pSync = pXML->AddElement( "CallerId" );
		pSync->SetValue( xCallerId );
	}
	
	BOOL bResult = Network.DialupWith( pXML );
	pXML->Delete();
	
	if ( ! bResult ) return S_FALSE;
	//	XRenderPreview(PreviewPayload(PayloadMask_Video|PayloadMask_Audio), Network.m_xUserId);
	XRenderPreview(PreviewPayload(PayloadMask_Audio), Network.m_xUserId);
	
	return S_OK;
}
Example #17
0
BOOL CChannel::PutDialup(LPCTSTR xRemoteId, LPCTSTR xCallerId)
{
	ASSERT( IsConnected() );
	CXMLElement* pSync = new CXMLElement( NULL, "SyncOrderRelation" );
	
	CXMLElement* pSub = pSync->AddElement( "MsgType" );
	pSub->SetValue( "Dialup" );
	
//	pSub = pSync->AddElement( "LocalId" );
//	pSub->SetValue( ( xLocalId && _tcslen(xLocalId) ) ? xLocalId : m_xUserId );
	
	pSub = pSync->AddElement( "RemoteId" );
	pSub->SetValue( xRemoteId );
	
	pSub = pSync->AddElement( "CallType" );
	pSub->SetValue( CA_HOOK );
	
//	SendPacket( new CSyncOrderRelation( pSync ) ); delete pSync;
	
	m_bNavigated = TRUE;
	m_tNavigated = GetTickCount();
	
	return TRUE;
}
Example #18
0
CXMLElement* CSecurity::ToXML(BOOL bRules)
{
	CXMLElement* pXML = new CXMLElement( NULL, _T("security") );
	pXML->AddAttribute( _T("xmlns"), CSecurity::xmlns );

	if ( bRules )
	{
		for ( POSITION pos = GetIterator() ; pos ; )
		{
			pXML->AddElement( GetNext( pos )->ToXML() );
		}
	}

	return pXML;
}
Example #19
0
BOOL CPlayerWnd::SaveXML()
{
	CXMLElement* pXML = new CXMLElement( NULL, _T("XlivePlayer") );
	
	for ( int nItem = 0; nItem < m_wndHistory.GetCount(); nItem++ )
	{
		CString strUrl;
		m_wndHistory.GetLBText( nItem, strUrl );
		
		CXMLElement* pMap = pXML->AddElement( _T("Cookie") );
		pMap->SetValue( strUrl );
	}
	
	BOOL bResult = SaveXML( pXML );
	pXML->Delete();
	
	return bResult;
}
void CLocalSearch::AddMetadata(CSchema* pSchema, CXMLElement* pXML, int nIndex)
{
	ASSERT( pSchema != NULL );
	ASSERT( pXML != NULL );
	ASSERT( pXML->GetParent() == NULL );

	CXMLElement* pGroup;

	if ( ! m_pSchemas.Lookup( pSchema, (void*&)pGroup ) )
	{
		pGroup = pSchema->Instantiate();
		m_pSchemas.SetAt( pSchema, pGroup );
	}

	CString strIndex;
	strIndex.Format( _T("%lu"), nIndex );

	pXML->AddAttribute( _T("index"), strIndex );
	pGroup->AddElement( pXML );
}
Example #21
0
BOOL CRulerSettingsPage::EditXML() 
{
	CString strValue;
	CXMLElement* pXML = NULL;
	CXMLAttribute* pAttri = NULL;
	
	if ( pXML = m_pXML->GetElementByName( _T("BlackList"), TRUE ) )
	{
		pXML->DeleteAllElements();

		for ( int nItem = 0; nItem < m_wndExtList.GetCount(); nItem++ )
		{
			m_wndExtList.GetLBText( nItem, strValue );
			CXMLElement* pMap = pXML->AddElement( _T("Map") );
			pMap->AddAttribute( _T("ID"), strValue );
		}
	}

	return TRUE;
}
CXMLElement* CBitziDownloader::ImportData(CSchema* pSchema)
{
	CXMLElement* pRoot	= pSchema->Instantiate( TRUE );
	CXMLElement* pXML	= pRoot->AddElement( pSchema->m_sSingular );
	int nCount = 0;

	for ( POSITION pos = pSchema->m_pBitziMap.GetHeadPosition() ; pos ; )
	{
		CSchemaBitzi* pMap = (CSchemaBitzi*)pSchema->m_pBitziMap.GetNext( pos );

		CString strValue = LookupValue( pMap->m_sFrom );
		if ( strValue.IsEmpty() ) continue;

		if ( pMap->m_nFactor )
		{
			double nValue;

			if ( _stscanf( strValue, _T("%lf"), &nValue ) == 1 )
			{
				nValue *= pMap->m_nFactor;

				if ( nValue == (double)( (int)nValue ) )
				{
					strValue.Format( _T("%i"), (int)nValue );
				}
				else
				{
					strValue.Format( _T("%f"), nValue );
				}
			}
		}

		pXML->AddAttribute( pMap->m_sTo, strValue );
		nCount++;
	}

	if ( nCount ) return pRoot;
	delete pRoot;

	return NULL;
}
Example #23
0
BOOL CPlayerWnd::SaveXML(CXMLElement* pXML)
{
	ASSERT( pXML != NULL );
	
	CFile pFile;
	if ( ! pFile.Open( _T("Xhistory.xml"), CFile::modeWrite|CFile::modeCreate ) ) return FALSE;
	
	CXMLElement* pParent = LoadXML( pXML->GetName() );
	if ( ! pParent ) pParent = CreateXML();
	
	pParent->GetElementByName( pXML->GetName() )->Delete();
	pParent->AddElement( pXML );
	
	CString strXML;
	strXML = pParent->ToString( TRUE, TRUE );
	
	pFile.Write( (LPCSTR)strXML, strXML.GetLength() );
	
	pFile.Close();
	pXML->Detach();
	pParent->Delete();
	
	return TRUE;
}
Example #24
0
void CLibraryFrame::RunLocalSearch(CQuerySearch* pSearch)
{
	CWaitCursor pCursor;

	pSearch->BuildWordList( true, true );

	CSingleLock oLock( &Library.m_pSection, TRUE );

	CAlbumFolder* pRoot = Library.GetAlbumRoot();
	if ( ! pRoot ) return;

	CAlbumFolder* pFolder = pRoot->GetFolderByURI( CSchema::uriSearchFolder );
	if ( pFolder == NULL )
	{
		pFolder = pRoot->AddFolder( CSchema::uriSearchFolder, L"Search Results" );
		if ( pFolder->m_pSchema != NULL )
		{
			int nColon = pFolder->m_pSchema->m_sTitle.Find( L':' );
			if ( nColon >= 0 )
				pFolder->m_sName = pFolder->m_pSchema->m_sTitle.Mid( nColon + 1 );
		}
	}
	else
	{
		// Get translated name of the default search folder
		// We will clear it, not others as user may want to keep several folders
		CString strFolderName;
		int nColon = pFolder->m_pSchema->m_sTitle.Find( L':' );
		if ( nColon >= 0 )
			strFolderName = pFolder->m_pSchema->m_sTitle.Mid( nColon + 1 );
		if ( ! strFolderName.IsEmpty() )
			pFolder	= pRoot->GetFolder( strFolderName );

		if ( pFolder == NULL )
		{
			pFolder = pRoot->AddFolder( CSchema::uriSearchFolder, L"Search Results" );
			if ( pFolder->m_pSchema != NULL && ! strFolderName.IsEmpty() )
				pFolder->m_sName = strFolderName;
		}
		else
			pFolder->Clear();
	}

	if ( pFolder->m_pSchema )
	{
		CString strDate, strTime;
		SYSTEMTIME pTime;

		GetLocalTime( &pTime );
		GetDateFormat( LOCALE_USER_DEFAULT, 0, &pTime, L"yyyy-MM-dd", strDate.GetBuffer( 64 ), 64 );
		GetTimeFormat( LOCALE_USER_DEFAULT, 0, &pTime, L"hh:mm tt", strTime.GetBuffer( 64 ), 64 );
		strDate.ReleaseBuffer(); strTime.ReleaseBuffer();

		CXMLElement* pOuter = pFolder->m_pSchema->Instantiate();
		CXMLElement* pInner = pOuter->AddElement( L"searchFolder" );
		pInner->AddAttribute( L"title", pFolder->m_sName );
		pInner->AddAttribute( L"content", pSearch->m_sSearch );
		pInner->AddAttribute( L"date", strDate );
		pInner->AddAttribute( L"time", strTime );
		pFolder->SetMetadata( pOuter );
		delete pOuter;
	}

	if ( CFileList* pFiles = Library.Search( pSearch, 0, TRUE ) )
	{
		for ( POSITION pos = pFiles->GetHeadPosition(); pos; )
		{
			const CLibraryFile* pFile = pFiles->GetNext( pos );

			if ( Settings.Search.SchemaTypes && pSearch->m_pSchema != NULL )
			{
				if ( ! pSearch->m_pSchema->FilterType( pFile->m_sName ) )
					pFile = NULL;
			}

			if ( pFile != NULL && pFile->IsAvailable() )
				pFolder->AddFile( const_cast< CLibraryFile* >( pFile ) );
		}

		delete pFiles;
	}

	oLock.Unlock();

	Update();
	Display( pFolder );
	GetParent()->PostMessage( WM_COMMAND, ID_VIEW_LIBRARY );
}
BOOL CFileMetadataPage::OnInitDialog()
{
	CFilePropertiesPage::OnInitDialog();

	CLibraryList* pFiles = GetList();

	CRect rcClient, rcCombo;
	CString strText;
	GetClientRect( &rcClient );

	m_wndSchemas.GetWindowRect( &rcCombo );
	ScreenToClient( &rcCombo );
	rcCombo.top = rcCombo.bottom + 8;
	rcCombo.bottom = rcClient.bottom - 8;

	m_wndData.Create( WS_CHILD|WS_VISIBLE|WS_BORDER|WS_TABSTOP, rcCombo, this, IDC_METADATA );
	LoadString ( strText, IDS_SEARCH_NO_METADATA );
	m_wndSchemas.m_sNoSchemaText = strText;

	BOOL bCollection = FALSE;
	CSchema* pSchema = NULL;

	{
		CQuickLock oLock( Library.m_pSection );

		for ( POSITION pos = pFiles->GetIterator() ; pos ; )
		{
			if ( CLibraryFile* pFile = pFiles->GetNextFile( pos ) )
			{
				CSchema* pThisSchema = pFile->m_pSchema;

				if ( pThisSchema != NULL && pThisSchema->m_nType == CSchema::stFolder ) bCollection = TRUE;

				if ( pSchema == NULL )
				{
					pSchema = pThisSchema;
				}
				else if ( pSchema != pThisSchema )
				{
					pSchema = NULL;
					break;
				}
			}
		}
	}

	m_wndSchemas.Load( pSchema != NULL ? pSchema->m_sURI : _T(""), bCollection ? -1 : 0 );
	OnSelChangeSchemas();

	if ( pSchema != NULL )
	{
		CXMLElement* pContainer	= pSchema->Instantiate( TRUE );
		CXMLElement* pXML		= pContainer->AddElement( pSchema->m_sSingular );

		{
			CQuickLock oLock( Library.m_pSection );

			for ( POSITION pos1 = pFiles->GetIterator() ; pos1 ; )
			{
				if ( CLibraryFile* pFile = pFiles->GetNextFile( pos1 ) )
				{
					if ( pFile->m_pMetadata != NULL && pSchema->Equals( pFile->m_pSchema ) )
					{
						for ( POSITION pos2 = pSchema->GetMemberIterator() ; pos2 ; )
						{
							CSchemaMember* pMember = pSchema->GetNextMember( pos2 );
							CString strOld = pMember->GetValueFrom( pXML, _T("(~ns~)") );
							CString strNew = pMember->GetValueFrom( pFile->m_pMetadata /* , _T("(~ns~)") */ );

							if ( strNew != _T("(~ns~)") && strOld != _T("(~mt~)") )
							{
								if ( strOld == _T("(~ns~)") )
								{
									pXML->AddAttribute( pMember->m_sName, strNew );
								}
								else if ( strOld != strNew )
								{
									pXML->AddAttribute( pMember->m_sName, _T("(~mt~)") );
								}
							}
						}
					}
				}
			}
		}

		m_wndData.UpdateData( pXML, FALSE );
		delete pContainer;
	}

	return TRUE;
}
Example #26
0
void CLocalSearch::AddHitG1(CG1Packet* pPacket, CSchemaMap& pSchemas, CLibraryFile* pFile, int nIndex)
{
	QWORD nFileSize = pFile->GetSize();

	pPacket->WriteLongLE( pFile->m_nIndex );
	pPacket->WriteLongLE( (DWORD)min( nFileSize, (QWORD)0xFFFFFFFF ) );

	if ( Settings.Gnutella1.QueryHitUTF8 ) //Support UTF-8 Query
	{
		pPacket->WriteStringUTF8( pFile->m_sName );
	}
	else
	{
		pPacket->WriteString( pFile->m_sName );
	}

	if ( pFile->m_oSHA1 && pFile->m_oTiger )
	{
		pPacket->WriteString( _T("urn:bitprint:") + pFile->m_oSHA1.toString() + _T('.') + pFile->m_oTiger.toString(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}
	else if ( pFile->m_oSHA1 )
	{
		pPacket->WriteString( _T("urn:sha1:") + pFile->m_oSHA1.toString(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}
	else if ( pFile->m_oTiger )
	{
		pPacket->WriteString( _T("urn:ttroot:") + pFile->m_oTiger.toString(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}
	if ( pFile->m_oED2K )
	{
		pPacket->WriteString( pFile->m_oED2K.toUrn(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}
	if ( pFile->m_oMD5 )
	{
		pPacket->WriteString( pFile->m_oMD5.toUrn(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}
	if ( pFile->m_oBTH )
	{
		pPacket->WriteString( pFile->m_oBTH.toUrn(), FALSE );
		pPacket->WriteByte( G1_PACKET_HIT_SEP );
	}

	if ( Settings.Gnutella1.EnableGGEP )
	{
		CGGEPBlock pBlock;

		if ( nFileSize >= 0xFFFFFFFF )
		{
			if ( CGGEPItem* pItem = pBlock.Add( GGEP_HEADER_LARGE_FILE ) )
			{
				pItem->WriteInt64( nFileSize );
			}
		}

		if ( pFile->m_pSources.GetCount() )
		{
			if ( CGGEPItem* pItem = pBlock.Add( GGEP_HEADER_ALTS ) )
			{
				for ( POSITION pos = pFile->m_pSources.GetHeadPosition(); pos; )
				{
					CSharedSource* pSource = pFile->m_pSources.GetNext( pos );
					CShareazaURL oURL( pSource->m_sURL );
					if ( oURL.m_pAddress.s_addr && oURL.m_nPort &&
						! Network.IsSelfIP( oURL.m_pAddress ) )
					{
						pItem->WriteLong( oURL.m_pAddress.s_addr );
						pItem->WriteShort( oURL.m_nPort );
					}
				}
			}
		}

		// Network wide file creation time (seconds)
		if ( DWORD nCreationTime = pFile->GetCreationTime() )
		{
			if ( CGGEPItem* pItem = pBlock.Add( GGEP_HEADER_CREATE_TIME ) )
			{
				pItem->Write( &nCreationTime, 4 );
			}
		}

		pBlock.Write( pPacket );
	}

	// End of file
	pPacket->WriteByte( 0 );

	// Prepare XML
	if ( pFile->m_pSchema && pFile->m_pMetadata &&
		( ! m_pSearch || m_pSearch->m_bWantXML ) )
	{
		CXMLElement* pGroup = NULL;
 		if ( ! pSchemas.Lookup( pFile->m_pSchema, pGroup ) )
		{
			pGroup = pFile->m_pSchema->Instantiate();
			if ( ! pGroup )
				return;
			pSchemas.SetAt( pFile->m_pSchema, pGroup );
		}
		if ( CXMLElement* pXML = pFile->m_pMetadata->Clone() )
		{
			CString strIndex;
			strIndex.Format( _T("%d"), nIndex );
			pXML->AddAttribute( _T("index"), strIndex );
			pGroup->AddElement( pXML );
		}
	}
}