liberscribble/src/scbstrokes.c File Reference

#include "scbstrokes.h"
#include "scblog.h"
#include "scbstroke.h"

Go to the source code of this file.

Functions
void	_stroke_release (gpointer data, gpointer user_data)
void	_stroke_dump (gpointer data, gpointer user_data)
gboolean	scb_strokes_new (ScbStrokesPtr ptr)
void	scb_strokes_free (ScbStrokesPtr strokes)
void	scb_strokes_empty (ScbStrokesPtr strokes)
int	scb_strokes_get_count (const ScbStrokesPtr strokes)
void	scb_strokes_detach (ScbStrokesPtr strokes)
void	scb_strokes_add_stroke (ScbStrokesPtr strokes, ScbStrokePtr stroke)
void	scb_strokes_add_strokes (ScbStrokesPtr dst, const ScbStrokesPtr src)
ScbStrokePtr	scb_strokes_detach_stroke (ScbStrokesPtr strokes, ScbStrokePtr stroke)
ScbStrokesPtr	scb_strokes_point_hit_test (ScbStrokesPtr strokes, ScbDevPointPtr point, const ScbHitTestCtxPtr ctx)
ScbStrokesPtr	scb_strokes_line_hit_test (ScbStrokesPtr strokes, ScbDevPointPtr point1, ScbDevPointPtr point2, const ScbHitTestCtxPtr ctx)
void	scb_strokes_erase_fast_draw (ScbStrokesPtr strokes)
void	_stroke_save (gpointer data, gpointer user_data)
gboolean	scb_strokes_save (ScbStrokesPtr strokes, ScbXmlPtr ptr)
gboolean	scb_strokes_load (ScbStrokesPtr strokes, ScbXmlPtr ptr)
void	scb_strokes_dump (ScbStrokesPtr strokes)

---

Function Documentation

void _stroke_dump	(	gpointer	data,
		gpointer	user_data
	)

Definition at line 38 of file scbstrokes.c.

{
    if (data)
    {
        scb_stroke_dump((ScbStrokePtr)data);
    }        
}

Here is the call graph for this function:

void _stroke_release	(	gpointer	data,
		gpointer	user_data
	)

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

Definition at line 30 of file scbstrokes.c.

{
    if (data)
    {
        scb_stroke_free((ScbStrokePtr)data);
    }        
}

Here is the call graph for this function:

void _stroke_save	(	gpointer	data,
		gpointer	user_data
	)

Definition at line 235 of file scbstrokes.c.

{
    if (data && user_data)
    {
        ScbXmlPtr ptr = (ScbXmlPtr)user_data;
        scb_stroke_save((ScbStrokePtr)data, ptr);
        ++ptr->index;
    }
}

Here is the call graph for this function:

void scb_strokes_add_stroke	(	ScbStrokesPtr	strokes,
		ScbStrokePtr	stroke
	)

Definition at line 112 of file scbstrokes.c.

{
    SCB_RET_IF(NULL == strokes || NULL == stroke, "Invalid storkes or stroke pointer!");
    g_list_append(strokes->strokes, stroke);
}

void scb_strokes_add_strokes	(	ScbStrokesPtr	dst,
		const ScbStrokesPtr	src
	)

Definition at line 119 of file scbstrokes.c.

{
    SCB_RET_IF(NULL == dst || NULL == src, "Invalid pointer(s)!");
    g_list_concat(dst->strokes, src->strokes);
}

void scb_strokes_detach

(

ScbStrokesPtr

strokes

)

Definition at line 100 of file scbstrokes.c.

{
    if (strokes)
    {
        g_list_free(strokes->strokes);
        strokes->strokes = NULL;
    }
    // NULL strokes pointer is not an error here. 
}

ScbStrokePtr scb_strokes_detach_stroke	(	ScbStrokesPtr	strokes,
		ScbStrokePtr	stroke
	)

Definition at line 129 of file scbstrokes.c.

{
    SCB_RET_NULL_IF(NULL == strokes || NULL == stroke, "Invalid pointer!");
    g_list_remove(strokes->strokes, stroke);                   
    return stroke;
}

void scb_strokes_dump

(

ScbStrokesPtr

strokes

)

Definition at line 292 of file scbstrokes.c.

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

Here is the call graph for this function:

void scb_strokes_empty

(

ScbStrokesPtr

strokes

)

Definition at line 72 of file scbstrokes.c.

{
    SCB_RET_IF(NULL == strokes, "Attempt to release NULL pointer!");
        
    g_list_foreach(strokes->strokes, _stroke_release, NULL);
    // free and allocate again? I can not find list release function
    // maybe we always free the first element unti list is empty
    g_list_free(strokes->strokes);
    strokes->strokes = g_list_alloc();
}

Here is the call graph for this function:

void scb_strokes_erase_fast_draw

(

ScbStrokesPtr

strokes

)

Definition at line 208 of file scbstrokes.c.

{
    if (NULL == strokes)
    {
        return;
    }

    GList *ptr = g_list_first(strokes->strokes);
    ScbStrokePtr stroke = NULL;
    while (ptr)
    {
        stroke = ptr->data;
        if (stroke)
        {
            ScbDevColor old = stroke->style.color;
            // use reverse color
            stroke->style.color = SCB_DEV_COLOR_WHITE;
            scb_stroke_fast_draw(stroke);
            stroke->style.color = old;
        }
        ptr = g_list_next(ptr);
    }
}

Here is the call graph for this function:

void scb_strokes_free

(

ScbStrokesPtr

strokes

)

Definition at line 59 of file scbstrokes.c.

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

Here is the call graph for this function:

int scb_strokes_get_count

(

const ScbStrokesPtr

strokes

)

Definition at line 84 of file scbstrokes.c.

{
    SCB_RET_INT_IF(NULL == strokes, SCB_INVALID_COUNT, "Invalid strokes pointer!");
    
    // here, the list contains a empty item, so we need to decrease one
    int len = g_list_length(strokes->strokes);
    if (len > 0)
    {
        return len - 1;
    }
    return SCB_INVALID_COUNT;
}

ScbStrokesPtr scb_strokes_line_hit_test	(	ScbStrokesPtr	strokes,
		ScbDevPointPtr	point1,
		ScbDevPointPtr	point2,
		const ScbHitTestCtxPtr	ctx
	)

Definition at line 174 of file scbstrokes.c.

{
    SCB_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 = ptr->data;
        if (stroke && scb_stroke_line_hit_test(stroke, point1, point2, ctx))
        {
            SCB_TRACE("line hit");
            if (NULL == result)
            {
                result = g_new0(ScbStrokes, 1);
                if (!scb_strokes_new(result))
                {
                    return NULL;
                }
            }
            // move from one list to the other
            scb_strokes_add_stroke(result, stroke);
            scb_strokes_detach_stroke(strokes, stroke);
        }
        ptr = g_list_next(ptr);   
    }
    return result;
}

Here is the call graph for this function:

gboolean scb_strokes_load	(	ScbStrokesPtr	strokes,
		ScbXmlPtr	ptr
	)

Definition at line 262 of file scbstrokes.c.

{
    // check
    SCB_RET_FALSE_IF(NULL == strokes || NULL == ptr, "Invalid strokes or xml pointer!");
        
    // the strokes here, should be clear. maybe memory leak if open and reload
    // the caller should check it
    scb_strokes_empty(strokes);
    ScbXmlPtr self = scb_xml_clone(ptr);
    strncat(self->xPath, "/strokes", SCB_MAX_XML_PATH);
    self->index = 1;
        
    while(1)
    {
        ScbStrokePtr stroke = scb_stroke_new();
        if (scb_stroke_load(stroke, self))
        {
            scb_strokes_add_stroke(strokes, stroke);
            ++self->index;
        }
        else
        {
            scb_stroke_free(stroke);
            break;
        }
    }
    return TRUE;
}

Here is the call graph for this function:

gboolean scb_strokes_new

(

ScbStrokesPtr

ptr

)

Definition at line 49 of file scbstrokes.c.

{
    SCB_RET_FALSE_IF(NULL == ptr, "Invalid pointer!");
    ptr->strokes = g_list_alloc();
    SCB_RET_FALSE_IF(NULL == ptr->strokes, "Could not allocate memory for list!");
    return TRUE;
}

ScbStrokesPtr scb_strokes_point_hit_test	(	ScbStrokesPtr	strokes,
		ScbDevPointPtr	point,
		const ScbHitTestCtxPtr	ctx
	)

Definition at line 140 of file scbstrokes.c.

{
    SCB_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 && scb_stroke_point_hit_test(stroke, point, ctx))
        {
            SCB_TRACE("point hit");
            if (NULL == result)
            {
                result = g_new0(ScbStrokes, 1);
                if (! scb_strokes_new(result))
                {
                    return NULL;
                }
            }
            // move from one stroke list to the other
            scb_strokes_add_stroke(result, stroke);
            scb_strokes_detach_stroke(strokes, stroke);
        }
        ptr = g_list_next(ptr);   
    }
    return result;
}

Here is the call graph for this function:

gboolean scb_strokes_save	(	ScbStrokesPtr	strokes,
		ScbXmlPtr	ptr
	)

Definition at line 246 of file scbstrokes.c.

{
    // check
    SCB_RET_FALSE_IF(NULL == strokes || NULL == ptr, "Invalid strokes or xml pointer!");
        
    // construct xPath
    ScbXmlPtr self = scb_xml_clone(ptr);
    ermXmlNewString(&self->handle, self->xPath, "strokes", "");
    strncat(self->xPath, "/strokes", SCB_MAX_XML_PATH);
    self->index = 1;
    g_list_foreach(strokes->strokes, _stroke_save, self);
    scb_xml_free(self);
    return TRUE;
}

Here is the call graph for this function: