scribble/src/FileMgr_xml.c File Reference

#include <gtk/gtk.h>
#include <libermanifest/ermanifest.h>
#include "FileManager.h"
#include "FileMgr_page.h"
#include "ScribbleLog.h"
#include "ScribbleUtils.h"
#include "ink_rw.h"

Go to the source code of this file.

Functions
int	saveManifestHead (erManifest *pErManiHandle, Manifest *pManifest)
int	fm_saveManifest (Manifest *pManifest, const char *sManifestFile, gboolean isCreatedFromTmpl)
int	fm_setIrxTypeAndSave (PFileManager pFM)
int	fm_saveFileManager (PFileManager pFM)
int	loadManifest (PFileManager pFM)
PtrInk	fm_loadIrexInk (erManifest *pIrxHandle, const PScribPage pScribPage)
PtrInk	fm_loadCurrInk (PFileManager pFM)
int	fm_initIrxHandle (PFileManager pFM, gboolean isOpen)
int	fm_deleteOnePage (PFileManager pFM, PScribPage pCurrPage)
void	dumpIrxXml (const char *sPageName, erManifest *pXmlHandle, int i)
int	fm_saveOnePage (PFileManager pFM, PScribPage pCurrPage)
int	fm_saveCurrPage (PFileManager pFM)
int	fm_saveAllPages (PFileManager pFM)
int	fm_loadAllInks (PFileManager pFM)
int	fm_saveIrexInk (PFileManager pFM, gboolean bClose)

---

Function Documentation

void dumpIrxXml	(	const char *	sPageName,
		erManifest *	pXmlHandle,
		int	i
	)

Definition at line 370 of file FileMgr_xml.c.

{
    char sFileName[512];
    snprintf(sFileName,512,"/dump_%d.xml",i);
    FILE* file=fopen(sFileName,"w+");
    if(file==NULL)
    {
        printf(" error when open %s\n",sFileName);
        return;
    }
    xmlDocDump(file,pXmlHandle->pDoc);
    fclose(file);
}

int fm_deleteOnePage	(	PFileManager	pFM,
		PScribPage	pCurrPage
	)

Definition at line 356 of file FileMgr_xml.c.

{
    //loop save every pages.
    SB_FMPRINTF("-- delete page=%s",pCurrPage->sPageName);
    //ignore currently.if(pCurrScribPage->bDirty)
    xml_write_ink(pFM->irxHandle,"/notes/pages",
                   NULL,pCurrPage->sPageName);
    fm_setIrxInkDirty(pFM,TRUE);
    
    setCurrentPageDirty(pFM,FALSE);
    SB_TIMEDISPLAY("--done--");
    return 0; 
}

Here is the call graph for this function:

int fm_initIrxHandle	(	PFileManager	pFM,
		gboolean	isOpen
	)

Definition at line 321 of file FileMgr_xml.c.

{
    char inkFileName[MAX_FILENAME];
    get_ink_filename (inkFileName, MAX_FILENAME,pFM);
    if( NULL==pFM->irxHandle)
    {
        pFM->irxHandle=(erManifest*)malloc(sizeof(erManifest));
    }
    gboolean bNeedCreate=TRUE ;
    if( isOpen )
    {
        if( FileExist(inkFileName) )
        {
            if( RET_OK!=ermXmlOpenFile(inkFileName, pFM->irxHandle) )
            {
                SB_ERRORPRINTF("open xml [%s] fail\n",inkFileName);
                return -1;
            }
            bNeedCreate=FALSE;
        }
    }
    if(bNeedCreate)
    {
        if( RET_OK!=ermXmlCreateFile(inkFileName,pFM->irxHandle) )
        {
            SB_ERRORPRINTF("create xml [%s] fail\n",inkFileName);
            return -1;
        }
        xml_write_irxHead(pFM->irxHandle);
    }
    SB_FMPRINTF("init [%s] successfully[open?=%d]\n",inkFileName,isOpen);
    return 0;
}

Here is the call graph for this function:

int fm_loadAllInks

(

PFileManager

pFM

)

Definition at line 441 of file FileMgr_xml.c.

{
    if( NULL==pFM->irxHandle ) return -1;
    
    PScribPage pCurrPage=pFM->manifest.pFirstScribPage;
    while(pCurrPage)
    {
        fm_loadIrexInk(pFM->irxHandle,pCurrPage);
        pCurrPage=pCurrPage->pNextPage;
    }
    return 0;
}

