scribble/inc/FileManager.h File Reference

#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <assert.h>
#include "ink.h"
#include <libermanifest/ermanifest.h>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_ScribPage
struct	_Manifest
struct	_FileManager
Defines
#define	MAX_PATHNAME   512
#define	MAX_FILENAME   512
#define	MAX_INKTYPE_LEN   10
#define	SCRIB_TYPE   "irx"
Typedefs
typedef struct _ScribPage	ScribPage
typedef ScribPage *	PScribPage
typedef struct _Manifest	Manifest
typedef struct _FileManager	FileManager
typedef FileManager *	PFileManager
Functions
int	createDirHirachy (PFileManager pFM)
int	initFileManagerByTmpl (PFileManager pFM, const char *sTmplPathName)
int	initFileManagerByManifest (PFileManager pFM, const char *sManifest)
PScribPage	getCurrScribPage (PFileManager pFM)
void	freeScribPage (PScribPage pPage)
const char *	getCurrImgFileName (PFileManager pFM)
PScribPage	jumptoScribPage (PFileManager pFM, int iPageNo)
int	loadManifest (PFileManager pFM)
int	insertNewPage (PFileManager pFM, int iPageNo, const char *sImgName)
int	deleteCurrPage (PFileManager pFM)
int	getTotalPage (PFileManager pFM)
int	getCurrPageNo (PFileManager pFM)
int	fm_saveFileManager (PFileManager pFM)
void	FreeFileManager (PFileManager pFM)
char *	getAbsPathFromCurrScrib (char *sAbsFileName, int iSize, const char *currFileName, const PFileManager pFM)
int	get_ink_filename (char *inkFileName, int iSize, const PFileManager pFM)
int	get_result_filename (char *resultFileName, int iSize, const PFileManager pFM, const PScribPage pScribPage)
int	get_curr_result_filename (char *resultFileName, int iSize, const PFileManager pFM)
void	fm_setIrxInkDirty (PFileManager pFM, gboolean bDirty)
PtrInk	fm_loadCurrInk (PFileManager pFM)
int	fm_initIrxHandle (PFileManager pFM, gboolean isOpen)
int	fm_deleteOnePage (PFileManager pFM, PScribPage pPage)
int	fm_saveOnePage (PFileManager pFM, PScribPage pPage)
int	fm_saveCurrPage (PFileManager pFM)
int	fm_saveAllPages (PFileManager pFM)
int	fm_saveIrexInk (PFileManager pFM, gboolean bClose)
int	fm_setIrxTypeAndSave (PFileManager pFM)
int	fc_convertold2irx (PFileManager pFM)
void	dumpManifest (Manifest *pM)
void	dumpFileManager (PFileManager pFM)
void	dumpIrxXml (const char *sPageName, erManifest *pXmlHandle, int i)

---

Define Documentation

#define MAX_FILENAME   512

Definition at line 44 of file FileManager.h.

#define MAX_INKTYPE_LEN   10

Definition at line 60 of file FileManager.h.

#define MAX_PATHNAME   512

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

Definition at line 43 of file FileManager.h.

#define SCRIB_TYPE   "irx"

Definition at line 62 of file FileManager.h.

---

Typedef Documentation

typedef struct _FileManager FileManager

typedef struct _Manifest Manifest

typedef FileManager* PFileManager

Definition at line 114 of file FileManager.h.

typedef ScribPage* PScribPage

Definition at line 78 of file FileManager.h.

typedef struct _ScribPage ScribPage

---

Function Documentation

int createDirHirachy

(

PFileManager

pFM

)

Definition at line 54 of file FileManager.c.

