ringview_helper.cpp

Resource editor base speadrum Chinese mobile

// RingView.cpp : implementation file
//

#include "stdafx.h"
#include "resourceeditor.h"
#include "RingView.h"

#include "DirFileInfo.h"
#include "Util.h"

#include "RenameDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

BOOL CRingView::EnumAndFillRings( CDirFileNode * pParentNode, HTREEITEM &hParentItem, LPCTSTR pszPathName )
{
    _ASSERTE( pParentNode != NULL && pszPathName != NULL );

    BOOL      bRet        = FALSE;
    CString   strPathName = pszPathName;
    HTREEITEM hOldParent  = hParentItem;
    HTREEITEM hItem       = NULL;
    CUtil     fileUtil, dirUtil;

    {
        bRet = AddRingDir(&pParentNode, hParentItem, pszPathName);
        hOldParent = hParentItem;
        
        strPathName.TrimRight(_T('\\'));
        strPathName += _T("\\*.*");
        
        WIN32_FIND_DATA wfd = { 0 };
        HANDLE hFind = ::FindFirstFile(strPathName, &wfd);
        _ASSERTE( hFind != INVALID_HANDLE_VALUE );
        
        ::FindNextFile(hFind, &wfd);
        while( ::FindNextFile(hFind, &wfd) && bRet )
        {
            strPathName = pszPathName;
            strPathName.TrimRight(_T('\\'));
            
            strPathName += _T('\\');
            strPathName += wfd.cFileName;
            
            LPCTSTR pExt = _tcsrchr(wfd.cFileName, _T('.'));
            if( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
            {
                dirUtil.AddStr(strPathName);
            }
            else  if( pExt != NULL && _tcsstr(SZ_FILE_EXT, pExt) != NULL  )
            {
                fileUtil.AddStr(strPathName);
            }        
        }
        ::FindClose(hFind);

        CDirFileNode * pChild = pParentNode;
        HTREEITEM      hItem  = hParentItem;
        fileUtil.SortStr();
        int nCount = fileUtil.GetStrSize();
        for( int i = 0; bRet && i < nCount; ++i )
        {
            pChild = pParentNode;
            hItem  = hParentItem;
            bRet = AddRingFile(&pChild, hItem, fileUtil.GetStr(i));
        }
        fileUtil.RemoveAll();
    }

    dirUtil.SortStr();
   
    hItem  = hParentItem;
    int nCount = dirUtil.GetStrSize();
    for( int i = 0; bRet && i < nCount; ++i )
    {
        bRet = EnumAndFillRings( pParentNode, hItem, dirUtil.GetStr(i) );
        hItem = hParentItem;
    }
    dirUtil.RemoveAll();

    hParentItem = hOldParent;

    return bRet;
}

BOOL CRingView::AddRingDir(CDirFileNode ** ppNode, HTREEITEM & hItem, LPCTSTR pszDirName)
{
    _ASSERTE( ppNode != NULL && pszDirName != NULL );

    CString strDir = pszDirName;
    strDir.TrimRight(_T('\\'));
    LPCTSTR pszDir = strDir.GetBuffer(0);
    LPCTSTR pszFind = _tcsrchr(pszDir, _T('\\'));
    if( pszFind == NULL )
        pszFind = pszDir;
    else
        pszFind++;

    CDirFileNode * pNode = (CDirFileNode *)m_pInfo->MallocNode();
    if( NULL == pNode )
    {
        AfxMessageBox(_T("Memory no enough!"));
        return FALSE;
    }
    m_pInfo->ZeroNode(pNode);

    CString strID = g_theApp.m_MMIRes.MakeRingID(pszFind);

    pNode->bIsDir = TRUE;
    //_tcscpy(pNode->szID, strID);
    //_tcscpy(pNode->szName, pszFind);
    //strDir.ReleaseBuffer();
//xb
	CString strNewName;
    if(!DoCheckAndRenameDir(*ppNode,pszFind,strNewName))
	{
		strDir.ReleaseBuffer();
		return FALSE;
	}
	_tcscpy(pNode->szID, g_theApp.m_MMIRes.MakeImgID(strNewName));
	_tcscpy(pNode->szName, strNewName);
    strDir.ReleaseBuffer();
//xe*/
    m_pInfo->AddChild(*ppNode, pNode);

    CTreeCtrl &tc = GetTreeCtrl();
    //HTREEITEM hInsert = tc.InsertItem(pszFind, IMG_COLL_IDX, IMG_COLL_SEL_IDX, hItem);
    HTREEITEM hInsert = tc.InsertItem(strNewName, IMG_COLL_IDX, IMG_COLL_SEL_IDX, hItem);
	tc.SetItemData(hInsert, (DWORD)pNode);

    *ppNode = pNode;
    hItem   = hInsert;

    return TRUE;
}

BOOL CRingView::AddRingFile(CDirFileNode ** ppNode, HTREEITEM & hItem, LPCTSTR pszFileName)
{
    _ASSERTE( ppNode != NULL && pszFileName != NULL );

    CDirFileNode * pParentNode = *ppNode;
    HTREEITEM      hParentItem = hItem;

    LPCTSTR pName = _tcsrchr(pszFileName, _T('\\'));
    _ASSERTE( pName != NULL );

    CString strFileName;

    CMMIRes &mmires = g_theApp.m_MMIRes;
    CString strID = mmires.MakeRingID(pszFileName);

    if( !g_theApp.DoCheckAndRename(pszFileName, strID, strFileName, MMI_RT_RING) )
    {
        return FALSE;
    }

    //if( !mmires.AddRing(strID, strFileName) )
	if( !mmires.AddRing(strID, pszFileName) )
    {
        AfxMessageBox(mmires.GetErrMsg());
        return  FALSE;
    }

    CDirFileNode * pNode = (CDirFileNode *)m_pInfo->MallocNode();
    if( NULL == pNode )
    {
        AfxMessageBox(_T("Memory no enough!"));
        mmires.DeleteAnim(strID);
        return FALSE;
    }
      
    pName = strFileName.GetBuffer(0);
    LPCTSTR pFind = _tcsrchr(pName, _T('\\'));
    if( pFind != NULL )
        pFind++;
    else
        pFind = pName;

    _tcscpy(pNode->szID, strID);
    _tcscpy(pNode->szName, pFind);
   
    PAUD_RING_DATA_INFO_T pRingInfo = NULL;
    VERIFY( mmires.m_mapRing.Lookup(pNode->szID, pRingInfo) );
    pNode->nWidth  = pRingInfo->data_len;
    pNode->nHeight = 1;

    CTreeCtrl & tc = GetTreeCtrl();

    HTREEITEM hInsert = tc.InsertItem(pFind, IMG_IDX, IMG_SEL_IDX, hParentItem );
    strFileName.ReleaseBuffer();

    tc.SetItemData( hInsert, (DWORD)pNode );
  
    m_pInfo->AddChild(pParentNode, pNode);

    *ppNode = pNode;
    hItem   = hInsert;

    return TRUE;
}

BOOL CRingView::ReplaceDir(CDirFileNode *pNode, LPCTSTR pszDir, BOOL bCheck /* = FALSE */)
{
    _ASSERTE( m_pInfo != NULL && pNode != NULL);
    _ASSERTE( pszDir != NULL );

    BOOL bReplaced = FALSE;
    CDirFileNode * pChild = (CDirFileNode *)m_pInfo->GetChild(pNode);

    RecursiveReplaceDir(pChild, pszDir, bReplaced, bCheck);

    return bReplaced;
}

BOOL CRingView::RecursiveReplaceDir(CDirFileNode * pNode, LPCTSTR pszDir, BOOL &bReplaced, BOOL bCheck /* = FALSE */)
{
    _ASSERTE( m_pInfo != NULL );
    _ASSERTE( pszDir != NULL );

    if( pNode == NULL )
        return TRUE;

    CString strDir    = pszDir;
    BOOL    bRet      = TRUE;
    BOOL    bContinue = FALSE;

    CTreeCtrl &tc   = GetTreeCtrl();
    HTREEITEM hSel  = tc.GetSelectedItem();
    _ASSERTE( hSel != NULL );

    {
        CDirFileNode * pSel = (CDirFileNode *)tc.GetItemData(hSel);
        _ASSERTE(pSel != NULL);
    
        for( CDirFileNode * pTemp = pNode; pTemp != NULL && pTemp != pSel; pTemp = (CDirFileNode *)m_pInfo->GetParent(pTemp) )
        {
            if( m_pInfo->GetNext(pTemp) != NULL )
            {
                bContinue = TRUE;
                break;
            }
        }
    }

    strDir += _T("\\");
    strDir += pNode->szName;
    if( m_pInfo->IsDirNode(pNode) )
    {
        CDirFileNode * pChild = (CDirFileNode *)m_pInfo->GetChild(pNode);
        //_ASSERTE( pChild != NULL );
		if( pChild != NULL )
			bRet = RecursiveReplaceDir(pChild, strDir, bReplaced, bCheck);
		else
			bRet = TRUE;
    }
    else if( !ReplaceFile(pNode, strDir, bCheck, hSel) )
    {
        CString strMsg;
        strMsg.Format(_T("Replace \"%s\" fail! Continue?"), pNode->szName);
        if( bContinue && AfxMessageBox(strMsg, MB_YESNO) == IDNO )
            return FALSE;
    }
    else
    {
        bReplaced = TRUE;
    }    
   
    strDir = pszDir;
    
    if( bRet && bContinue )
        bRet = RecursiveReplaceDir((CDirFileNode *)m_pInfo->GetNext(pNode), strDir, bReplaced, bCheck);

    return bRet;
}

BOOL CRingView::ReplaceFile(CDirFileNode *pNode, LPCTSTR pszFileName, 
                            BOOL bCheck /* = FALSE */, HTREEITEM hItem /* = NULL */ )
{
    _ASSERTE( pNode != NULL && pszFileName != NULL );
  
    if( hItem != NULL ) m_SizeInfo.DeleteByHandle( (DWORD)hItem);

    UINT uOld = 0;
    UINT uNew = 0;
    if( g_theApp.m_MMIRes.ReplaceRing(pNode->szID, pszFileName, bCheck, &uOld, &uNew) )
    {
        PAUD_RING_DATA_INFO_T pRingInfo = NULL;
        VERIFY( g_theApp.m_MMIRes.m_mapRing.Lookup(pNode->szID, pRingInfo) );

        pNode->nWidth = pRingInfo->data_len;
        
        if( hItem != NULL && uNew > uOld )
        {
            m_SizeInfo.SetSizeInfo( (DWORD)hItem, uOld, uNew );
        }

	    SetModifiedFlag();
        return TRUE;
    }
    else
    {
        AfxMessageBox(g_theApp.m_MMIRes.GetErrMsg());
        
        return FALSE;
    }
}

BOOL CRingView::RemoveAllRes(CDirFileNode *pNode)
{
    _ASSERTE( pNode != NULL );

    RecursiveRemoveAllRes(pNode);

    m_pInfo->RemoveNode(pNode);

    return TRUE;
}

BOOL CRingView::RecursiveRemoveAllRes(CDirFileNode *pNode)
{
    if( pNode == NULL )
        return TRUE;

    CDirFileNode * pChild = (CDirFileNode *)m_pInfo->GetChild(pNode);
	while ( NULL != pChild )
	{
		CDirFileNode * pNext = (CDirFileNode *)m_pInfo->GetNext(pChild);
        	
		RecursiveRemoveAllRes( pChild );
                
		pChild = pNext;
	}
	
    if( !m_pInfo->IsHasChild(pNode) )
    {
        CMMIRes &mmires = g_theApp.m_MMIRes;
        mmires.DeleteRing(pNode->szID);
    }
   
    return TRUE;
}

void CRingView::RemoveSizeInfo( HTREEITEM hItem )
{
    if( NULL == hItem )
        return;

    CTreeCtrl &tc = GetTreeCtrl();

    m_SizeInfo.DeleteByHandle( (DWORD)hItem );

    for( HTREEITEM hChild = tc.GetChildItem(hItem); hChild != NULL; 
         hChild = tc.GetNextSiblingItem(hChild) )
    {
        RemoveSizeInfo(hChild);
    }
}

BOOL CRingView::EnumAndExportRings( CDirFileNode * pParentNode, LPCTSTR pszPathName)
{
    _ASSERTE( pParentNode != NULL && pszPathName != NULL );

    CString   strPathName = pszPathName;
    CDirFileNode *pNode   = pParentNode;
    CDirFileInfo dfi;
    
	if(pNode->bIsDir)
	{
		if( !::CreateDirectory(strPathName, NULL) )
		{
			if( GetLastError() != ERROR_ALREADY_EXISTS )
			{
				_ASSERTE( 0 );
				return FALSE;
			}
		}
		strPathName+="\\";
	}
	else
	{
		CString strFileName =strPathName+pNode->szName;
		g_theApp.m_MMIRes.ExportRing(pNode->szID,strFileName);
		return TRUE;
	}

    for( pNode = (CDirFileNode *)dfi.GetChild(pNode); 
         pNode != NULL; pNode = (CDirFileNode *)dfi.GetNext(pNode) )   
    {  
		CString strNewDir = strPathName;
	    if(pNode->bIsDir)
		{
           strNewDir+=pNode->szName;
		}
        if(!EnumAndExportRings(pNode, strNewDir))
            return FALSE;
    }
    return TRUE;
}

BOOL CRingView::RenameDir( CDirFileNode * pParentNode,LPCTSTR pszOldName, CString &strNewName)
{
	CString strOldName(pszOldName);
    _ASSERTE( !strOldName.IsEmpty() );

    CRenameDlg dlg;
    dlg.m_strAdded  = strOldName;
    dlg.m_strAdding = strNewName;
	dlg.m_bDirFile  = TRUE;
	dlg.m_pParentNode = pParentNode;
	dlg.m_pDirFileInfo= m_pInfo;

    if( dlg.DoModal() == IDOK )
    {
        strNewName = dlg.m_strNewName;
        return TRUE;
    }
	else
		return FALSE;
}

BOOL CRingView::DoCheckAndRenameDir( CDirFileNode * pParentNode, LPCTSTR pszOldName, CString &strNewName)
{
	CDirFileNode * pCNode =(CDirFileNode *)m_pInfo->GetChild(pParentNode);
	while(pCNode != NULL)
	{
		if(_tcscmp(pCNode->szName, pszOldName)==0)
		{
			if(AfxMessageBox(_T("This directory already exist,\ndo you rename it?"), MB_YESNO)==IDNO)
				return FALSE;
			
			return RenameDir(pParentNode,pszOldName,strNewName);	
		
		}
        pCNode = (CDirFileNode *)m_pInfo->GetNext(pCNode);
	}
	strNewName = pszOldName;
	return TRUE;
}