Here is the call graph for this function:

PtrInk fm_loadCurrInk

(

PFileManager

pFM

)

Definition at line 313 of file FileMgr_xml.c.

{
    SB_FMPRINTF("entry");
    return fm_loadIrexInk(pFM->irxHandle,getCurrScribPage(pFM));
}

Here is the call graph for this function:

PtrInk fm_loadIrexInk	(	erManifest *	pIrxHandle,
		const PScribPage	pScribPage
	)

Definition at line 296 of file FileMgr_xml.c.

{
    //assert(pIrxHandle!=NULL);
    if( NULL==pScribPage->pink )
    {   
        if( NULL==pIrxHandle)
        {
            pScribPage->pink=construct_ink ();
        }
        else
        {
            pScribPage->pink=xml_read_ink(pIrxHandle,pScribPage->sPageName);
        }
    }
    return pScribPage->pink;
}

Here is the call graph for this function:

int fm_saveAllPages

(

PFileManager

pFM

)

Definition at line 411 of file FileMgr_xml.c.

{
    erManifest irxHandle;
    
    char inkFileName[MAX_FILENAME];
    get_ink_filename (inkFileName, MAX_FILENAME,pFM);
    if( RET_OK!=ermXmlCreateFile(inkFileName, &irxHandle) )
    {
        SB_ERRORPRINTF("open irx xml [%s] fail (for save)\n",inkFileName);
        return -1;
    }
    SB_TIMEDISPLAY("-- write head to \n[%s]",inkFileName);
    xml_write_irxHead(&irxHandle);
    //loop save every pages.
    PScribPage pCurrPage=pFM->manifest.pFirstScribPage;
    while(pCurrPage)
    {
        SB_FMPRINTF("-- write page=%s",pCurrPage->sPageName);
        //ignore currently.if(pCurrScribPage->bDirty)
        xml_write_ink(&irxHandle,"/notes/pages",
                      pCurrPage->pink,pCurrPage->sPageName);
        
        pCurrPage=pCurrPage->pNextPage;
    }
    ermXmlSaveAndClose(&irxHandle);
    SB_TIMEDISPLAY("write irx inkfile finished");
    return 0; 
}

Here is the call graph for this function:

int fm_saveCurrPage

(

PFileManager

pFM

)

Definition at line 403 of file FileMgr_xml.c.

{
    return fm_saveOnePage(pFM,getCurrScribPage(pFM));
}

Here is the call graph for this function:

int fm_saveFileManager

(

PFileManager

pFM

)

Definition at line 185 of file FileMgr_xml.c.

{
    int ret;

    SB_FMPRINTF("\n\nstart save...[curropen=%d,lastopen=%d]\n",
                pFM->iCurrOpenPage,pFM->manifest.iLastOpenPage);
    //if the last openpage is changed ,then save.
    if(pFM->iCurrOpenPage!=pFM->manifest.iLastOpenPage)
    {
        pFM->manifest.iLastOpenPage=pFM->iCurrOpenPage;
        pFM->bNeedSaveManifest=TRUE;
    }
    //bNeedCreatDirHirachy is true means nothing in current foder.
    if(!pFM->bNeedSaveManifest || pFM->bNeedCreatDirHirachy)
    {
        SB_FMPRINTF("manifest need no save\n");
        return 0;
    }
    ret = fm_saveManifest( &pFM->manifest,pFM->sManifestPathName,
                             pFM->isCreatedFromTmpl);
    if ( (0 == ret) && (TRUE == pFM->isCreatedFromTmpl) )
    {
        pFM->isCreatedFromTmpl = FALSE;
    }
    return ret;
}

Here is the call graph for this function:

int fm_saveIrexInk	(	PFileManager	pFM,
		gboolean	bClose
	)

Definition at line 455 of file FileMgr_xml.c.

{
    //bNeedCreatDirHirachy is true means nothing in current foder.
    if(!pFM->manifest.bNeedSaveIrx || pFM->bNeedCreatDirHirachy)
    {
        SB_FMPRINTF("need not save .irx inkfile\n");
        if (bClose)
        {
            if( NULL!=pFM->irxHandle )
            {
                ermXmlClose(pFM->irxHandle);
            }
            pFM->irxHandle=NULL;
        }
        return 0;
    }
    
    if( NULL!=pFM->irxHandle )
    {
        SB_FMPRINTF("saving irx inkfile...\n");
        if (bClose)
        {
            ermXmlSaveAndClose(pFM->irxHandle);
        }
        else
        {
            ermXmlSave(pFM->irxHandle);
        }
    }

    SB_FMPRINTF("done...\n");
    return 0; 
}

Here is the call graph for this function:

int fm_saveManifest	(	Manifest *	pManifest,
		const char *	sManifestFile,
		gboolean	isCreatedFromTmpl
	)

Definition at line 105 of file FileMgr_xml.c.

{
    erManifest erManifest;
    if(isCreatedFromTmpl)
    {
        //create new manifest file
        if( RET_OK!=ermXmlCreateFile(sManifestFile, &erManifest))
        {
            SB_ERRORPRINTF("error when create xml\n");
            return -1;
        }
        SB_FMPRINTF("xml created\n"); 
        saveManifestHead(&erManifest,pManifest);   
        ermXmlNewString(&erManifest, "/package", "Scribble", "");
        SB_FMPRINTF("manifest head created\n");     
    }
    else
    {
        //open the manifest and then reset the value
        if( RET_OK!=ermXmlOpenFile(sManifestFile, &erManifest))
        {
            SB_ERRORPRINTF("error when open manifest file\n");
            return -1;
        }
        //empty the existed content
        ermXmlSetString(&erManifest,"/package/Scribble","");
    }
        
    ermXmlNewString(&erManifest, "/package/Scribble", "ScribbleName", 
                     pManifest->sScribbleName);
    ermXmlNewInt(&erManifest, "/package/Scribble", "LastOpenPage", 
                  pManifest->iLastOpenPage);
    ermXmlNewInt(&erManifest, "/package/Scribble", "TotalPages", 
                  pManifest->iTotalPages);        
    ermXmlNewString(&erManifest, "/package/Scribble", "ScribPages", "");
    
    PScribPage  pCurrPage=pManifest->pFirstScribPage;
    
    int i = 0;
    char xpathname[256] ={0};
    while(pCurrPage)
    {
        ermXmlNewString(&erManifest, "/package/Scribble/ScribPages",
                         "Page","");
        snprintf(xpathname, MAX_PATHNAME, 
                 "/package/Scribble/ScribPages/Page[%d]", ++i);
        ermXmlNewString(&erManifest, xpathname,
                         "ImgFileName",pCurrPage->sImgFileName);
        ermXmlNewString(&erManifest, xpathname,
                         "PageName",pCurrPage->sPageName);
        pCurrPage=pCurrPage->pNextPage;
    }
    ermXmlSaveAndClose(&erManifest);
    SB_FMPRINTF("manifest saved\n");
    return 0;
}

Here is the call graph for this function:

int fm_saveOnePage	(	PFileManager	pFM,
		PScribPage	pCurrPage
	)

Definition at line 385 of file FileMgr_xml.c.

{
    if(!pCurrPage->bDirty)
        return 0;
    
    //loop save every pages.
    SB_TIMEDISPLAY("-- write page=%s",pCurrPage->sPageName);
    //ignore currently.if(pCurrScribPage->bDirty)
    xml_write_ink(pFM->irxHandle,"/notes/pages",
                       pCurrPage->pink,pCurrPage->sPageName);
    fm_setIrxInkDirty(pFM,TRUE);
    
    setCurrentPageDirty(pFM,FALSE);
    SB_TIMEDISPLAY("write irx inkfile finished");
    return 0; 
}

Here is the call graph for this function:

int fm_setIrxTypeAndSave

(

PFileManager

pFM

)

Definition at line 164 of file FileMgr_xml.c.

