scribble/src/ink_rw_xml.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>
#include "ink_rw.h"
#include "ScribbleLog.h"
#include "ScribbleUtils.h"

Go to the source code of this file.

Defines
#define	MAX_XPATH   512
#define	MAX_STOKE_STR   0x10000
#define	MAX_CHARS_IN_LINE   64
Functions
gboolean	xml_page_exist (erManifest *pXmlHandle, const char *sPageName)
int	xml_parse_stroke (PtrStroke pStroke, const char *strpoints)
PtrInk	xml_read_ink (erManifest *pXmlHandle, const char *sPageName)
gboolean	xml_write_stroke (erManifest *pXmlHandle, const char *xpath, const PtrStroke pStroke)
int	xml_write_irxHead (erManifest *pErManiHandle)
void	xml_write_page_head (erManifest *pXmlHandle, const char *xpath)
gboolean	xml_write_ink (erManifest *pXmlHandle, const char *xpath, const PtrInk pink, const char *sPageName)

---

Define Documentation

#define MAX_CHARS_IN_LINE   64

Definition at line 192 of file ink_rw_xml.c.

#define MAX_STOKE_STR   0x10000

Definition at line 47 of file ink_rw_xml.c.

#define MAX_XPATH   512

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

Definition at line 43 of file ink_rw_xml.c.

---

Function Documentation

gboolean xml_page_exist	(	erManifest *	pXmlHandle,
		const char *	sPageName
	)

Definition at line 49 of file ink_rw_xml.c.

{    
    if( NULL==pXmlHandle || NULL==sPageName)
    {
        SB_INKERRPRINTF("error:invalid parameter\n");
        return FALSE;
    }
    
    char sCurrXPath[MAX_XPATH];
    snprintf(sCurrXPath,MAX_XPATH,"/notes/pages/page[@id=\"%s\"]",sPageName);
    SB_FMPRINTF("sCurrXPath=\n%s\n",sCurrXPath);
    if( RET_OK!=ermXmlExist(pXmlHandle, sCurrXPath) )
    {
        SB_INKERRPRINTF("page[%s] not existed\n",sPageName);
        return FALSE;
    }
    return TRUE;
}

Here is the call graph for this function:

int xml_parse_stroke	(	PtrStroke	pStroke,
		const char *	strpoints
	)

Definition at line 70 of file ink_rw_xml.c.

{
    if (strpoints == NULL || pStroke == NULL)
    {
        SB_INKERRPRINTF("failed:incorrect arguments\n");
        return -1;
    }
    
    gchar**  points_set=g_strsplit_set(strpoints," \n\t",-1);
    if ( NULL==points_set[0])
    {
        SB_INKERRPRINTF("returned:nPoints=0\n");
        pStroke->nPoints=0;
        return 0;
    }
    
    /*
    int i=0;
    printf("====================\n",i,points_set[i]);
    while( points_set[i] && strlen(points_set[i]) )
    {
        printf("data[%d]=[=%s=]\n",i,points_set[i]);
        i++;
    }
    printf("============total data number=[%d]\n",i);
    */
    
    PtrInkPoint point;
    int i=0;   
    while( points_set[i] && strlen(points_set[i]) )
    {
        point = construct_point ();
        if ( NULL==point )
        { 
            SB_INKERRPRINTF("construct point error\n");
            g_strfreev(points_set);
            return -1;
        }
        point->x=atoi(points_set[i]);
        i++;
        if(!points_set[i])
        {
            SB_INKERRPRINTF("failed getting point->y for the %dth point)\n",i/3+1);
            break;
        }
        point->y=atoi(points_set[i]);
        SB_INKPRINTF("point(%d,%d) \n", point->x, point->y);
        ink_add_point(pStroke, point);
        i++;        
        if(!points_set[i])
        {
            SB_INKERRPRINTF("failed getting point->pressure for the %dth point)\n",i/3+1);
            break;
        }
        //currently ,we ignore the pen presure
        i++;
    }
    pStroke->nPoints=i/3;
    //SB_FMPRINTF("total points=%d",pStroke->nPoints);
    g_strfreev(points_set);
    return 0;
}