{    
    //if dir not exist, creat dirstruct
    const char* sDataDir=pFM->sDataDir;
    if( pFM->bNeedCreatDirHirachy && !FileExist(sDataDir) )
    {
        SB_FMPRINTF("create for\n%s\n",sDataDir);
        if( 0!=CreateDir(sDataDir))
        {
            SB_ERRORPRINTF("create directory [%s]fail\n",sDataDir);
            return -1;
        }
        SB_FMPRINTF("create directory [%s] ok\n",sDataDir);
        char sResultDir[MAX_PATHNAME+1];           
            //crearete ./result directory
        get_result_dirname(sResultDir,sizeof(sResultDir),sDataDir);
        if( 0!=CreateDir(sResultDir))
        {
            SB_ERRORPRINTF("create directory [%s]fail\n",sResultDir);
            return -1;
        }
        SB_FMPRINTF("create directory [%s] ok\n",sResultDir);
                 
        //now we can init the handle to .irx inkfile.
        if( 0!=fm_initIrxHandle(pFM,FALSE) )
        {
            SB_ERRORPRINTF("create .irx inkfile error\n");
            return -1;
        }
        pFM->bNeedCreatDirHirachy=FALSE; 
        SB_FMPRINTF("done\n");         
    }  

    return 0;
}

Here is the call graph for this function:

int deleteCurrPage

(

PFileManager

pFM

)

Definition at line 367 of file FileMgr_page.c.

{
    return deletePage( pFM,getCurrPageNo(pFM) );
}

Here is the call graph for this function:

void dumpFileManager

(

PFileManager

pFM

)

Definition at line 91 of file FileManager.c.

{

    SB_FMPRINTF("\n==========================================\n"
            "sTmplPathName=[%s]\n"
            "sManifestPathName=[%s]\n"
            "sDataDir=[%s]\n"
            "sScribbleName=[%s]\n"
            "========================================\n",
            pFM->sTmplPathName,
            pFM->sManifestPathName,
            pFM->sDataDir, 
            pFM->manifest.sScribbleName);
}

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);
}

void dumpManifest

(

Manifest *

pM

)

Definition at line 298 of file FileManager.c.

{
    printf("\n=================================\n"
            "sScribbleName=[%s]\n"
            "iLastOpenPage=[%d]\n"
            "iTotalPages=[%d]\n",
            pM->sScribbleName,pM->iLastOpenPage,pM->iTotalPages);
    PScribPage  pPage=pM->pFirstScribPage;;
    while(pPage)
    {
        printf("----------------------------------\n");
        printf("sImgFileName=[%s]\nsPageName=[%s]\n",  
               pPage->sImgFileName,pPage->sPageName);
        printf("sImgFileName=[%s]\nsPageName=[%s]\nbDirty=%d\n",  
               pPage->sImgFileName,pPage->sPageName,pPage->bDirty);
                
        pPage=pPage->pNextPage;
    }
    printf("=================================\n");
}

int fc_convertold2irx

(

PFileManager

pFM

)

Definition at line 71 of file FormatConverter.c.

{
    //currently, we can only(also need only) convert notes
    if( 0!=strcasecmp(pFM->manifest.sInkType,"notes") )
    {
        SB_ERRORPRINTF("error:unknow ink type!\n");
        return -1;
    }
    //load everypage and fill in Manifest
    PScribPage pCurrPage=pFM->manifest.pFirstScribPage;
    char sInkFileName[MAX_FILENAME];
    
    while(pCurrPage)
    {
        fc_get_ink_filename(sInkFileName,MAX_FILENAME,pFM,pCurrPage);
        pCurrPage->pink=file_read_ink(sInkFileName);
        if( pCurrPage->pink== NULL)
        {
            SB_FMPRINTF("-- null in page \n%s\n",pCurrPage->sPageName);
        }else
        {
            SB_FMPRINTF("--load strokes=%d\nin [%s]",pCurrPage->pink->nStrokes,pCurrPage->sPageName);
        }
        pCurrPage=pCurrPage->pNextPage;
    }
    SB_FMPRINTF("-- saving the old ink folder");
    //save the ink
    int iRet=fm_saveAllPages(pFM);
    if( 0!= iRet)
    {
        SB_FMPRINTF("-- save pages error\n");
        return -1;
    }

    //when success,deleted the whole ink directory.
    char sInkDir[MAX_PATHNAME];
    fc_get_ink_dirname(sInkDir,sizeof(sInkDir),pFM->sDataDir);
    SB_FMPRINTF("-- deleting folder [%s]", sInkDir);
    char* cmd = g_strdup_printf("rm -rf \"%s\"", sInkDir);
    system(cmd);
    g_free(cmd);
    return 0;

}

Here is the call graph for this function:

int fm_deleteOnePage	(	PFileManager	pFM,
		PScribPage	pPage
	)

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:

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:

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_saveOnePage	(	PFileManager	pFM,
		PScribPage	pPage
	)

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:

void fm_setIrxInkDirty	(	PFileManager	pFM,
		gboolean	bDirty
	)

Definition at line 384 of file FileMgr_page.c.

{
    pFM->manifest.bNeedSaveIrx=bDirty;
}

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:

void FreeFileManager

(

PFileManager

pFM

)

Definition at line 205 of file FileManager.c.

{
    if( NULL==pFM ) return;
    
    PScribPage pCurrPage=pFM->manifest.pFirstScribPage;
    PScribPage pNextPage=NULL;
    while(pCurrPage)
    {
        pNextPage=pCurrPage->pNextPage;
        //free scribpage inlcude ink object
        freeScribPage(pCurrPage);
        pCurrPage=pNextPage;
    }
    if( NULL!=pFM->irxHandle)
    {
        free(pFM->irxHandle);
        pFM->irxHandle=NULL;
    }
    memset(pFM,0,sizeof(FileManager));
}

Here is the call graph for this function:

void freeScribPage

(

PScribPage

pPage

)

Definition at line 291 of file FileMgr_page.c.

{
     //free ink object
    if(pPage->pink)
    {
        free(pPage->pink);
        pPage->pink=NULL;
    }
    free(pPage);
}

int get_curr_result_filename	(	char *	resultFileName,
		int	iSize,
		const PFileManager	pFM
	)

Definition at line 291 of file FileManager.c.

{
    return get_result_filename(resultFileName,iSize,
                               pFM,getCurrScribPage(pFM));
}

Here is the call graph for this function:

int get_ink_filename	(	char *	inkFileName,
		int	iSize,
		const PFileManager	pFM
	)

Definition at line 250 of file FileManager.c.

{
    //SB_FMPRINTF("__start__\n");   
    memset(inkFileName,0,iSize);
    snprintf( inkFileName,iSize-1,
              "%s%s.irx",
              pFM->sDataDir,
              pFM->manifest.sScribbleName);
    //SB_FMPRINTF("__end__\ninkFileName=%s\n", inkFileName);
    return 0;
}

int get_result_filename	(	char *	resultFileName,
		int	iSize,
		const PFileManager	pFM,
		const PScribPage	pScribPage
	)

Definition at line 275 of file FileManager.c.

{
    //SB_FMPRINTF("__start__\n");    
    if( NULL==pScribPage) return -1;
    
    memset(resultFileName,0,iSize);
    snprintf( resultFileName,iSize-1,
              "%sresult/%s.png",
              pFM->sDataDir,
              pScribPage->sPageName);
    //SB_FMPRINTF("__end__\nresultfile=%s\n", resultFileName);
    return 0;
}

char* getAbsPathFromCurrScrib	(	char *	sAbsFileName,
		int	iSize,
		const char *	currFileName,
		const PFileManager	pFM
	)

Definition at line 228 of file FileManager.c.

{
    memset(sAbsFileName,0,iSize);
    if( currFileName[0] == '/' ) 
    {
        strncpy(sAbsFileName,currFileName,iSize-1);
    }
    else
    {    
        
        snprintf( sAbsFileName,iSize-1,
                    "%s%s",
                    pFM->sDataDir,
                    currFileName);
    }
    return sAbsFileName;
}

const char* getCurrImgFileName

(

PFileManager

pFM

)

Definition at line 143 of file FileMgr_page.c.

{
    return getCurrScribPage(pFM)->sImgFileName;
}

Here is the call graph for this function:

int getCurrPageNo

(

PFileManager

pFM

)

Definition at line 379 of file FileMgr_page.c.

{
    return pFM->iCurrOpenPage;
}

PScribPage getCurrScribPage

(

PFileManager

pFM

)

Definition at line 137 of file FileMgr_page.c.

{
    return pFM->pCurrPage;
}

int getTotalPage

(

PFileManager

pFM

)

Definition at line 374 of file FileMgr_page.c.

{
    return pFM->manifest.iTotalPages;
}

int initFileManagerByManifest	(	PFileManager	pFM,
		const char *	sManifest
	)

Definition at line 148 of file FileManager.c.

{
    SB_FMPRINTF("init by \n%s\n",sManifestPathName);
    memset(pFM,0,sizeof(FileManager));
    strncpy(pFM->sManifestPathName,sManifestPathName,
            sizeof(pFM->sManifestPathName)-1 );
    if( 0!=loadManifest(pFM) )
    {
        SB_ERRORPRINTF("load manifest[%s] error\n",sManifestPathName);
        return -1;
    }    

    GetDirFromFullName(pFM->sDataDir,sizeof(pFM->sDataDir),sManifestPathName);   
    
    pFM->isCreatedFromTmpl=FALSE;
    
    SB_FMPRINTF("notes type is:[%s]",pFM->manifest.sInkType);
    //if type is not irex(current type), we need conversion it to new format
    if( 0!=strcasecmp(pFM->manifest.sInkType,SCRIB_TYPE) )
    {
        SB_FMPRINTF("init by \n%s\n",sManifestPathName);
        if( 0!=fc_convertold2irx(pFM) )
        {
            SB_ERRORPRINTF("converting error\n");
            return -1;
        }
        pFM->bNeedSaveManifest=TRUE;
        SB_FMPRINTF("update manifest...");
        strncpy(pFM->manifest.sInkType,SCRIB_TYPE,sizeof(pFM->manifest.sInkType));
        //change the type to irx and save the manifest
        if( 0!=fm_setIrxTypeAndSave(pFM) )
        {
            SB_ERRORPRINTF("save type error[%s]\n",pFM->sManifestPathName);
            return -1;
        }
    } 
       
    if( 0!=fm_initIrxHandle(pFM,TRUE) )
    {
            SB_ERRORPRINTF("open .irx inkfile error\n");
            return -1;
    }
    
    pFM->bNeedSaveManifest=FALSE;
       
    PScribPage pScribPage=jumptoScribPage(pFM,pFM->manifest.iLastOpenPage);
    if( NULL==pScribPage ) //no page
        return -1;
    //get template from CurrentPage
    strcpy(pFM->sTmplPathName,pScribPage->sImgFileName);    
    
    pFM->bNeedCreatDirHirachy=FALSE;
    
    dumpFileManager(pFM);
    return 0;
}

Here is the call graph for this function:

int initFileManagerByTmpl	(	PFileManager	pFM,
		const char *	sTmplPathName
	)

Definition at line 107 of file FileManager.c.

{    
    SB_FMPRINTF("init by %s\n",sTmplPathName);
    int iLenOfSuffix=strlen(".bmp");
    if( NULL==sTmplPathName || strlen(sTmplPathName)<=iLenOfSuffix )
        return -1;
    
    memset(pFM,0,sizeof(FileManager));
    
    strncpy(pFM->sTmplPathName,sTmplPathName,
            sizeof(pFM->sTmplPathName)-1);
    
    GetDirFromFullName(pFM->sDataDir,sizeof(pFM->sDataDir),sTmplPathName);

    if( 0!=getUniqNameForSCRIB(pFM) )
    {
        return -1;
    }
    //DataDir should just above of manifest
    strcat(pFM->sDataDir,pFM->manifest.sScribbleName);
    strcat(pFM->sDataDir,"/");
       
    //constract manifest       
    strcpy(pFM->sManifestPathName,pFM->sDataDir);
    strcat(pFM->sManifestPathName,MANIFEST_FILENAME);
    
    dumpFileManager(pFM);
    //init manifest.
    pFM->manifest.iLastOpenPage=0;//numbered from 1.
    pFM->manifest.iTotalPages=0;       
    
    pFM->bNeedCreatDirHirachy=TRUE;
    pFM->isCreatedFromTmpl=TRUE;
    
    //construct the first new page.
    insertNewPage(pFM,1,NULL);
    jumptoScribPage(pFM,1);    
    
    return 0;
}