{
    erManifest erManifest;
    //open the manifest and then reset the value
    if( RET_OK!=ermXmlOpenFile(pFM->sManifestPathName, &erManifest))
    {
            SB_ERRORPRINTF("error when open manifest file\n");
            return -1;
    }
    //change the type to irx     
    ermXmlSetString(&erManifest,"/package/metadata/dc-metadata/Type",
                    SCRIB_TYPE);
    //save the manifest
    if( RET_OK!=ermXmlSaveAndClose(&erManifest) )
    {
        SB_ERRORPRINTF("update manifest error[%s]\n",pFM->sManifestPathName);
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

int loadManifest

(

PFileManager

pFM

)

Definition at line 213 of file FileMgr_xml.c.

{
    erManifest manifest;
    if( RET_OK!=ermXmlOpenFile(pFM->sManifestPathName, &manifest) )
    {
        SB_ERRORPRINTF("open xml [%s] fail\n",pFM->sManifestPathName);
        return -1;
    }

    Manifest *pManifest=&pFM->manifest;
    
    ermXmlGetString(&manifest, "/package/metadata/dc-metadata/Type",  
                     pFM->manifest.sInkType, MAX_INKTYPE_LEN);    
    ermXmlGetString(&manifest, "/package/Scribble/ScribbleName", 
                     pManifest->sScribbleName, MAX_FILENAME+1); 
    ermXmlGetInt(&manifest, "/package/Scribble/LastOpenPage", 
                  &pManifest->iLastOpenPage); 
    ermXmlGetInt(&manifest, "/package/Scribble/TotalPages", 
                  &pManifest->iTotalPages);  
    
    ScribPage *pLastPage=NULL;
    ScribPage *pScribPage=NULL;
    int i = 0;
    char xpathname[256] ={0};        
    //fetch every page
    for( i=0;i<pManifest->iTotalPages;i++ )
    {
        pScribPage=(ScribPage *)malloc(sizeof(ScribPage));
        if(  NULL==pScribPage)
        {
            SB_ERRORPRINTF("error when malloc space\n");
            return -1;
        }
        memset(pScribPage,0,sizeof(ScribPage));
        snprintf(xpathname, 256, 
                 "/package/Scribble/ScribPages/Page[%d]/ImgFileName",i+1);
        if(    RET_OK != ermXmlGetString(&manifest,xpathname, 
               pScribPage->sImgFileName,MAX_FILENAME+1)
               || isStrEmpty(pScribPage->sImgFileName) )
        {
            free(pScribPage);
            break;
        }
        
        snprintf(xpathname, 256, 
                 "/package/Scribble/ScribPages/Page[%d]/PageName",i+1);
        if(    RET_OK != ermXmlGetString(&manifest,xpathname, 
               pScribPage->sPageName,MAX_FILENAME+1)
               || isStrEmpty(pScribPage->sPageName) )
        {
            free(pScribPage);
            break;
        }
        if( 0==i )
        {   //first page
            pManifest->pFirstScribPage=pScribPage;
        }
        else
        {
            pLastPage->pNextPage=pScribPage;
        }
        pScribPage->bDirty=FALSE;
        pLastPage=pScribPage;
    }//end for loop
    //correct it if error totalpages    
       
    if( pManifest->iTotalPages != i  )
    {
        SB_WARNPRINTF("real pages=%d[in xml:%d]\n",i,pManifest->iTotalPages);
        pManifest->iTotalPages=i;
    }
    ermXmlClose(&manifest);
    
    if( 0==pManifest->iTotalPages  )
    {
        SB_ERRORPRINTF("no valid page!\n");
        return -1;
    }
    SB_FMPRINTF("manifest loaded success\n");
    //dumpManifest(pManifest);
    return 0;
}

Here is the call graph for this function:

int saveManifestHead	(	erManifest *	pErManiHandle,
		Manifest *	pManifest
	)

Copyright (C) 2005-2008 iRex Technologies B.V. All rights reserved.

Definition at line 68 of file FileMgr_xml.c.

{
    ermXmlNewString(pErManiHandle, "/", "package", "");
 
    ermXmlNewString(pErManiHandle, "/package", "metadata", "");
    ermXmlNewString(pErManiHandle, "/package/metadata","dc-metadata", "");
    ermXmlNewString(pErManiHandle, "/package/metadata/dc-metadata", "Title", 
                    pManifest->sScribbleName);
    ermXmlNewString(pErManiHandle, "/package/metadata/dc-metadata", "Description", 
                    pManifest->sScribbleName);
    ermXmlNewString(pErManiHandle, "/package/metadata/dc-metadata", "Type", SCRIB_TYPE);
        
    ermXmlNewString(pErManiHandle, "/package/metadata", "y-metadata", "");
    ermXmlNewString(pErManiHandle, "/package/metadata/y-metadata", 
                    "startpage", "dummy.bmp");    
    return 0;
}

Here is the call graph for this function: