scbpages.c

Go to the documentation of this file.

/*
 * File Name: scbpages.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 <string.h>
#include <glib.h>

// ereader include files, between < >

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

#define UNUSED(x) (void)(x)


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


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

#define MAX_TIMESTAMP         0x7FFFFFFF
#define CACHE_PAGES_NUMBER    20


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


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

static void _page_release       (gpointer data, gpointer userdata);
static void _page_dump          (gpointer data, gpointer userdata);


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

// Remove the oldest page if enough pages are cached
// Return TRUE means it is not necessary to remove oldest page data until
// a new page is loaded; otherwise return FALSE.
gboolean remove_oldest_page_data(ScbPagesPtr pages)
{
    // Get the page with oldest timestamp, and calculate the sum
    ScbPagePtr oldest_page = NULL;
    int oldest_timestamp = MAX_TIMESTAMP;
    int loaded_pages_number = 0;
    GList* ptr = g_list_first(pages->pages);

    while(ptr)
    {
        ScbPagePtr cur_page = (ScbPagePtr)ptr->data;
        if (cur_page != NULL && (erscribble_strokes_get_count(&cur_page->strokes) > 0))
        {
            loaded_pages_number++;
            if (cur_page->timestamp < oldest_timestamp)
            {
                oldest_timestamp = cur_page->timestamp;
                oldest_page = cur_page;
            }
        }
        ptr = g_list_next(ptr);
    }

    if (loaded_pages_number <= CACHE_PAGES_NUMBER)
    {
        return TRUE;
    }

    // clear strokes of the oldest page
    
    // TODO. Handle the situation that the number of loaded pages
    // are much more than the cached pages number
    erscribble_page_clear_strokes(oldest_page);
    oldest_page->is_blob_loaded = FALSE;
    loaded_pages_number--;

    if (loaded_pages_number > CACHE_PAGES_NUMBER)
    {
        return FALSE;
    }

    return TRUE;
}


gboolean erscribble_pages_new(ScbPagesPtr ptr)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == ptr, "Invalid pointer!");

    ptr->pages = NULL;
    return TRUE;
}


void erscribble_pages_free(ScbPagesPtr ptr)
{
    if (ptr)
    {
        // release all stroke
        g_list_foreach(ptr->pages, _page_release, NULL);

        // now the pointers are wild pointers
        g_list_free(ptr->pages);
        ptr->pages = NULL;
    }
}


// it will check whether or not the page exist. do nothing if exist
// by id and pointer
gboolean erscribble_pages_add_page(ScbPagesPtr pages, ScbPagePtr page)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == pages || NULL == page, "Invalid pages or page pointer!");
    
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while(ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        // if (cur_page && 0 == strncmp(cur_page->id.id, page->id.id, ERSCRIBBLE_MAX_PAGEID_LEN))
        if (cur_page && (cur_page->id.position == page->id.position))
        {
            // The querying page already exist, quit, it's ok,
            // The new page should be removed.
            // WARNPRINTF("Duplicated page id %s!", page->id.id);
            return FALSE;
        }
        ptr = g_list_next(ptr);
    }

    pages->pages = g_list_append(pages->pages, page);
    return TRUE;
}


ScbPagePtr erscribble_pages_detach_page(ScbPagesPtr pages, ScbPageIdPtr id)
{
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while(ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        // if (cur_page && 0 == strncmp(cur_page->id.id, id->id, ERSCRIBBLE_MAX_PAGEID_LEN))
        if (cur_page && (cur_page->id.position == id->position))
        {
            // ok, hit. notice.......
            pages->pages = g_list_remove(pages->pages, cur_page);
            return cur_page;
        }
        ptr = g_list_next(ptr);
    }
    return NULL;
}


void erscribble_pages_remove_page(ScbPagesPtr pages, ScbPageIdPtr id)
{
    ERSCRIBBLE_RET_IF(NULL == pages || NULL == id, "Invalid pointer!");
    
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while(ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        // if (cur_page && 0 == strncmp(cur_page->id.id, id->id, ERSCRIBBLE_MAX_PAGEID_LEN))
        if (cur_page && (cur_page->id.position == id->position))
        {
            // ok, hit. notice.......
            erscribble_page_free(cur_page);
            pages->pages = g_list_remove(pages->pages, ptr->data);
            return;
        }
        ptr = g_list_next(ptr);
    }
}


int erscribble_pages_get_count(ScbPagesPtr pages)
{
    ERSCRIBBLE_RET_INT_IF(NULL == pages, ERSCRIBBLE_INVALID_COUNT, "Invalid pages pointer!");
    return g_list_length(pages->pages);
}


ScbPagePtr erscribble_pages_get_page(ScbPagesPtr pages, ScbPageIdPtr id)
{
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while(ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        // if (cur_page && 0 == strncmp(cur_page->id.id, id->id, ERSCRIBBLE_MAX_PAGEID_LEN))
        if (cur_page && (cur_page->id.position == id->position))
        {
            // ok, hit. notice.......
           return cur_page;
        }
        ptr = g_list_next(ptr);
    }
    return NULL;
}


gboolean erscribble_pages_change_page_id(ScbPagesPtr pages, ScbPageIdPtr oldId, 
                                         ScbPageIdPtr newId)
{
    // change page id, make sure the id does not conflict. we do not check here
    
    ScbPagePtr cur_page  = NULL;
    GList* ptr = g_list_first(pages->pages);
    while(ptr)
    {
        cur_page = (ScbPagePtr)ptr->data;
        // if (cur_page && 0 == strncmp(cur_page->id.id, oldId->id, ERSCRIBBLE_MAX_PAGEID_LEN))
        if (cur_page && (cur_page->id.position == oldId->position))
        {
            strncpy(cur_page->id.id, newId->id, ERSCRIBBLE_MAX_PAGEID_LEN);
            cur_page->id.position = newId->position;
            cur_page->id.annotation_id = newId->annotation_id;

            return TRUE;
        }
        ptr = g_list_next(ptr);
    }
    return FALSE;
}


void erscribble_pages_dump(ScbPagesPtr pages)

{
    ERSCRIBBLE_RET_IF(NULL == pages, "NULL pointer!");
    g_list_foreach(pages->pages, _page_dump, 0);
}


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

static void _page_release(gpointer data, gpointer userdata)
{
    UNUSED(userdata);
    if (data)
    {
        erscribble_page_free((ScbPagePtr)data);
    }
}

static void _page_dump(gpointer data, gpointer userdata)
{
    UNUSED(userdata);
    if (data)
    {
        erscribble_page_dump((ScbPagePtr)data);
    }
}