scbdoc.c File Reference

#include <fcntl.h>
#include <string.h>
#include <assert.h>
#include <sys/time.h>
#include <glib.h>
#include <glib/gprintf.h>
#include "scbdoc.h"
#include "scblog.h"
#include "scbpage.h"

Include dependency graph for scbdoc.c:

Go to the source code of this file.

Defines
#define	_GNU_SOURCE
#define	METADB_FILE_POSITION   "file_position"
#define	METADB_START_ANCHOR   "start_anchor"
#define	METADB_END_ANCHOR   "end_anchor"
#define	METADB_ANNOTATION_ID   "annotation_id"
#define	METADB_DATA   "data"
Functions
static void	update_timestamp (ScbPagePtr page)
static void	remove_oldest_page_scribbles (ScbDocPtr doc)
static gboolean	load_application_data (ScbDocPtr doc)
static gboolean	save_application_data (ScbDocPtr doc)
static void	load_pages_basic_data (const ScbDocPtr doc, const metadata_table *table)
static metadata_table *	load_document_data (const ScbDocPtr doc)
static gboolean	load_page_data (ScbDocPtr doc, ScbPagePtr page)
static gboolean	save_page_data (const ScbDocPtr doc, const ScbPagePtr page, const ScbStreamPtr stream, gboolean *need_free_stream)
void	erscribble_doc_init_context (ScbDocPtr ptr)
void	erscribble_doc_free_context (ScbDocPtr ptr)
ScbDocPtr	erscribble_doc_new (const ScbPathPtr target_doc_path)
ScbDocPtr	erscribble_doc_new_with_database (const char *target_file_name, erMetadb metadata_db)
void	erscribble_doc_free (ScbDocPtr ptr)
void	erscribble_doc_free_without_database (ScbDocPtr ptr)
ScbDocPtr	erscribble_doc_open (const ScbPathPtr target_doc_path)
ScbDocPtr	erscribble_doc_open_with_database (const char *target_file_name, erMetadb metadata_db)
ScbPagesPtr	erscribble_doc_get_pages (ScbDocPtr ptr)
ScbStrokeAttributesPtr	erscribble_doc_get_current_stroke_attributes (ScbDocPtr doc)
ScbPagePtr	erscribble_doc_get_page (ScbDocPtr doc, const ScbPageIdPtr id)
gboolean	erscribble_doc_save_page (ScbDocPtr doc, ScbPagePtr page)
gboolean	erscribble_doc_add_page (ScbDocPtr doc, ScbPagePtr page)
static gboolean	erscribble_doc_insert_page_impl (ScbDocPtr doc, ScbPagesPtr pages, ScbPagePtr page)
gboolean	erscribble_doc_insert_page (ScbDocPtr doc, ScbPagePtr page)
static gboolean	erscribble_doc_delete_page_impl (ScbDocPtr doc, ScbPagesPtr pages, ScbPageIdPtr pid)
gboolean	erscribble_doc_delete_page (ScbDocPtr doc, ScbPageIdPtr pid)
void	erscribble_doc_add_map_item (ScbDocPtr doc, const ScbTBSItemPtr ptr)
ScbTBState	erscribble_doc_get_current_state (ScbDocPtr doc)
gboolean	erscribble_state_is_scribble (ScbDocPtr doc)
gboolean	erscribble_state_is_erase (ScbDocPtr doc)
void	erscribble_doc_dump (ScbDocPtr ptr)
void	erscribble_doc_disable_autodelete (gboolean do_disable)
Variables
static gboolean	g_enable_autodelete = TRUE

---

Define Documentation

#define _GNU_SOURCE

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

Definition at line 28 of file scbdoc.c.

#define METADB_ANNOTATION_ID   "annotation_id"

Definition at line 68 of file scbdoc.c.

Referenced by load_pages_basic_data().

#define METADB_DATA   "data"

Definition at line 69 of file scbdoc.c.

Referenced by load_page_data().

#define METADB_END_ANCHOR   "end_anchor"

Definition at line 67 of file scbdoc.c.

#define METADB_FILE_POSITION   "file_position"

Definition at line 65 of file scbdoc.c.

Referenced by load_pages_basic_data().

#define METADB_START_ANCHOR   "start_anchor"

Definition at line 66 of file scbdoc.c.

Referenced by load_pages_basic_data().

---

Function Documentation

void erscribble_doc_add_map_item	(	ScbDocPtr	doc,
		const ScbTBSItemPtr	ptr
	)

Definition at line 607 of file scbdoc.c.

References _ScbDoc::context, LOGPRINTF, and _ScbDocContext::table.

{
    LOGPRINTF("entry");
    //ERSCRIBBLE_RET_IF(NULL == doc || NULL == ptr, "Invalid pointer(s)!");
    g_array_append_val(doc->context.table,  *ptr);
    LOGPRINTF("exit");
}

gboolean erscribble_doc_add_page	(	ScbDocPtr	doc,
		ScbPagePtr	page
	)

Definition at line 464 of file scbdoc.c.

References erscribble_doc_get_pages(), erscribble_pages_add_page(), and LOGPRINTF.

Referenced by notepad::CNotepadDoc::add_page(), and notepad::CNotepadDoc::on_scribble_end().

{
    LOGPRINTF("entry");
    ScbPagesPtr pages = erscribble_doc_get_pages(doc);
    if (NULL == pages) return FALSE;
    LOGPRINTF("exit");
    return erscribble_pages_add_page(pages, page);
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean erscribble_doc_delete_page	(	ScbDocPtr	doc,
		ScbPageIdPtr	pid
	)

Definition at line 596 of file scbdoc.c.

References erscribble_doc_delete_page_impl(), erscribble_doc_get_pages(), and LOGPRINTF.

Referenced by notepad::CNotepadDoc::delete_page().

{
    LOGPRINTF("entry");
    ScbPagesPtr pages = erscribble_doc_get_pages(doc);
    if (NULL == pages) 
        return FALSE;
    LOGPRINTF("exit");
    return erscribble_doc_delete_page_impl(doc, pages, pid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean erscribble_doc_delete_page_impl	(	ScbDocPtr	doc,
		ScbPagesPtr	pages,
		ScbPageIdPtr	pid
	)			[static]

Definition at line 527 of file scbdoc.c.

References _ScbPageId::annotation_id, ER_OK, ermetadb_local_remove_annotation(), erscribble_doc_save_page(), erscribble_page_clear_strokes(), erscribble_pages_free(), erscribble_pages_get_page(), erscribble_pages_new(), ERSCRIBBLE_RET_FALSE_IF, _ScbPageId::id, _ScbPage::id, _ScbPage::is_blob_loaded, load_document_data(), load_page_data(), LOGPRINTF, _ScbDoc::metadata_db, _ScbDoc::pages, _ScbPageId::position, and update_timestamp().

Referenced by erscribble_doc_delete_page().

{
    LOGPRINTF("entry");
    ERSCRIBBLE_RET_FALSE_IF(NULL == doc || NULL == pages || NULL == pid, "Invalid pages or page pointer!");
   
    int result = -1;
    gboolean ok = FALSE;
    ScbPagePtr page = erscribble_pages_get_page(pages, pid);

    if (page != NULL)
    {
        // update the access time of current page
        update_timestamp(page);

        // load the BLOB data of current page if it exists
        // at this time, the BLOB data of oldest page would be deleted
        erscribble_page_clear_strokes(page);
        page->is_blob_loaded = FALSE;
        load_page_data(doc, page);
    }
  
    ermetadb_local_remove_annotation(doc->metadata_db, page->id.annotation_id);
    page = NULL ; 
    erscribble_pages_free(&doc->pages);

    ok = erscribble_pages_new(&doc->pages);

    if (ok)
    {
        // load the document data from data base
        ok = (NULL != load_document_data(doc));
    }

    GList* ptr = g_list_first((&doc->pages)->pages);
    ScbPagePtr cur_page = (ScbPagePtr)ptr->data;

    if (ok)
    {
        while (ptr)
        {
            cur_page = (ScbPagePtr)ptr->data;
            if (cur_page && (cur_page->id.position > pid->position))
            {
                // update the access time of current page
                update_timestamp(cur_page);
                load_page_data(doc, cur_page);

                cur_page->id.position -= 1;
                gint64 my_id = 0;
                my_id = g_ascii_strtoll(cur_page->id.id,  NULL, 10  );
                my_id -= 1;
                g_sprintf(cur_page->id.id, "%lld", my_id);

                result = erscribble_doc_save_page(doc, cur_page); // todo check result
                if (result != ER_OK ) break;
            }
            ptr = g_list_next(ptr);
        }
    }
    else 
    {
        result = -1;
    }

    LOGPRINTF("exit");
    return (gboolean)( result == ER_OK );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_doc_disable_autodelete

(

gboolean

do_disable

)

Definition at line 1235 of file scbdoc.c.

References g_enable_autodelete.

Referenced by notepad::CNotepadDoc::CNotepadDoc().

{
    g_enable_autodelete = !do_disable ;  // reverse semantics
}

Here is the caller graph for this function:

void erscribble_doc_dump

(

ScbDocPtr

ptr

)

Definition at line 635 of file scbdoc.c.

References erscribble_pages_dump(), and _ScbDoc::pages.

{
    if (ptr)
    {
        erscribble_pages_dump(&ptr->pages);
    }
}

Here is the call graph for this function:

void erscribble_doc_free

(

ScbDocPtr

ptr

)

Definition at line 204 of file scbdoc.c.

References _ScbDocVersion::company, erscribble_doc_free_context(), erscribble_pages_free(), LOGPRINTF, _ScbDoc::pages, _ScbDoc::screen, _ScbScreen::units, and _ScbDoc::version.

Referenced by test::ScribbleMgr::close(), notepad::CNotepadDoc::close(), erscribble_doc_free_without_database(), and erscribble_doc_open_with_database().

{
    LOGPRINTF("entry");
    if (NULL == ptr)
    {
        return;
    }

    erscribble_doc_free_context(ptr);
    erscribble_pages_free(&ptr->pages);

    if (ptr->version.company != NULL)
    {
        g_string_free(ptr->version.company, TRUE);
    }

    if (ptr->screen.units != NULL)
    {
        g_string_free(ptr->screen.units, TRUE);
    }

    g_free(ptr);
    LOGPRINTF("exit");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_doc_free_context

(

ScbDocPtr

ptr

)

Definition at line 130 of file scbdoc.c.

References _ScbDoc::context, LOGPRINTF, and _ScbDocContext::table.

Referenced by erscribble_doc_free().

{
    LOGPRINTF("entry");
    if (ptr->context.table != NULL)
    {
        g_array_free(ptr->context.table, TRUE);
        ptr->context.table = NULL;
    }
    LOGPRINTF("exit");
}

Here is the caller graph for this function:

void erscribble_doc_free_without_database

(

ScbDocPtr

ptr

)

Definition at line 230 of file scbdoc.c.

References ermetadb_close(), erscribble_doc_free(), LOGPRINTF, and _ScbDoc::metadata_db.

{
    LOGPRINTF("entry");
    if (NULL == ptr)
    {
        return;
    }

    // close the database
    ermetadb_close(ptr->metadata_db);
    ptr->metadata_db = NULL;

    // free the scribbble doc
    erscribble_doc_free(ptr);
    LOGPRINTF("exit");
}

Here is the call graph for this function:

ScbTBState erscribble_doc_get_current_state

(

ScbDocPtr

doc

)

Definition at line 616 of file scbdoc.c.

References _ScbDoc::context, _ScbDocContext::curState, and ERSCRIBBLE_TBS_INVALID.

Referenced by erscribble_state_is_erase(), and erscribble_state_is_scribble().

{
    if (NULL == doc) return ERSCRIBBLE_TBS_INVALID;
    return doc->context.curState;
}

Here is the caller graph for this function:

ScbStrokeAttributesPtr erscribble_doc_get_current_stroke_attributes

(

ScbDocPtr

doc

)

Definition at line 334 of file scbdoc.c.

References _ScbDoc::context, _ScbDocContext::curStrokeAttr, and LOGPRINTF.

Referenced by notepad::CNotepadDoc::on_scribble_begin().

{
    LOGPRINTF("entry");
    return &doc->context.curStrokeAttr;
}

Here is the caller graph for this function:

ScbPagePtr erscribble_doc_get_page	(	ScbDocPtr	doc,
		const ScbPageIdPtr	id
	)

Definition at line 341 of file scbdoc.c.

References ERRORPRINTF, erscribble_doc_get_pages(), erscribble_page_copy_id(), erscribble_page_load(), erscribble_page_new(), erscribble_pages_add_page(), erscribble_pages_get_page(), _ScbPage::id, load_page_data(), LOGPRINTF, _ScbDoc::pages, and update_timestamp().

Referenced by test::ScribbleMgr::clear_page(), notepad::CNotepadDoc::clear_page(), test::ScribbleMgr::draw_scribble_page(), notepad::CNotepadDoc::draw_scribble_page(), test::ScribbleMgr::on_erase_begin(), notepad::CNotepadDoc::on_erase_begin(), test::ScribbleMgr::on_erase_move(), notepad::CNotepadDoc::on_scribble_begin(), and notepad::CNotepadDoc::save_page().

{
    LOGPRINTF("entry");
    ScbPagesPtr pages = erscribble_doc_get_pages(doc);
    if (NULL == pages)
    {
        ERRORPRINTF("Pages list is not constructed!");
        return NULL;
    }

    // search the page from cache
    ScbPagePtr page = erscribble_pages_get_page(pages, id);

    if (page != NULL)
    {
        // update the access time of current page
        update_timestamp(page);

        // load the BLOB data of current page if it exists
        // at this time, the BLOB data of oldest page would be deleted
        load_page_data(doc, page);
    }
    else
    {
#ifdef SAVE_TO_FILE
        // TEST try to load the page in local file
        page = erscribble_page_new();

        ScbStreamPtr stream = doc_load_page_file(id);
        if (stream != NULL)
        {
            erscribble_page_load(page, stream);
        }

        erscribble_page_copy_id(&page->id, id);
        // add the loaded page into cache
        erscribble_pages_add_page(&doc->pages, page);
#else
        // if the page is exist, create a new one
        page = erscribble_page_new();

        erscribble_page_copy_id(&page->id, id);

        erscribble_pages_add_page(pages, page);

        // update the access time of current page
        update_timestamp(page);
#endif
    }

    assert(page != NULL);

    LOGPRINTF("exit");
    return page;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbPagesPtr erscribble_doc_get_pages

(

ScbDocPtr

ptr

)

Definition at line 323 of file scbdoc.c.

References LOGPRINTF, and _ScbDoc::pages.

Referenced by erscribble_doc_add_page(), erscribble_doc_delete_page(), erscribble_doc_get_page(), erscribble_doc_insert_page(), and notepad::CNotepadDoc::get_num_pages().

{
    LOGPRINTF("entry");
    if (ptr)
    {
        return &ptr->pages;
    }
    return NULL;
}

Here is the caller graph for this function:

void erscribble_doc_init_context

(

ScbDocPtr

ptr

)

Definition at line 109 of file scbdoc.c.

References _ScbDocContext::appId, _ScbDoc::context, _ScbDocContext::curState, _ScbDocContext::curStrokeAttr, ERSCRIBBLE_DEF_CMD_ACT_SIZE, ERSCRIBBLE_DEF_SHAPE_LINE, ERSCRIBBLE_DEF_STROKE_LAYER, ERSCRIBBLE_DEF_ZOOM_FACTOR, ERSCRIBBLE_DEV_COLOR_BLACK, ERSCRIBBLE_TBS_SCRIBBLE, LOGPRINTF, _ScbDocContext::need_save_app, and _ScbDocContext::table.

Referenced by erscribble_doc_new_with_database(), and erscribble_doc_open_with_database().

{
    LOGPRINTF("entry");
    // TODO. Remove the old code and initialize the setting by new items(shape...)
    ptr->context.table = g_array_sized_new(FALSE, TRUE, 
            sizeof(ScbTBSItem), ERSCRIBBLE_DEF_CMD_ACT_SIZE);
    ptr->context.curState = ERSCRIBBLE_TBS_SCRIBBLE;
    ptr->context.curStrokeAttr.color     = ERSCRIBBLE_DEV_COLOR_BLACK;
    ptr->context.curStrokeAttr.layer     = ERSCRIBBLE_DEF_STROKE_LAYER;
    ptr->context.curStrokeAttr.points_number = 0;
    ptr->context.curStrokeAttr.shape_id  = ERSCRIBBLE_DEF_SHAPE_LINE;
    ptr->context.curStrokeAttr.zoom      = ERSCRIBBLE_DEF_ZOOM_FACTOR;

    ptr->context.appId = -1;

    // The application data is goint to be saved
    ptr->context.need_save_app = TRUE;
    LOGPRINTF("exit");
}

Here is the caller graph for this function:

gboolean erscribble_doc_insert_page	(	ScbDocPtr	doc,
		ScbPagePtr	page
	)

Definition at line 517 of file scbdoc.c.

References erscribble_doc_get_pages(), erscribble_doc_insert_page_impl(), and LOGPRINTF.

Referenced by notepad::CNotepadDoc::insert_page().

{
    LOGPRINTF("entry");
    ScbPagesPtr pages = erscribble_doc_get_pages(doc);
    if (NULL == pages) 
        return FALSE;
    LOGPRINTF("exit");
    return erscribble_doc_insert_page_impl(doc, pages, page);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean erscribble_doc_insert_page_impl	(	ScbDocPtr	doc,
		ScbPagesPtr	pages,
		ScbPagePtr	page
	)			[static]

Definition at line 473 of file scbdoc.c.

References ER_OK, erscribble_doc_save_page(), ERSCRIBBLE_RET_FALSE_IF, _ScbPageId::id, _ScbPage::id, load_page_data(), LOGPRINTF, _ScbPageId::position, and update_timestamp().

Referenced by erscribble_doc_insert_page().

{
    LOGPRINTF("entry");
    // Note: page is already created with erscribble_page_new
    ERSCRIBBLE_RET_FALSE_IF(NULL == doc || NULL == pages || NULL == page, "Invalid pages or page pointer!");
   
    int result = ER_OK;
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while (ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        if (cur_page && (cur_page->id.position >= page->id.position))
        {
            // move pages after inserted page
            // update the access time of current page
            update_timestamp(cur_page);

            // load the BLOB data of current page if it exists
            load_page_data(doc, cur_page);

            cur_page->id.position += 1;
            gint64 my_id = 0;
            my_id = g_ascii_strtoll(cur_page->id.id,  NULL, 10);
            my_id += 1;
            g_sprintf(cur_page->id.id, "%lld", my_id);
            result = erscribble_doc_save_page(doc, cur_page); 
            LOGPRINTF("incremented page id to %s(%d) res: %d", cur_page->id.id, cur_page->id.position, result);
            if (result != ER_OK) break;
        }
        ptr = g_list_next(ptr);
    }

    // add and save new page
    if (result == ER_OK )
    {
        pages->pages = g_list_append(pages->pages, page); 
        result = erscribble_doc_save_page(doc, page); 
    }

    LOGPRINTF("exit %d", result);
    return (gboolean)( result == ER_OK );
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbDocPtr erscribble_doc_new

(

const ScbPathPtr

target_doc_path

)

Definition at line 142 of file scbdoc.c.

References ermetadb_close(), ermetadb_local_open(), erscribble_doc_new_with_database(), LOGPRINTF, name, and path.

Referenced by test::ScribbleMgr::open().

{
    LOGPRINTF("entry");
    g_return_val_if_fail((target_doc_path && target_doc_path->document_path != '\0'), NULL);

    gchar *path = g_path_get_dirname(target_doc_path->document_path);
    erMetadb db = ermetadb_local_open(path, TRUE);
    g_free(path);
    if (db == NULL) return NULL;

    gchar *name = g_path_get_basename(target_doc_path->document_path);
    ScbDocPtr doc = erscribble_doc_new_with_database(name, db);
    g_free(name);
    if (doc == NULL) {
        ermetadb_close(db);
    }
    LOGPRINTF("exit");
    return doc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbDocPtr erscribble_doc_new_with_database	(	const char *	target_file_name,
		erMetadb	metadata_db
	)

Definition at line 163 of file scbdoc.c.

References _ScbDocVersion::company, _ScbScreen::dpi, ERRORPRINTF, ERSCRIBBLE_DEF_SCREEN_DPI, ERSCRIBBLE_DEF_SCREEN_UNITS, erscribble_doc_init_context(), ERSCRIBBLE_LIB_ORG, ERSCRIBBLE_LIB_VERSION_MAJOR, ERSCRIBBLE_LIB_VERSION_MINOR, erscribble_pages_new(), LOGPRINTF, _ScbVersion::major, _ScbDoc::metadata_db, _ScbVersion::minor, _ScbDoc::pages, _ScbDoc::path, _ScbDoc::screen, _ScbScreen::units, _ScbDoc::version, and _ScbDocVersion::version_number.

Referenced by notepad::CNotepadDoc::create(), and erscribble_doc_new().

{

    LOGPRINTF("entry");
    g_return_val_if_fail((target_file_name && *target_file_name), NULL);

    ScbDocPtr doc = g_new0(ScbDoc, 1);
    if (NULL == doc)
    {
        ERRORPRINTF("Not enough memory!");
        return NULL;
    }

    if (!erscribble_pages_new(&doc->pages))
    {
        g_free(doc);
        return NULL;
    }

    erscribble_doc_init_context(doc);

    // set version data
    doc->version.version_number.major = ERSCRIBBLE_LIB_VERSION_MAJOR;
    doc->version.version_number.minor = ERSCRIBBLE_LIB_VERSION_MINOR;
    doc->version.company = g_string_new(ERSCRIBBLE_LIB_ORG);

    // set screen data
    doc->screen.dpi = ERSCRIBBLE_DEF_SCREEN_DPI;
    doc->screen.units = g_string_new(ERSCRIBBLE_DEF_SCREEN_UNITS);

    // use the specified metadata db for the document
    doc->metadata_db = metadata_db;

    // set the target document path
    strcpy(doc->path.document_path, target_file_name);

    LOGPRINTF("exit");
    return doc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbDocPtr erscribble_doc_open

(

const ScbPathPtr

target_doc_path

)

Definition at line 248 of file scbdoc.c.

References ermetadb_close(), ermetadb_local_open(), erscribble_doc_open_with_database(), LOGPRINTF, name, and path.

Referenced by test::ScribbleMgr::open().

{
    LOGPRINTF("entry");
    g_return_val_if_fail((target_doc_path && target_doc_path->document_path != '\0'), NULL);

    gchar *path = g_path_get_dirname(target_doc_path->document_path);
    erMetadb db = ermetadb_local_open(path, FALSE);
    g_free(path);
    if (db == NULL) return NULL;
    
    gchar *name = g_path_get_basename(target_doc_path->document_path);
    ScbDocPtr doc = erscribble_doc_open_with_database(name, db);
    g_free(name);
    if (doc == NULL)
    {
        ermetadb_close(db);
    }
    LOGPRINTF("exit");
    return doc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbDocPtr erscribble_doc_open_with_database	(	const char *	target_file_name,
		erMetadb	metadata_db
	)

Definition at line 270 of file scbdoc.c.

References _ScbDoc::context, ERRORPRINTF, erscribble_doc_free(), erscribble_doc_init_context(), erscribble_pages_new(), load_application_data(), load_document_data(), LOGPRINTF, _ScbDoc::metadata_db, _ScbDocContext::need_save_app, _ScbDoc::pages, and _ScbDoc::path.

Referenced by erscribble_doc_open(), and notepad::CNotepadDoc::open().

{
    LOGPRINTF("entry");
    ScbDocPtr doc = NULL; 
    gboolean  ok;

    g_return_val_if_fail((target_file_name && *target_file_name), NULL);

    doc = g_new0(ScbDoc, 1);
    if (NULL == doc)
    {
        ERRORPRINTF("Not enough memory!");
        return NULL;
    }

    doc->metadata_db = metadata_db;

    // set the target document path
    strcpy(doc->path.document_path, target_file_name);

    ok = load_application_data(doc);
    if (ok)
    {
        // the application data has been saved in metadb
        // we don't have to save it again
        // TODO. if the application data is modified, set the flag to be TRUE
        doc->context.need_save_app = FALSE;

        ok = erscribble_pages_new(&doc->pages);
    }

    if (ok)
    {
        // load the document data from data base
        ok = (NULL != load_document_data(doc));
    }

    if (ok)
    {
        erscribble_doc_init_context(doc); 
    }

    if (!ok)
    {
        // free the document
        erscribble_doc_free(doc);
        doc = NULL;
    }
    LOGPRINTF("exit");
    return doc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean erscribble_doc_save_page	(	ScbDocPtr	doc,
		ScbPagePtr	page
	)

Definition at line 398 of file scbdoc.c.

References _ScbDoc::context, erscribble_create_stream(), erscribble_free_stream(), erscribble_page_get_length(), erscribble_page_set_minor_version_number(), erscribble_page_write_stream(), _ScbPageId::id, _ScbPage::id, LOGPRINTF, _ScbVersion::minor, _ScbDocContext::need_save_app, save_application_data(), save_page_data(), _ScbDoc::version, and _ScbDocVersion::version_number.

Referenced by erscribble_doc_delete_page_impl(), erscribble_doc_insert_page_impl(), test::ScribbleMgr::save(), and notepad::CNotepadDoc::save_page().

{
    LOGPRINTF("entry");
    if (doc->context.need_save_app)
    {
        gboolean ok = save_application_data(doc);
        if (!ok)
        {
            LOGPRINTF("save_application_data NOK");
            return FALSE;
        }
        doc->context.need_save_app = FALSE;
    }

    int page_len = erscribble_page_get_length(page);
    LOGPRINTF("page_len %d page %s", page_len, page->id.id);
    // need free the stream buffer?
    gboolean need_free_stream_buffer = TRUE;

    // create a memory stream for writing, length = page length + 128
    ScbStreamPtr stream = erscribble_create_stream(page_len + 128);

    if (NULL == stream)
    {
        LOGPRINTF("creation of stream failed");
        return FALSE;
    }

    // set the minor version number of the library
    erscribble_page_set_minor_version_number(page, doc->version.version_number.minor);
    LOGPRINTF("minor version number %d", doc->version.version_number.minor);
    
    // write the page data into stream
    gboolean ret = erscribble_page_write_stream(page, stream);
    if (ret)
    {
#ifdef SAVE_TO_FILE
        ret = doc_save_page_file(&page->id, stream);
#else
        ret = save_page_data(doc, page, stream, &need_free_stream_buffer);
#endif
    }

    // Free the stream by the results of saving operation
    if (!need_free_stream_buffer)
    {
        // if the saving operation returns successfully, it means
        // that the BLOB has been written into database. The ownership of
        // stream's buffer has been transfered to metadata lib.
        // Scribble lib MUST NOT free the memory any more.
        erscribble_free_stream(stream, FALSE);
    }
    else
    {
        // if saving fails, scribble lib considers the ownership has not
        // been transfered to metadata lib. So the memory should be released here.
        // TODO. HOWEVER, a problem is that the saveing may fail no matter whether
        // taking the ownership of BLOB or not. SHOULD BE FIXED.
        erscribble_free_stream(stream, TRUE);
    }

    LOGPRINTF("exit %d", ret);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean erscribble_state_is_erase

(

ScbDocPtr

doc

)

Definition at line 629 of file scbdoc.c.

References erscribble_doc_get_current_state(), and ERSCRIBBLE_TBS_ERASE.

{
    return ERSCRIBBLE_TBS_ERASE == erscribble_doc_get_current_state(doc);
}

Here is the call graph for this function:

gboolean erscribble_state_is_scribble

(

ScbDocPtr

doc

)

Definition at line 623 of file scbdoc.c.

References erscribble_doc_get_current_state(), and ERSCRIBBLE_TBS_SCRIBBLE.

{
    return ERSCRIBBLE_TBS_SCRIBBLE == erscribble_doc_get_current_state(doc);
}

Here is the call graph for this function:

static gboolean load_application_data

(

ScbDocPtr

doc

)

[static]

Definition at line 674 of file scbdoc.c.

References _ScbDocVersion::company, _ScbScreen::dpi, ER_OK, ermetadb_local_get_application_data(), ERRORPRINTF, ERSCRIBBLE_SCREEN_DPI, ERSCRIBBLE_SCREEN_UNITS, ERSCRIBBLE_VERSION_COMPANY, ERSCRIBBLE_VERSION_MAJOR, ERSCRIBBLE_VERSION_MINOR, LOGPRINTF, _ScbVersion::major, _ScbDoc::metadata_db, metadata_table_add_column(), metadata_table_find_column(), metadata_table_free, metadata_table_get_cell(), metadata_table_new(), _ScbVersion::minor, _ScbDoc::path, _ScbDoc::screen, _ScbScreen::units, metadata_cell::v_text, metadata_cell::value, _ScbDoc::version, and _ScbDocVersion::version_number.

Referenced by erscribble_doc_open_with_database().

{
    LOGPRINTF("entry");
    if (doc->metadata_db == NULL)
    {
        ERRORPRINTF("Document is not ready");
        return FALSE;
    }

    // get document basic information from application_data table

    // 1. create an empty table with required keys
    metadata_table *name_table = metadata_table_new();

    if (name_table == NULL)
    {
        return FALSE;
    }

    // 2. set new column of the table
    metadata_table_add_column(name_table, ERSCRIBBLE_VERSION_MAJOR);
    metadata_table_add_column(name_table, ERSCRIBBLE_VERSION_MINOR);
    metadata_table_add_column(name_table, ERSCRIBBLE_VERSION_COMPANY);
    metadata_table_add_column(name_table, ERSCRIBBLE_SCREEN_DPI);
    metadata_table_add_column(name_table, ERSCRIBBLE_SCREEN_UNITS);

    // 3. get the results
    metadata_table *results_table = NULL;
    int ret = ermetadb_local_get_application_data(doc->metadata_db
            , doc->path.document_path
            , name_table
            , &results_table);
    metadata_table_free(name_table);

    if (results_table == NULL)
    {
        return FALSE;
    }

    if (ret == ER_OK)
    {
        const metadata_cell *cell = NULL;
        // get major version number
        int index = metadata_table_find_column(results_table, ERSCRIBBLE_VERSION_MAJOR);
        if (index >= 0)
        {
            cell = metadata_table_get_cell(results_table, index);
            if (cell != NULL)
            {
                sscanf(cell->value.v_text->str, "%hd", &doc->version.version_number.major);

                cell = NULL;
            }
        }

        //  get minor version number
        index = metadata_table_find_column(results_table, ERSCRIBBLE_VERSION_MINOR);
        if (index >= 0)
        {
            cell = metadata_table_get_cell(results_table, index);
            if (cell != NULL)
            {
                sscanf(cell->value.v_text->str, "%hd", &doc->version.version_number.minor);

                cell = NULL;
            }
        }

        // get company name
        index = metadata_table_find_column(results_table, ERSCRIBBLE_VERSION_COMPANY);
        if (index >= 0)
        {
            cell = metadata_table_get_cell(results_table, index);
            if (cell != NULL)
            {
                doc->version.company = g_string_new(cell->value.v_text->str);
                cell = NULL;
            }
        }

        // get screen dpi
        index = metadata_table_find_column(results_table, ERSCRIBBLE_SCREEN_DPI);
        if (index >= 0)
        {
            cell = metadata_table_get_cell(results_table, index);
            if (cell != NULL)
            {
                sscanf(cell->value.v_text->str, "%d", &doc->screen.dpi);

                cell = NULL;
            }
        }

        // get screen units
        index = metadata_table_find_column(results_table, ERSCRIBBLE_SCREEN_UNITS);
        if (index >= 0)
        {
            cell = metadata_table_get_cell(results_table, index);
            if (cell != NULL)
            {
                doc->screen.units = g_string_new(cell->value.v_text->str);
                cell = NULL;
            }
        }
    }

    // free the results table
    metadata_table_free(results_table);

    LOGPRINTF("exit");
    return (ret == ER_OK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static metadata_table * load_document_data

(

const ScbDocPtr

doc

)

[static]

Definition at line 940 of file scbdoc.c.

References ER_OK, ermetadb_local_select_annotations(), ERRORPRINTF, ERSCRIBBLE_ANNOTATION_TYPE, load_pages_basic_data(), LOGPRINTF, _ScbDoc::metadata_db, metadata_table_free, and _ScbDoc::path.

Referenced by erscribble_doc_delete_page_impl(), and erscribble_doc_open_with_database().

{
   LOGPRINTF("entry");
    if (doc->metadata_db == NULL)
    {
        ERRORPRINTF("Document is not ready");
        return NULL;
    }

    metadata_table *results = NULL;
    int ret = ermetadb_local_select_annotations(
                                    doc->metadata_db,
                                    doc->path.document_path,
                                    ERSCRIBBLE_ANNOTATION_TYPE,
                                    NULL,
                                    -1,
                                    -1,
                                    &results);
    if (ret == ER_OK)
    {
        // load all of the pages data from results table
        load_pages_basic_data(doc, results);
    }
    else
    {
        metadata_table_free(results);
        results = NULL;
    }

    LOGPRINTF("exit");
    return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean load_page_data	(	ScbDocPtr	doc,
		ScbPagePtr	page
	)			[static]

Definition at line 974 of file scbdoc.c.

References _ScbPageId::annotation_id, ER_OK, ermetadb_local_get_annotations(), ERRORPRINTF, erscribble_create_stream(), erscribble_free_stream(), erscribble_page_clear_strokes(), erscribble_page_get_stroke_count(), erscribble_page_load(), erscribble_reset_offset(), erscribble_write_stream(), _ScbPageId::id, _ScbPage::id, _ScbPage::is_blob_loaded, LOGPRINTF, METADATA_BLOB, _ScbDoc::metadata_db, metadata_table_cell_index, metadata_table_find_column(), metadata_table_get_cell(), METADB_DATA, metadata_table::n_rows, remove_oldest_page_scribbles(), metadata_cell::type, metadata_cell::v_blob, and metadata_cell::value.

Referenced by erscribble_doc_delete_page_impl(), erscribble_doc_get_page(), and erscribble_doc_insert_page_impl().

{
    LOGPRINTF("entry");
    if (doc->metadata_db == NULL)
    {
        ERRORPRINTF("Document is not ready");
        return FALSE;
    }
    
    if (page->is_blob_loaded)
    {
        // the blob of this page has been loaded, DO NOT
        // access the database again
        return FALSE;
    }

    if (erscribble_page_get_stroke_count(page) > 0)
    {
        // if the data of strokes exists, return true
        return FALSE;
    }

    if (page->id.annotation_id < 0)
    {
        // the annotation id is invalid, do not query metadb
        return FALSE;
    }

    // Set is_blob_loaded to be TRUE no matter it can be loaded or not,
    // to improve the performance
    page->is_blob_loaded = TRUE;

    // Load the BLOB from metadb
    // TODO. Load the BLOB of adjacent pages?
    gint64 anno_list[1];
    anno_list[0] = page->id.annotation_id;

    metadata_table *value = NULL;
    int ret = ermetadb_local_get_annotations(doc->metadata_db,
        &anno_list[0], 1, &value);

    if (ret != ER_OK || value == NULL)
    {
        ERRORPRINTF("Cannot retrieve BLOB of page %s", page->id.id);
        return FALSE;
    }

    // Should not retrieve more than one rows of data
    guint idx = 0;
    for (; idx < value->n_rows; ++idx)
    {
        int cell_idx = metadata_table_find_column(value, METADB_DATA);
        const metadata_cell *cell =
            metadata_table_get_cell(value, metadata_table_cell_index(value, idx, cell_idx));
        assert(cell->type == METADATA_BLOB);
        gsize length = cell->value.v_blob.len;

        // create a stream to import the BLOB
        // TODO. maybe we can use only one stream instance
        ScbStreamPtr stream = erscribble_create_stream(length);
        if (stream != NULL)
        {
            // read the BLOB
            if (erscribble_write_stream(stream, (void*)cell->value.v_blob.data, length))
            {
                erscribble_reset_offset(stream);
                // the BLOB is read out successfully
                // try to load the page
                if (!erscribble_page_load(page, stream))
                {
                    ERRORPRINTF("Error happens when loading page:%s",
                        page->id.id);
                    // clear the strokes if they exist
                    erscribble_page_clear_strokes(page);
                    return FALSE;
                }

                // remove the oldest page
                remove_oldest_page_scribbles(doc);
            }

            erscribble_free_stream(stream, TRUE);
            stream = NULL;
        }
        else
        {
            ERRORPRINTF("Not enough memory to create a new stream");
            return FALSE;
        }
    }

    LOGPRINTF("exit");
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void load_pages_basic_data	(	const ScbDocPtr	doc,
		const metadata_table *	table
	)			[static]

Definition at line 880 of file scbdoc.c.

References metadata_table::cell_data, erscribble_page_free(), erscribble_page_new(), erscribble_page_set_id(), erscribble_pages_add_page(), _ScbPage::id, LOGPRINTF, METADATA_INT64, metadata_table_cell_index, metadata_table_find_column(), metadata_table_get_cell(), METADATA_TEXT, METADB_ANNOTATION_ID, METADB_FILE_POSITION, METADB_START_ANCHOR, metadata_table::n_rows, _ScbDoc::pages, metadata_cell::type, metadata_cell::v_int64, metadata_cell::v_text, and metadata_cell::value.

Referenced by load_document_data().

{
   LOGPRINTF("entry");
    // The page instance would be constructed in this function
    // All of the basic data of a page would be set, except the BLOB

    if (table == NULL || table->cell_data->len <= 0)
    {
        LOGPRINTF("Empty table of scribble");
        return;
    }

    gint64 position = 0;
    gint64 anno_id = 0;
    guint  idx = 0;
    for (; idx < table->n_rows; ++idx)
    {
        // read the file position
        int cell_idx = metadata_table_find_column(table, METADB_FILE_POSITION);
        assert(cell_idx >= 0);
        const metadata_cell* cell = metadata_table_get_cell(table,
            metadata_table_cell_index(table, idx, cell_idx));
        assert(cell->type == METADATA_INT64);
        position = cell->value.v_int64;

        // read the annotation id
        cell_idx = metadata_table_find_column(table, METADB_ANNOTATION_ID);
        assert(cell_idx >= 0);
        cell = metadata_table_get_cell(table,
            metadata_table_cell_index(table, idx, cell_idx));
        assert(cell->type == METADATA_INT64);
        anno_id = cell->value.v_int64;

        // read the start anchor
        cell_idx = metadata_table_find_column(table, METADB_START_ANCHOR);
        assert(cell_idx >= 0);
        cell = metadata_table_get_cell(table,
            metadata_table_cell_index(table, idx, cell_idx));
        assert(cell->type == METADATA_TEXT);
        // create a new page with the start anchor and related information
        ScbPagePtr page = erscribble_page_new();
        if (page != NULL)
        {
            // add the loaded page into pages list
            if (!erscribble_pages_add_page(&doc->pages, page))
            {
                erscribble_page_free(page);
            }
            else
            {
                // set page id
                erscribble_page_set_id(&page->id, position, cell->value.v_text->str, anno_id);
            }
        }
    }

    LOGPRINTF("exit");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void remove_oldest_page_scribbles

(

ScbDocPtr

doc

)

[static]

Definition at line 662 of file scbdoc.c.

References LOGPRINTF, _ScbDoc::pages, and remove_oldest_page_data().

Referenced by load_page_data(), and save_page_data().

{
    LOGPRINTF("entry");
    gboolean ret_clear = FALSE;
    while (!ret_clear)
    {
        ret_clear = remove_oldest_page_data(&doc->pages);
    }
    LOGPRINTF("exit");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean save_application_data

(

ScbDocPtr

doc

)

[static]

Definition at line 788 of file scbdoc.c.

References _ScbDocVersion::company, _ScbScreen::dpi, ER_OK, ermetadb_local_set_application_data(), ERRORPRINTF, ERSCRIBBLE_SCREEN_DPI, ERSCRIBBLE_SCREEN_UNITS, ERSCRIBBLE_VERSION_COMPANY, ERSCRIBBLE_VERSION_MAJOR, ERSCRIBBLE_VERSION_MINOR, LOGPRINTF, _ScbVersion::major, _ScbDoc::metadata_db, metadata_table_add_column(), metadata_table_find_column(), metadata_table_free, metadata_table_new(), metadata_table_set_text(), _ScbVersion::minor, _ScbDoc::path, _ScbDoc::screen, _ScbScreen::units, _ScbDoc::version, and _ScbDocVersion::version_number.

Referenced by erscribble_doc_save_page().

{
    LOGPRINTF("entry");
    if (doc->metadata_db == NULL)
    {
        ERRORPRINTF("Document is not ready");
        return FALSE;
    }
    
    // This function MUST be called when there is scribble data in current document

    // save document basic information into application_data table
    // 1. create an empty table with required keys
    metadata_table *value_table = metadata_table_new();

    if (value_table == NULL)
    {
        return FALSE;
    }

    // 2. set new column of the table
    metadata_table_add_column(value_table, ERSCRIBBLE_VERSION_MAJOR);
    metadata_table_add_column(value_table, ERSCRIBBLE_VERSION_MINOR);
    metadata_table_add_column(value_table, ERSCRIBBLE_VERSION_COMPANY);
    metadata_table_add_column(value_table, ERSCRIBBLE_SCREEN_DPI);
    metadata_table_add_column(value_table, ERSCRIBBLE_SCREEN_UNITS);

    // 3. set the value of each item
    GString *value_str = g_string_new("");

    int index = metadata_table_find_column(value_table, ERSCRIBBLE_VERSION_MAJOR);
    if (index >= 0)
    {
        g_string_printf(value_str, "%d", doc->version.version_number.major);
        if (metadata_table_set_text(value_table, index, value_str->str)
            != ER_OK)
        {
            ERRORPRINTF("Cannot write major version number");
        }
    }

    index = metadata_table_find_column(value_table, ERSCRIBBLE_VERSION_MINOR);
    if (index >= 0)
    {
        g_string_printf(value_str, "%d", doc->version.version_number.minor);
        if (metadata_table_set_text(value_table, index, value_str->str)
            != ER_OK)
        {
            ERRORPRINTF("Cannot write minor version number");
        }
    }

    index = metadata_table_find_column(value_table, ERSCRIBBLE_VERSION_COMPANY);
    if (index >= 0)
    {
        if (metadata_table_set_text(value_table, index, doc->version.company->str)
            != ER_OK)
        {
            ERRORPRINTF("Cannot write company name");
        }
    }

    index = metadata_table_find_column(value_table, ERSCRIBBLE_SCREEN_DPI);
    if (index >= 0)
    {
        g_string_printf(value_str, "%d", doc->screen.dpi);
        if (metadata_table_set_text(value_table, index, value_str->str)
            != ER_OK)
        {
            ERRORPRINTF("Cannot write DPI");
        }
    }

    index = metadata_table_find_column(value_table, ERSCRIBBLE_SCREEN_UNITS);
    if (index >= 0)
    {
        if (metadata_table_set_text(value_table, index, doc->screen.units->str)
            != ER_OK)
        {
            ERRORPRINTF("Cannot write screen units");
        }
    }

    // write to database
    int ret = ermetadb_local_set_application_data(doc->metadata_db, doc->path.document_path, value_table);
    metadata_table_free(value_table);

    LOGPRINTF("exit");
    return ret == ER_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean save_page_data	(	const ScbDocPtr	doc,
		const ScbPagePtr	page,
		const ScbStreamPtr	stream,
		gboolean *	need_free_stream
	)			[static]

Definition at line 1131 of file scbdoc.c.

References _ScbPageId::annotation_id, ER_FAIL, ER_OK, ermetadb_local_create_annotation(), ermetadb_local_remove_annotation(), ermetadb_local_set_annotation(), ERRORPRINTF, ERSCRIBBLE_ANNOTATION_TYPE, erscribble_page_get_stroke_count(), g_enable_autodelete, _ScbPageId::id, _ScbPage::id, _ScbPage::is_blob_loaded, LOGPRINTF, _ScbDoc::metadata_db, _ScbDoc::path, _ScbPageId::position, and remove_oldest_page_scribbles().

Referenced by erscribble_doc_save_page().

{
    LOGPRINTF("entry");
    if (doc == NULL || page == NULL || stream == NULL)
    {
        return FALSE;
    }

    if (doc->metadata_db == NULL)
    {
        ERRORPRINTF("document is not ready");
        return FALSE;
    }

    int ret = ER_FAIL;
    *need_free_stream = TRUE;

    if (page->id.annotation_id < 0)
    {
        // the page has not been stored in data base before
        // create a new row if the number of strokes is not 0
        //if (erscribble_page_get_stroke_count(page) > 0)
        gboolean do_create = FALSE;
        if (g_enable_autodelete)
            do_create = erscribble_page_get_stroke_count(page) >  0 ? TRUE : FALSE;
        else 
            do_create = erscribble_page_get_stroke_count(page) >= 0 ? TRUE : FALSE;
            
        if (do_create)
        {
            ret = ermetadb_local_create_annotation (doc->metadata_db,
                                              doc->path.document_path,
                                              &page->id.annotation_id,
                                              ERSCRIBBLE_ANNOTATION_TYPE,
                                              "",
                                              page->id.position,
                                              NULL,      // title is null
                                              page->id.id,
                                              NULL,      // end anchor is null
                                              (gchar*)stream->buffer,
                                              stream->offset);

            if (ret == ER_OK)
            {
                *need_free_stream = FALSE;
            }
        }
    }
    else
    {
        // the page has been stored in data base
        // update it
        // if there is no any strokes in the page, we should remove the record in data base
        //if (erscribble_page_get_stroke_count(page) > 0)
        gboolean do_update = FALSE;
        if (g_enable_autodelete)
            do_update = erscribble_page_get_stroke_count(page) >  0 ? TRUE : FALSE;
        else 
            do_update = erscribble_page_get_stroke_count(page) >= 0 ? TRUE : FALSE;

        if (do_update)
        {
            ret = ermetadb_local_set_annotation(doc->metadata_db,
                    page->id.annotation_id,
                    ERSCRIBBLE_ANNOTATION_TYPE,
                    "",
                    page->id.position,
                    NULL,        // title is null
                    page->id.id,
                    NULL,        // end anchor is null
                    (gchar*)stream->buffer,
                    stream->offset);
            if (ret == ER_OK)
            {
                *need_free_stream = FALSE;
            }
        }
        else
        {
            // otherwise update the record
            ret = ermetadb_local_remove_annotation(doc->metadata_db,
                                             page->id.annotation_id);
            // set annotation id to be invalid
            page->id.annotation_id = -1;
        }
    }

    if (page->id.annotation_id >= 0)
    {
        // Set is_blob_loaded to be TRUE, so that we need not laod the
        // BLOB from metadb when getting this page.
        page->is_blob_loaded = TRUE;

        // remove the oldest page if necessary
        remove_oldest_page_scribbles(doc);
    }

    LOGPRINTF("exit");
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_timestamp

(

ScbPagePtr

page

)

[static]

Definition at line 648 of file scbdoc.c.

References _ScbPage::timestamp.

Referenced by erscribble_doc_delete_page_impl(), erscribble_doc_get_page(), and erscribble_doc_insert_page_impl().

{
    int now;
#ifdef WIN32
    now = GetTickCount();
#else
    struct timeval cur_time_struct;
    gettimeofday(&cur_time_struct, 0);
    now = cur_time_struct.tv_sec;
#endif
    page->timestamp = now;
}

Here is the caller graph for this function:

---

Variable Documentation

gboolean g_enable_autodelete = TRUE [static]

Definition at line 78 of file scbdoc.c.

Referenced by erscribble_doc_disable_autodelete(), and save_page_data().