Here is the call graph for this function:

PtrInk xml_read_ink	(	erManifest *	pXmlHandle,
		const char *	sPageName
	)

Definition at line 135 of file ink_rw_xml.c.

{    
    if( NULL==pXmlHandle || NULL==sPageName)
    {
        SB_INKERRPRINTF("error:invalid parameter\n");
        return NULL;
    }
    PtrInk pink = construct_ink ();
    if (NULL == pink )
    {
        SB_INKERRPRINTF("error:construct_ink\n");
        return NULL;
    }
    
    if( !xml_page_exist(pXmlHandle,sPageName) )
    {
        return pink;
    }
    
    char sStrPoints[MAX_STOKE_STR];    
    char sStrokeXPath[MAX_XPATH];
    int i=1;
    char sHtmlColor[HTMLCOLOR_LEN];
    while(TRUE)
    {
        snprintf(sStrokeXPath,MAX_XPATH,
                 "/notes/pages/page[@id=\"%s\"]/strokes/stroke[%d]",
                 sPageName, i );
        //SB_FMPRINTF("path=\n%s\n",sStrokeXPath);
        if( RET_OK!=ermXmlGetString(pXmlHandle,sStrokeXPath, 
                                    sStrPoints, MAX_STOKE_STR) )
        {
            break;
        }
        //SB_INKPRINTF("\n\npoints=%s\n\n",sStrPoints);   
        PtrStroke pStroke = construct_stroke ();
        if (pStroke == NULL)
        {
            SB_INKERRPRINTF("return: construct_stroke failed \n");
            break;
        }
        xml_parse_stroke (pStroke,sStrPoints);
        
        ermXmlGetAttributeInt(pXmlHandle,sStrokeXPath,
                              "pensize",&pStroke->iPenSize);
        ermXmlGetAttributeString(pXmlHandle,sStrokeXPath,
                              "color",sHtmlColor,HTMLCOLOR_LEN);
        Util_GdkColorFromHtmlColor(&pStroke->gdkColor,sHtmlColor);
        
        ink_add_stroke (pink, pStroke);
        i++;
    }
    SB_FMPRINTF("read %d strokes \n",i);
    return pink;
}

Here is the call graph for this function:

gboolean xml_write_ink	(	erManifest *	pXmlHandle,
		const char *	xpath,
		const PtrInk	pink,
		const char *	sPageName
	)

Definition at line 269 of file ink_rw_xml.c.

{
    if( NULL==pXmlHandle || NULL==xpath || NULL==sPageName )//0==pink->nStrokes
    {
        return FALSE;
    }    
    SB_FMPRINTF("--page,path=[%s],sPageName=%s",xpath,sPageName);
    
    char sCurrXPath[MAX_XPATH];
    
    //if the page exist,we first empty it.
    if( !xml_page_exist(pXmlHandle,sPageName) )
    {
        ermXmlNewString(pXmlHandle, xpath, "page", "");
        
        snprintf(sCurrXPath,MAX_XPATH,"%s/page[last()]",xpath);   
        ermXmlSetAttributeString(pXmlHandle,sCurrXPath,
                                "id",sPageName,strlen(sPageName) );
        snprintf(sCurrXPath,MAX_XPATH,"%s/page[@id=\"%s\"]",xpath,sPageName); 
    }
    else
    { //empty it firstly
        snprintf(sCurrXPath,MAX_XPATH,"%s/page[@id=\"%s\"]",xpath,sPageName); 
        ermXmlSetString(pXmlHandle,sCurrXPath, "");
    }
    if( NULL==pink || 0==pink->nStrokes )
    {
        return TRUE;
    }
     
    xml_write_page_head(pXmlHandle,sCurrXPath);
    
    SB_FMPRINTF("ink->nStrokes=%d \n", pink->nStrokes);
    PtrStroke pStroke = pink->firstStroke;
    int i=1;
    char strokesPath[MAX_XPATH];
    snprintf(strokesPath,MAX_XPATH,"%s/strokes",sCurrXPath);
    char sLastStrokeXPath[MAX_XPATH];//xpath for last stroke

    while (pStroke)
    {     
        ermXmlNewString(pXmlHandle, strokesPath, "stroke", "");
        snprintf(sLastStrokeXPath,MAX_XPATH,"%s/stroke[%d]",strokesPath,i);
        //SB_FMPRINTF("\nsLastStrokeXPath=[%s]\n",sLastStrokeXPath);
        xml_write_stroke(pXmlHandle,sLastStrokeXPath,pStroke);
        pStroke = pStroke->nextStroke;
        i++;
    }
    return TRUE;
}

