scbdoc.c

Go to the documentation of this file.

/*
 * File Name: scbdoc.c
 */

/*
 * This file is part of liberscribble.
 *
 * liberscribble is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * liberscribble is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

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


#define _GNU_SOURCE

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <fcntl.h>
#include <string.h>
#include <assert.h>

#ifdef WIN32
#include <windows.h>
#else
#include <sys/time.h>
#endif

#include <glib.h>
#include <glib/gprintf.h>

// ereader include files, between < >

// local include files, between " "
#include "scbdoc.h"
#include "scblog.h"
#include "scbpage.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

#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"


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

// g_enable_autodelete: TRUE  -> (default) automaticaly delete pages with stroke count 0 
// g_enable_autodelete: FALSE -> do not automaticaly delete pages with stroke count 0 
static gboolean g_enable_autodelete = TRUE;

//============================================================================
// Local Function Definitions
//============================================================================

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

#ifdef SAVE_TO_FILE
static ScbStreamPtr doc_load_page_file                  (const ScbPageIdPtr id);
static gboolean doc_save_page_file                      (const ScbPageIdPtr id, 
                                                         ScbStreamPtr stream);
#else
static gboolean save_page_data                          (const ScbDocPtr doc, 
                                                         const ScbPagePtr page, 
                                                         const ScbStreamPtr stream,
                                                         gboolean *need_free_stream);
#endif

//============================================================================
// Functions Implementation
//============================================================================

void erscribble_doc_init_context(ScbDocPtr ptr)
{
    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");
}


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


ScbDocPtr erscribble_doc_new(const ScbPathPtr target_doc_path)
{
    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;
}


ScbDocPtr erscribble_doc_new_with_database(const char *target_file_name, erMetadb metadata_db)
{

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


void erscribble_doc_free(ScbDocPtr ptr)
{
    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");
}


void erscribble_doc_free_without_database(ScbDocPtr ptr)
{
    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");
}


ScbDocPtr erscribble_doc_open(const ScbPathPtr target_doc_path)
{
    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;
}


ScbDocPtr erscribble_doc_open_with_database(const char *target_file_name, erMetadb metadata_db)
{
    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;
}


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


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


ScbPagePtr erscribble_doc_get_page(ScbDocPtr doc, const ScbPageIdPtr id)
{
    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;
}


gboolean erscribble_doc_save_page(ScbDocPtr doc, ScbPagePtr 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;
}


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

static gboolean erscribble_doc_insert_page_impl(ScbDocPtr doc, ScbPagesPtr pages, ScbPagePtr 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 );
}

gboolean erscribble_doc_insert_page(ScbDocPtr doc, ScbPagePtr 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);
}

static gboolean erscribble_doc_delete_page_impl(ScbDocPtr doc, ScbPagesPtr pages, ScbPageIdPtr pid)
{
    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 );
}


gboolean erscribble_doc_delete_page(ScbDocPtr doc, ScbPageIdPtr pid)
{
    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);
}


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


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


gboolean erscribble_state_is_scribble(ScbDocPtr doc)
{
    return ERSCRIBBLE_TBS_SCRIBBLE == erscribble_doc_get_current_state(doc);
}


gboolean erscribble_state_is_erase(ScbDocPtr doc)
{
    return ERSCRIBBLE_TBS_ERASE == erscribble_doc_get_current_state(doc);
}


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


//============================================================================
// Local Functions Implementation
//============================================================================

static void update_timestamp(ScbPagePtr page)
{
    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;
}


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


static gboolean load_application_data(ScbDocPtr doc)
{
    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);
}


static gboolean save_application_data(ScbDocPtr doc)
{
    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;
}


static void load_pages_basic_data(const ScbDocPtr doc, const metadata_table *table)
{
   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");
}


static metadata_table *load_document_data(const ScbDocPtr doc)
{
   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;
}


static gboolean load_page_data(ScbDocPtr doc, ScbPagePtr page)
{
    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;
}


#ifdef SAVE_TO_FILE

static ScbStreamPtr doc_load_page_file(const ScbPageIdPtr id)
{
    LOGPRINTF("entry");
    FILE *f_read = fopen(id->id, "rb");
    
    if (NULL == f_read)
    {
        // the file does not exist
        return NULL;
    }
    
    // obtain file size:
    fseek(f_read , 0 , SEEK_END);
    long size = ftell(f_read);

    ScbStreamPtr stream = erscribble_create_stream(size);
    if (NULL == stream)
    {
        fclose(f_read);
        return NULL;
    }

    fseek(f_read, 0, SEEK_SET);
    long ret = fread(stream->buffer, 1, size, f_read);
    if (ret != size)
    {
        erscribble_free_stream(stream, TRUE);
        stream = NULL;
    }

    fclose(f_read);
    LOGPRINTF("exit");
    return stream;
}


static gboolean doc_save_page_file(const ScbPageIdPtr id, ScbStreamPtr stream)
{
    LOGPRINTF("entry");
    FILE *f_write = fopen(id->id, "wb");
    if (NULL == f_write)
    {
        // the file does not exist
        return FALSE;
    }

    if (fwrite(stream->buffer, 1, stream->offset, f_write) != stream->offset)
    {
        return FALSE;
    }

    fclose(f_write);

    LOGPRINTF("exit");
    return TRUE;
}

#else

static gboolean save_page_data(const ScbDocPtr doc, 
                               const ScbPagePtr page, 
                               const ScbStreamPtr stream,
                               gboolean *need_free_stream)
{
    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;
}

void erscribble_doc_disable_autodelete(gboolean do_disable)
{
    g_enable_autodelete = !do_disable ;  // reverse semantics
}



#endif