scbstrokes.c

Go to the documentation of this file.

/*
 * File Name: scbstrokes.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 < >

// ereader include files, between < >

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

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


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


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


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


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

static void _stroke_release     (gpointer data, gpointer user_data);
static void _stroke_dump        (gpointer data, gpointer user_data);


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

gboolean erscribble_strokes_new(ScbStrokesPtr ptr)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == ptr, "Invalid pointer!");
    ptr->strokes = 0;
    return TRUE;
}


void erscribble_strokes_free(ScbStrokesPtr strokes)
{
    ERSCRIBBLE_RET_IF(NULL == strokes, "Attempt to release NULL pointer!");
        
    // release all stroke
    g_list_foreach(strokes->strokes, _stroke_release, NULL);

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


void erscribble_strokes_clear(ScbStrokesPtr strokes)
{
    ERSCRIBBLE_RET_IF(NULL == strokes, "Attempt to release NULL pointer!");

    g_list_free(strokes->strokes);
    strokes->strokes = NULL;
}


int erscribble_strokes_get_count(const ScbStrokesPtr strokes)
{
    ERSCRIBBLE_RET_INT_IF(NULL == strokes, ERSCRIBBLE_INVALID_COUNT, "Invalid strokes pointer!");
    
    // here, the list contains a empty item, so we need to decrease one
    return g_list_length(strokes->strokes);
}


void erscribble_strokes_add_stroke(ScbStrokesPtr strokes, 
                            ScbStrokePtr stroke)
{
    ERSCRIBBLE_RET_IF(NULL == strokes || NULL == stroke, "Invalid storkes or stroke pointer!");
    strokes->strokes = g_list_append(strokes->strokes, stroke);
}


void erscribble_strokes_add_strokes(ScbStrokesPtr dst, 
                            const ScbStrokesPtr src)
{
    ERSCRIBBLE_RET_IF(NULL == dst || NULL == src, "Invalid pointer(s)!");
    dst->strokes = g_list_concat(dst->strokes, src->strokes);
}


ScbStrokePtr erscribble_strokes_detach_stroke(ScbStrokesPtr strokes, 
                            ScbStrokePtr stroke)
{
    ERSCRIBBLE_RET_NULL_IF(NULL == strokes || NULL == stroke, "Invalid pointer!");
    strokes->strokes = g_list_remove(strokes->strokes, stroke);                   
    return stroke;
}


ScbStrokesPtr erscribble_strokes_point_hit_test(ScbStrokesPtr strokes, 
                                   ScbDevPointPtr point,
                                   const ScbHitTestCtxPtr ctx)
{
    ERSCRIBBLE_RET_NULL_IF(NULL == strokes, "Invalid strokes list pointer!");
        
    ScbStrokesPtr result = NULL;
    ScbStrokePtr stroke  = NULL;
    GList* ptr = g_list_first(strokes->strokes);
    while(ptr)
    {
        stroke = (ScbStrokePtr)ptr->data;
        if (stroke && erscribble_stroke_point_hit_test(stroke, point, ctx))
        {
            LOGPRINTF("point hit");
            if (NULL == result)
            {
                result = g_new0(ScbStrokes, 1);
                if (! erscribble_strokes_new(result))
                {
                    return NULL;
                }
            }
            // move from one stroke list to the other
            erscribble_strokes_add_stroke(result, stroke);
            erscribble_strokes_detach_stroke(strokes, stroke);
        }
        ptr = g_list_next(ptr);   
    }
    return result;
}


ScbStrokesPtr erscribble_strokes_line_hit_test(ScbStrokesPtr strokes, 
                                  ScbDevPointPtr point1,
                                  ScbDevPointPtr point2,
                                  const ScbHitTestCtxPtr ctx)
{
    ERSCRIBBLE_RET_NULL_IF(NULL == strokes, "Invalid strokes list pointer!");
        
    ScbStrokesPtr result = NULL;
    ScbStrokePtr stroke  = NULL;
    GList* ptr = g_list_first(strokes->strokes);
    while(ptr)
    {
        stroke = (ScbStrokePtr)ptr->data;
        if (stroke && erscribble_stroke_line_hit_test(stroke, point1, point2, ctx))
        {
            LOGPRINTF("line hit");
            if (NULL == result)
            {
                result = g_new0(ScbStrokes, 1);
                if (!erscribble_strokes_new(result))
                {
                    return NULL;
                }
            }
            // move from one list to the other
            erscribble_strokes_add_stroke(result, stroke);
            erscribble_strokes_detach_stroke(strokes, stroke);
        }
        ptr = g_list_next(ptr);   
    }
    return result;
}


void erscribble_strokes_erase_driver_draw(ScbStrokesPtr strokes)
{
    if (NULL == strokes)
    {
        return;
    }

    GList *ptr = g_list_first(strokes->strokes);
    ScbStrokePtr stroke = NULL;
    while (ptr)
    {
        stroke = (ScbStrokePtr)ptr->data;
        if (stroke)
        {
            ScbDevColor old = stroke->attributes.color;
            // use reverse color
            // TODO. The WHITE color is not always correct.
            // We should the draw the erased part by background color in the future.
            stroke->attributes.color = ERSCRIBBLE_DEV_COLOR_WHITE;
            erscribble_stroke_driver_draw(stroke);
            stroke->attributes.color = old;
        }
        ptr = g_list_next(ptr);
    }
}


gboolean erscribble_strokes_load(ScbStrokesPtr strokes, ScbStreamPtr stream, const int strokes_num)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == strokes || NULL == stream, "Invalid strokes or stream!");

    erscribble_strokes_clear(strokes);

    int i = 0;
    for (; i < strokes_num; ++i)
    {
        ScbStrokePtr stroke = erscribble_stroke_new();
        if (erscribble_stroke_load(stroke, stream))
        {
            erscribble_strokes_add_stroke(strokes, stroke);
        }
        else
        {
            erscribble_stroke_free(stroke);
            return FALSE;
        }
    }

    return TRUE;
}


gboolean erscribble_strokes_write_stream(ScbStrokesPtr strokes, ScbStreamPtr stream)
{
    ERSCRIBBLE_RET_FALSE_IF(NULL == strokes || NULL == stream, "Invalid strokes or stream!");

    ScbStrokePtr stroke  = NULL;
    GList* item = g_list_first(strokes->strokes);
    while(item)
    {
        stroke = (ScbStrokePtr)item->data;
        
        if (erscribble_stroke_write_stream(stroke, stream) == FALSE)
        {
            return FALSE;
        }

        item = g_list_next(item);   
    }

    return TRUE;
}


void erscribble_strokes_dump(ScbStrokesPtr strokes)
{
    if (strokes)
    {
        g_list_foreach(strokes->strokes, _stroke_dump, 0);
    }
}


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

static void _stroke_release(gpointer data, gpointer user_data)
{
    UNUSED(user_data);
    if (data)
    {
        erscribble_stroke_free((ScbStrokePtr)data);
    }        
}


static void _stroke_dump(gpointer data, gpointer user_data)
{
    UNUSED(user_data);
    if (data)
    {
        erscribble_stroke_dump((ScbStrokePtr)data);
    }        
}