Here is the call graph for this function:

int xml_write_irxHead

(

erManifest *

pErManiHandle

)

Definition at line 240 of file ink_rw_xml.c.

{
    ermXmlNewString(pErManiHandle, "/", "notes", "");
    ermXmlNewString(pErManiHandle, "/notes", "version", "");
    ermXmlNewString(pErManiHandle, "/notes/version", "number", "1.0");
    ermXmlNewString(pErManiHandle, "/notes/version","orgnization", "iRex Technologies");
    
    ermXmlNewString(pErManiHandle, "/notes", "screen", "");
    //units can be px,mm or in.
    ermXmlNewString(pErManiHandle, "/notes/screen", "units", "px");
    ermXmlNewInt(pErManiHandle, "/notes/screen","dpi", 160);
        
    ermXmlNewString(pErManiHandle, "/notes", "pages", "");
    
    return 0;
}

Here is the call graph for this function:

void xml_write_page_head	(	erManifest *	pXmlHandle,
		const char *	xpath
	)

Definition at line 258 of file ink_rw_xml.c.

{
    ermXmlSetAttributeString(pXmlHandle,xpath, 
                             "backgroundcolor","#000000",HTMLCOLOR_LEN);
    ermXmlNewInt(pXmlHandle, xpath, "orientation", 0);
    ermXmlNewInt(pXmlHandle, xpath, "height", 935);
    ermXmlNewInt(pXmlHandle, xpath, "width", 768);
    ermXmlNewString(pXmlHandle, xpath, "strokes", "");
}

Here is the call graph for this function:

gboolean xml_write_stroke	(	erManifest *	pXmlHandle,
		const char *	xpath,
		const PtrStroke	pStroke
	)

Definition at line 201 of file ink_rw_xml.c.

{
    if( NULL==xpath || NULL==pStroke || 0==pStroke->nPoints)
    {
        return FALSE;
    }    
    
    ermXmlSetAttributeInt(pXmlHandle,xpath,"layer",0);
    ermXmlSetAttributeString(pXmlHandle,xpath,"linestyle","solid",strlen("solid"));
    ermXmlSetAttributeInt(pXmlHandle,xpath,"pensize",pStroke->iPenSize);
    
    char sHtmlColor[10];
    Util_HtmlColorFromGdkColor(sHtmlColor,10,&pStroke->gdkColor);
    ermXmlSetAttributeString(pXmlHandle,xpath,
                             "color",sHtmlColor,HTMLCOLOR_LEN);
    
    char dataLine[MAX_CHARS_IN_LINE];
    GArray*  garr_stroke=g_array_sized_new(TRUE,FALSE,sizeof(char),1024);
    
    //SB_FMPRINTF("stroke->nPoints=%d \n", pStroke->nPoints);
    PtrInkPoint point = pStroke->firstPoint;
    while (point)
    {
        //write a line for a point
        snprintf(dataLine,MAX_CHARS_IN_LINE,"%d %d 0\n",point->x,point->y);        
        g_array_append_vals(garr_stroke,dataLine,strlen(dataLine));      
        point = point->nextPoint;     
    }  
    //printf("\n\nfinal stroke string:%s\n\n",  garr_stroke->data);
    ermXmlSetString(pXmlHandle, xpath, garr_stroke->data);
    
    g_array_free(garr_stroke,FALSE);
    return TRUE;
}

Here is the call graph for this function: