scbpage.c

Go to the documentation of this file.

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

// ereader include files, between < >

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


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


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


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


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


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

void erscribble_page_set_id(ScbPageIdPtr ptr, const int position, const char *anchor, const int anno_id)
{
    if (ptr)
    {
        strncpy(ptr->id, anchor, ERSCRIBBLE_MAX_PAGEID_LEN);
        ptr->position = position;
        // the annotation id should be set to invalid
        // and then it would be set by query database
        ptr->annotation_id = anno_id;
    }
}


void erscribble_page_copy_id(ScbPageIdPtr dst, const ScbPageIdPtr src)
{
    if (dst && src)
    {
        strncpy(dst->id, src->id, ERSCRIBBLE_MAX_PAGEID_LEN);
        dst->position = src->position;
        dst->annotation_id = src->annotation_id;
    }
}


void erscribble_page_reset_id(ScbPageIdPtr ptr)
{
    if (ptr)
    {
        memset(ptr->id, 0, ERSCRIBBLE_MAX_PAGEID_LEN);
        ptr->position = -1;
        ptr->annotation_id = -1;
    }
}


ScbPagePtr erscribble_page_new()
{
    ScbPagePtr ptr = g_new0(ScbPage, 1);
    if (NULL == ptr)
    {
        // not enough memory, fatal error
        ERRORPRINTF("Not enough memory for page!");
        return NULL;
    }

    // init values
    if (!erscribble_strokes_new(&ptr->strokes))
    {
        g_free(ptr);
        return NULL;
    }

    ptr->attributes.area.left      = ERSCRIBBLE_DEF_PAGE_LEFT;
    ptr->attributes.area.right     = ERSCRIBBLE_DEF_PAGE_RIGHT;
    ptr->attributes.area.top       = ERSCRIBBLE_DEF_PAGE_TOP;
    ptr->attributes.area.bottom    = ERSCRIBBLE_DEF_PAGE_BOTTOM;

    // initialize the position and annotation id to be -1
    ptr->id.position      = -1;
    ptr->id.annotation_id = -1;

    // set the flag is_blob_loaded to be false
    ptr->is_blob_loaded = FALSE;

    return ptr;
}

void erscribble_page_set_size(ScbPagePtr ptr, const int width, const int height)
{
    ptr->attributes.area.right = ptr->attributes.area.left + width;
    ptr->attributes.area.bottom = ptr->attributes.area.top + height;
}

void erscribble_page_free(ScbPagePtr ptr)
{
    ERSCRIBBLE_RET_IF(NULL == ptr, "Attempt to release NULL pointer!");

    erscribble_page_clear_strokes(ptr);
    g_free(ptr);
}


void erscribble_page_clear_strokes(ScbPagePtr ptr)
{
    ERSCRIBBLE_RET_IF(NULL == ptr, "Attempt to operate on NULL pointer!");

    erscribble_strokes_free(&ptr->strokes);
    erscribble_strokes_free(&ptr->del_strokes);
}


void erscribble_page_clear(ScbPagePtr ptr)
{
    ERSCRIBBLE_RET_IF(NULL == ptr, "Attempt to take action on NULL pointer!");

    // This function can only be used in one scenario now: copy all of the elements in one list to
    // another, then clear the previous list. This function will be used in undo/redo
    erscribble_strokes_clear(&ptr->strokes);
    erscribble_strokes_clear(&ptr->del_strokes);
}


int erscribble_page_get_stroke_count(ScbPagePtr ptr)
{
    ERSCRIBBLE_RET_INT_IF(NULL == ptr, ERSCRIBBLE_INVALID_COUNT, "Invalid page pointer!");
    return erscribble_strokes_get_count(&ptr->strokes);
}


gboolean erscribble_page_add_stroke(ScbPagePtr page, ScbStrokePtr stroke)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == page || NULL == stroke, "Invalid pointer!");        
    page->strokes.strokes = g_list_append(page->strokes.strokes, stroke);

    return TRUE;
}


ScbStrokesPtr erscribble_page_get_strokes(ScbPagePtr page)
{
    ERSCRIBBLE_RET_NULL_IF(NULL == page, "Attempt to access NULL pointer!");
    return &page->strokes;
}


void erscribble_page_erase_init(ScbPageEraseCtxPtr ptr)
{
    ptr->zoom = 1.0;
    ptr->bInit = FALSE;
}


ScbStrokesPtr erscribble_page_erase_hit_test(ScbPagePtr page, ScbDevPointPtr point, ScbPageEraseCtxPtr eraCtx)
{
    ScbStrokesPtr strokes = NULL;
    ScbHitTestCtx ctx; 
    ctx.size = ERSCRIBBLE_DEF_ERASE_SIZE;
    ctx.zoom = eraCtx->zoom;
    if (!eraCtx->bInit)
    {
        eraCtx->p1 = *point;
        eraCtx->bInit = TRUE;
        strokes = erscribble_strokes_point_hit_test(&page->strokes, point, &ctx);
    }
    else
    {
        eraCtx->p2 = eraCtx->p1;
        eraCtx->p1 = *point;
        strokes = erscribble_strokes_line_hit_test(&page->strokes, 
            &eraCtx->p2, 
            &eraCtx->p1,
            &ctx);
    }

    return strokes;
}


int erscribble_page_get_length(ScbPagePtr ptr)
{
    // set the strokes number before exporting
    ptr->attributes.strokes_number = erscribble_page_get_stroke_count(ptr);

    int length = sizeof(ptr->attributes);

    ScbStrokePtr stroke  = NULL;
    GList* item = g_list_first(ptr->strokes.strokes);
    while(item)
    {
        stroke = (ScbStrokePtr)item->data;
        
        // set points number before exporting
        stroke->attributes.points_number = erscribble_stroke_get_point_count(stroke);
        
        // add by stroke attributes
        length += sizeof(stroke->attributes);

        // add by stroke points
        length += stroke->attributes.points_number * sizeof(ScbDevPoint);

        item = g_list_next(item);   
    }

    return length;
}


void erscribble_page_set_minor_version_number(ScbPagePtr page, const unsigned short minor)
{
    page->attributes.minor_version = minor;
}


gboolean erscribble_page_load(ScbPagePtr page, ScbStreamPtr stream)
{
    // read the page attributes at the first
    ERSCRIBBLE_RET_FALSE_IF(page == NULL || stream == NULL, "Invalid page structure or stream");

    gboolean ret = erscribble_read_stream(stream, &page->attributes, sizeof(page->attributes));

    if (ret == FALSE)
    {
        return ret;
    }

    return erscribble_strokes_load(&page->strokes, stream, page->attributes.strokes_number);
}


gboolean erscribble_page_write_stream(ScbPagePtr page, ScbStreamPtr stream)
{
    // write the page attributes into stream
    if (erscribble_write_stream(stream, &page->attributes, sizeof(page->attributes)))
    {
        // write the stokes data into stream
        if (erscribble_strokes_write_stream(&page->strokes, stream))
        {
            return TRUE;
        }
    }

    return FALSE;
}


void erscribble_page_dump(ScbPagePtr ptr)
{
    ERSCRIBBLE_RET_IF(NULL == ptr, "Attempt to dump on NULL page pointer!");

    DUMPPRINTF("================= Page %s Information =================", ptr->id.id);
    DUMPPRINTF("orientation %d", ptr->attributes.style.orientation);
    DUMPPRINTF("rect (%d, %d) - (%d, %d)", ptr->attributes.area.left, ptr->attributes.area.top, 
        ptr->attributes.area.right, ptr->attributes.area.bottom);
    erscribble_strokes_dump(&ptr->strokes);
    DUMPPRINTF("==================== Page %s Done =====================", ptr->id.id);
}