chxliteprefs.cpp

linux下的一款播放器

                    {
                        eState = eParsingComment;
                    }
                    break;

                    default:
                    {
                        eState = eParsingName;
                        sName = *pos; // don't lose this char
                    }
                }
                ++pos;
                --nCount;
        }
        break;
        default:
            HX_ASSERT(false);
            break;
        }
    }

    return HXR_OK;
}



void
LitePrefs::ClearPrefs(CHXMapStringToOb* pPrefs)
{
    POSITION pos = pPrefs->GetStartPosition();
    while(pos != NULL)
    {
        Pref * pPref = NULL;
        char * szPrefKey = NULL;
        pPrefs->GetNextAssoc( pos, (const char*&) szPrefKey, (void*&) pPref );
        HX_ASSERT(pPref);
        delete pPref;
    }
    pPrefs->RemoveAll();
}

HX_RESULT 
LitePrefs::RetrievePref(IHXCommonClassFactory* pFactory,
			   const CHXMapStringToOb* pPrefs,
			   const char* pName,
			   REF(IHXBuffer*) pValue)
{
    HX_RESULT res = HXR_FAIL;

    Pref* pPref = NULL;
    if (pPrefs->Lookup(pName, (void*&)pPref))
    {
	res = pFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pValue);
	if (SUCCEEDED(res))
	{
	    res = pValue->Set((const UCHAR*)pPref->Buffer(), 
				   pPref->Size());
	}
    }

    return res;
}

BOOL
LitePrefs::SkipToken(char*& pos, INT32& nCount, char term)
{
    BOOL bRet = FALSE;

    while (*pos != term && nCount != 0)
    {
        ++pos;
        --nCount;
    }

    if( nCount != 0 )
    {
        // skip term
        ++pos;
        --nCount;
        bRet = TRUE;
    }

    return bRet;
}

BOOL
LitePrefs::ParseToken(char*& pos, INT32& nCount, char term, CHXString& token)
{
    BOOL bRet = FALSE;

    while (*pos != term && nCount != 0)
    {
        token += *pos;
        ++pos;
        --nCount;
    }

    if( nCount != 0 )
    {
        // skip term
        ++pos;
        --nCount;

        // trim white space around token
        token.TrimLeft();
        token.TrimRight();

        bRet = TRUE;
    }

    return bRet;
}



//
// class CHXLitePrefs
//
CHXLitePrefs::CHXLitePrefs(const char* pRootPath)
: m_pMutex(NULL)
, m_pFactory(NULL)
, m_pScheduler(NULL)
, m_hCallback((CallbackHandle)NULL)
, m_strRootPath(pRootPath)
, m_bAutoCommit(true)
{
#ifdef THREADS_SUPPORTED
    HXMutex::MakeMutex(m_pMutex);
#else
    HXMutex::MakeStubMutex(m_pMutex);
#endif
    m_prefs.SetCaseSensitive(FALSE);
}


CHXLitePrefs::~CHXLitePrefs()
{
    Close();
}

inline
CHXString CHXLitePrefs::GetFullPath(const CHXString& strFileName)
{
    return HXPathUtil::CombinePath(m_strRootPath, strFileName);
}

void
CHXLitePrefs::Close()
{
#if !defined(HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)
    // remove pending callback
    if (m_hCallback)
    {
	m_pScheduler->Remove(m_hCallback);
        m_hCallback = (CallbackHandle)NULL;
    }
#endif // (HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)

    // commit changes
    Commit();

    // cleanup
    LitePrefs::ClearPrefs(&m_prefs);
    HX_RELEASE(m_pFactory);
    HX_RELEASE(m_pScheduler);
    HX_DELETE(m_pMutex);
}


// IHXPreferences

STDMETHODIMP
CHXLitePrefs::ReadPref(const char* pName, REF(IHXBuffer*) pValue)
{
    HX_RESULT res = HXR_FAIL;

    if (pName && m_pFactory)
    {
	m_pMutex->Lock();

	res = LitePrefs::RetrievePref(m_pFactory, &m_prefs, pName, pValue);

	m_pMutex->Unlock();
    }

    return res;
}

STDMETHODIMP
CHXLitePrefs::SetAutoCommit(bool bAutoCommit)
{
    // if false, client must explicitly call Commit() to save changes after write
    m_bAutoCommit = bAutoCommit;
    return HXR_OK;
}

void
CHXLitePrefs::PossiblyCommitPrefChange()
{
    if (m_bAutoCommit)
    {
#if defined(HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)      
        HX_VERIFY(SUCCEEDED(Commit()));
#else
        // schedule a callback and commit the changes
        // so that multiple WritePref calls result in only one write to file
	if (!m_hCallback && m_pScheduler)
	{
	    m_hCallback = m_pScheduler->RelativeEnter(this, 0);
	    HX_ASSERT(m_hCallback);
	}
	else if (!m_pScheduler)
	{
	    // lame... no scheduler!
	    HX_VERIFY(SUCCEEDED(Commit()));
	}
#endif
    }
}

STDMETHODIMP
CHXLitePrefs::WritePref(const char* pName, IHXBuffer* pValue)
{
    HX_RESULT res = HXR_FAIL;

    if (pName && pValue)
    {
	m_pMutex->Lock();
	res = LitePrefs::StorePref(&m_prefs, pName, (const char*)pValue->GetBuffer());
        if(SUCCEEDED(res))
        {
            PossiblyCommitPrefChange();
        }
        m_pMutex->Unlock();
    }

    return res;
}

// IHXPreferences3
STDMETHODIMP
CHXLitePrefs::Open(const char* pCompanyName,
		   const char* pProductName,
		   ULONG32 nProdMajorVer,
		   ULONG32 nProdMinorVer)
{
    HX_RESULT res = HXR_INVALID_PARAMETER;

    if (pProductName)
    {
        m_strFileName.Format("%s_%lu_%lu.cfg",pProductName, nProdMajorVer, nProdMinorVer); 

	LitePrefs::ClearPrefs(&m_prefs);
    
        CHXString strPath = GetFullPath(m_strFileName);
        res = LitePrefs::ReadPrefs(strPath, &m_prefs);
    }
    return res;
}


STDMETHODIMP
CHXLitePrefs::OpenShared(const char* pCompanyName)
{
    return HXR_NOTIMPL; //Open(pCompanyName, "Shared", 0, 0);
}


STDMETHODIMP
CHXLitePrefs::DeletePref(const char* pPrefKey)
{
    HX_RESULT hr = HXR_FAIL;
    Pref* pPref = NULL;

    m_pMutex->Lock();
    if (m_prefs.Lookup(pPrefKey, (void*&)pPref))
    {
	// delete the pref
        m_prefs.RemoveKey(pPrefKey);
	delete pPref;

        PossiblyCommitPrefChange();
        hr = HXR_OK;
    }
    m_pMutex->Unlock();

    return hr;
}

//
// Restore primary pref file so it contains no pref
// settings (and update current prefs accordingly) 
//
STDMETHODIMP
CHXLitePrefs::ResetPrefs()
{
    m_pMutex->Lock();
    // force re-write of file so only shadow references remain.
    LitePrefs::ClearPrefs(&m_prefs);
    Commit();

    // re-build memory prefs (so default values from shadows are set)
    CHXString strPrimaryFilePath = GetFullPath(m_strFileName);
    HX_RESULT hr = LitePrefs::ReadPrefs(strPrimaryFilePath, &m_prefs);
    m_pMutex->Lock();

    return hr;
}




STDMETHODIMP
CHXLitePrefs::SetContext(IUnknown* pContext)
{
    HX_RESULT res = HXR_FAIL;

    if (!m_pFactory && pContext)
    {
	res = pContext->QueryInterface(IID_IHXCommonClassFactory,
				       (void**)&m_pFactory);
	HX_ASSERT(SUCCEEDED(res));

#if !defined(HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)
	res = pContext->QueryInterface(IID_IHXScheduler,
				       (void**)&m_pScheduler);
	HX_ASSERT(SUCCEEDED(res));
#endif // (HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)
    }

    return res;
}


STDMETHODIMP
CHXLitePrefs::Commit()
{
    HX_RESULT res = HXR_NOT_INITIALIZED;
    
    if (m_strFileName)
    {
	m_pMutex->Lock();

        CHXString strPath = GetFullPath(m_strFileName);
	res = LitePrefs::WritePrefs(&m_prefs, strPath);

	m_pMutex->Unlock();
    }

    return res;
}

// IHXCallback
#if !defined(HELIX_CONFIG_LITEPREFS_SLUGGISH_OUT)
STDMETHODIMP
CHXLitePrefs::Func()
{
    m_hCallback = (CallbackHandle)NULL;

    HX_VERIFY(SUCCEEDED(Commit()));

    return HXR_OK;
}
#endif