Here is the call graph for this function:

int insertNewPage	(	PFileManager	pFM,
		int	iPageNo,
		const char *	sImgName
	)

Definition at line 206 of file FileMgr_page.c.

{
    int iTotalPage=getTotalPage(pFM);
    SB_FMPRINTF("insert %d.current[total=%d,curropen=%d]\n",
                iPageNo,getTotalPage(pFM),getCurrPageNo(pFM));
    if( iPageNo<1 || iPageNo>(1+iTotalPage) )
    {
        SB_WARNPRINTF("invalid pageno:%d[total=%d,curropen=%d]\n",
                    iPageNo,iTotalPage,getCurrPageNo(pFM));
        return -1;
    }
    ScribPage *pScribPage=(ScribPage *)malloc(sizeof(ScribPage));
    if(  NULL==pScribPage)
    {
        SB_ERRORPRINTF("error when malloc space\n");
        return -1;
    }
    memset(pScribPage,0,sizeof(ScribPage));
    if( 0!=getNewPageName(pScribPage,&pFM->manifest) )
    {
        SB_ERRORPRINTF("error when get new page name\n");
        free(pScribPage);
        return -1;
    }
    //generate a new ink data structure
    pScribPage->pink=construct_ink();
    assert(pScribPage->pink);
    
    const char *sCurrImgName=sImgName;
    if( isStrEmpty(sImgName) )
    {
        sCurrImgName=pFM->sTmplPathName;
    }
    //currently, the image name is always same as template name
    strcpy( pScribPage->sImgFileName,sCurrImgName);
    
    //get previous scribpage
    ScribPage *pPrevScribPage=getScribPage(pFM,iPageNo-1);
    if( NULL==pPrevScribPage)
    {//it's first page.
        pScribPage->pNextPage=pFM->manifest.pFirstScribPage;
        pFM->manifest.pFirstScribPage=pScribPage;       
    }
    else
    {
        pScribPage->pNextPage=pPrevScribPage->pNextPage;
        pPrevScribPage->pNextPage=pScribPage;
    }
    //reset total page
    pFM->manifest.iTotalPages++;
    //reset current pageno if necessary
    if( iPageNo<=getCurrPageNo(pFM))
    {
        pFM->iCurrOpenPage++;
    }
    
    pFM->bNeedSaveManifest=TRUE;
    SB_FMPRINTF("insert %d done.current[total=%d,curropen=%d]\n",
                iPageNo,getTotalPage(pFM),getCurrPageNo(pFM));
    return 0;
}

Here is the call graph for this function:

PScribPage jumptoScribPage	(	PFileManager	pFM,
		int	iPageNo
	)

Definition at line 182 of file FileMgr_page.c.

{
    SB_FMPRINTF("jumpto pageno:%d[total=%d,curropen=%d]\n",
                iPageNo,getTotalPage(pFM),getCurrPageNo(pFM));
    //if iPageNo<1, then set to 1, >iTotalpage, set to last.
    if( iPageNo<1 ) iPageNo=1;

    if( iPageNo>getTotalPage(pFM) ) iPageNo=getTotalPage(pFM);

    PScribPage pPage=getScribPage(pFM,iPageNo);
    //must find, actually.
    if( NULL!=pPage )
    {
        pFM->iCurrOpenPage=iPageNo;
        pFM->pCurrPage=pPage;
    }
    SB_FMPRINTF("jump done.pageno=%d[pPage==NULL?%d]\n",
                iPageNo,NULL==pPage);
    return pPage;
}

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: