scbstroke.h File Reference

#include <glib.h>
#include "scbcolor.h"
#include "scbpoints.h"
#include "scbtype.h"
#include "scbstream.h"

Include dependency graph for scbstroke.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_ScbStrokeAttributes
struct	_ScbStroke
struct	_ScbHitTestCtx
Typedefs
typedef G_BEGIN_DECLS struct _ScbStrokeAttributes	ScbStrokeAttributes
typedef ScbStrokeAttributes *	ScbStrokeAttributesPtr
typedef struct _ScbStroke	ScbStroke
typedef ScbStroke *	ScbStrokePtr
typedef struct _ScbHitTestCtx	ScbHitTestCtx
typedef ScbHitTestCtx *	ScbHitTestCtxPtr
Functions
ScbStrokePtr	erscribble_stroke_new ()
ScbStrokePtr	erscribble_stroke_new_with_attributes (ScbStrokeAttributesPtr pAttr)
void	erscribble_stroke_free (ScbStrokePtr stroke)
int	erscribble_stroke_get_point_count (ScbStrokePtr stroke)
ScbPointPtr	erscribble_stroke_get_point_data (ScbStrokePtr stroke)
int	erscribble_stroke_add_point (ScbStrokePtr stroke, ScbDevPointPtr point)
void	erscribble_stroke_driver_draw_point (ScbStrokePtr stroke, ScbDevPointPtr point, gboolean is_last_point)
void	erscribble_stroke_driver_draw (ScbStrokePtr stroke)
gboolean	erscribble_stroke_point_hit_test (ScbStrokePtr stroke, ScbDevPointPtr point, const ScbHitTestCtxPtr ctx)
gboolean	erscribble_stroke_line_hit_test (ScbStrokePtr stroke, ScbDevPointPtr point1, ScbDevPointPtr point2, const ScbHitTestCtxPtr ctx)
void	erscribble_stroke_set_shape (ScbStrokePtr stroke, const int shape_id)
void	erscribble_stroke_set_size (ScbStrokePtr stroke, const int size_id)
int	erscribble_stroke_get_shape (ScbStrokePtr stroke)
int	erscribble_stroke_get_size (ScbStrokePtr stroke)
void	erscribble_stroke_set_color (ScbStrokePtr stroke, const ScbDevColor color)
ScbDevColor	erscribble_stroke_get_color (ScbStrokePtr stroke)
void	erscribble_stroke_dump (ScbStrokePtr ptr)
gboolean	erscribble_stroke_load (ScbStrokePtr stroke, ScbStreamPtr stream)
gboolean	erscribble_stroke_write_stream (ScbStrokePtr stroke, ScbStreamPtr stream)

---

Typedef Documentation

typedef struct _ScbHitTestCtx ScbHitTestCtx

typedef ScbHitTestCtx* ScbHitTestCtxPtr

Definition at line 95 of file scbstroke.h.

typedef struct _ScbStroke ScbStroke

typedef G_BEGIN_DECLS struct _ScbStrokeAttributes ScbStrokeAttributes

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

typedef ScbStrokeAttributes* ScbStrokeAttributesPtr

Definition at line 76 of file scbstroke.h.

typedef ScbStroke* ScbStrokePtr

Definition at line 86 of file scbstroke.h.

---

Function Documentation

int erscribble_stroke_add_point	(	ScbStrokePtr	stroke,
		ScbDevPointPtr	point
	)

Definition at line 194 of file scbstroke.c.

References _ScbRect::bottom, erscribble_points_append(), ERSCRIBBLE_RET_ERR, ERSCRIBBLE_RET_INT_IF, ERSCRIBBLE_RET_OK, _ScbRect::left, _ScbDevPoint::point, _ScbStroke::points, _ScbStroke::rect, _ScbRect::right, _ScbRect::top, _ScbPoint::x, and _ScbPoint::y.

Referenced by erscribble_stroke_load(), notepad::CNotepadDoc::on_scribble_begin(), notepad::CNotepadDoc::on_scribble_end(), and notepad::CNotepadDoc::on_scribble_move().

{
    ERSCRIBBLE_RET_INT_IF(NULL == stroke, ERSCRIBBLE_RET_ERR, "stroke pointer is NULL!");
    ERSCRIBBLE_RET_INT_IF(NULL == point, ERSCRIBBLE_RET_ERR, "Invalid point pointer!");

    // for debug. report points whose x or y is incorrect. 
    // It maybe not correct, the coordinates can be very large. 
    // if (point->x >=  1024 || point->y >= 1024)
    // {
        // WARNPRINTF("Odd points found! (%d %d)", point->x, point->y);
    // }

    erscribble_points_append(&stroke->points, point);

    // adjust rectangle
    if (stroke->rect.left > point->point.x)
    {
        stroke->rect.left = point->point.x;
    }

    if (stroke->rect.right < point->point.x)
    {
        stroke->rect.right = point->point.x;
    }

    if (stroke->rect.top > point->point.y)
    {
        stroke->rect.top = point->point.y;
    }

    if (stroke->rect.bottom < point->point.y)
    {
        stroke->rect.bottom = point->point.y;
    }

    return ERSCRIBBLE_RET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_stroke_driver_draw

(

ScbStrokePtr

stroke

)

Definition at line 285 of file scbstroke.c.

References _ScbStroke::attributes, ERSCRIBBLE_DEF_DRIVER_DRAW_BUF_LEN, erscribble_driver_draw_points(), ERSCRIBBLE_RET_IF, _ScbStroke::points, _ScbPoint::x, _DrvPointInfo::x, and _ScbPoint::y.

Referenced by erscribble_strokes_erase_driver_draw().

{
    ERSCRIBBLE_RET_IF(NULL == stroke || NULL == stroke->points.points, "NULL pointer!");

    int len = stroke->points.points->len;
    if (len <= 0) return;

    ScbPointPtr ip = (ScbPointPtr)stroke->points.points->data;

    DrvPointsBuf output;
    int output_size = 0;

    int brush_size = stroke->attributes.size_id;
    unsigned char brush_color = stroke->attributes.color;

    // divide into ioctl's
    DrvPointInfo* op = &output.points[0];
    int i = 0;
    for(i = 0; i < len; ++i)
    {
        // copy points
        op->x = ip->x;
        op->y = ip->y;
        op->size = brush_size;
        op->color = brush_color;
        if (i == len-1) op->pen_down = FALSE; // force pen_up for last point of stroke
        else op->pen_down = TRUE;

        output_size++;
        ip++;
        op++;

        if (output_size == ERSCRIBBLE_DEF_DRIVER_DRAW_BUF_LEN || i == len-1)
        {
            // call ioctl
            output.count = output_size;
            erscribble_driver_draw_points(&output);
            output_size = 0;
            op = &output.points[0];
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_stroke_driver_draw_point	(	ScbStrokePtr	stroke,
		ScbDevPointPtr	point,
		gboolean	is_last_point
	)

Definition at line 247 of file scbstroke.c.

References _ScbStroke::attributes, erscribble_driver_draw(), erscribble_driver_draw_now(), erscribble_driver_draw_record(), erscribble_driver_draw_reset_context(), and ERSCRIBBLE_RET_IF.

Referenced by notepad::CNotepadDoc::on_scribble_begin(), notepad::CNotepadDoc::on_scribble_end(), and notepad::CNotepadDoc::on_scribble_move().

{
    ERSCRIBBLE_RET_IF(NULL == stroke || NULL == point, "NULL storke or point!");

    // Fast draw points by using the additional global points buffer.
    // Here, we have two choices:
    // 1. use a timer, but the application should have a message loop. Gtk/X11
    // 2. check timestamp and points, draw them if necessary.
    
    if (erscribble_driver_draw_now() || is_last_point)
    {
        if (is_last_point)
        {
            // add the last point 
            erscribble_driver_draw_record(point, 
                stroke->attributes.size_id,
                stroke->attributes.color,
                FALSE);
        }

        // draw it right now
        erscribble_driver_draw();

        // reset
        erscribble_driver_draw_reset_context();
    }

    if (!is_last_point)
    {
        // record this point
        erscribble_driver_draw_record(point,
            stroke->attributes.size_id,
            stroke->attributes.color, 
            TRUE);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_stroke_dump

(

ScbStrokePtr

ptr

)

Definition at line 549 of file scbstroke.c.

References DUMPPRINTF, ERSCRIBBLE_RET_IF, _ScbStroke::points, _ScbPoint::x, and _ScbPoint::y.

Referenced by _stroke_dump().

{
    ERSCRIBBLE_RET_IF(NULL == ptr || NULL == ptr->points.points, "");
    
    int count = ptr->points.points->len;
    ScbPointPtr p = (ScbPointPtr)ptr->points.points->data;
    int *pp = (int *)ptr->points.pressures->data;
    while(count > 0)
    {
        DUMPPRINTF("\t(%d,\t%d,\t%d)", p->x, p->y, *pp);
        --count; ++ p; ++pp;
    }
}

Here is the caller graph for this function:

void erscribble_stroke_free

(

ScbStrokePtr

stroke

)

Definition at line 183 of file scbstroke.c.

References erscribble_points_free(), ERSCRIBBLE_RET_IF, and _ScbStroke::points.

Referenced by _stroke_release(), and erscribble_strokes_load().

{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Attempt to release NULL pointer!");
    if (stroke->points.points)
    {
        erscribble_points_free(&stroke->points);
    }
    g_free(stroke);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbDevColor erscribble_stroke_get_color

(

ScbStrokePtr

stroke

)

Definition at line 574 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_DEV_COLOR_UNKNOWN.

{
    if (NULL == stroke)
    {
        return ERSCRIBBLE_DEV_COLOR_UNKNOWN;
    }
    return stroke->attributes.color;
}

int erscribble_stroke_get_point_count

(

ScbStrokePtr

stroke

)

Definition at line 233 of file scbstroke.c.

References ERSCRIBBLE_INVALID_COUNT, ERSCRIBBLE_RET_INT_IF, and _ScbStroke::points.

Referenced by erscribble_page_get_length().

{
    ERSCRIBBLE_RET_INT_IF(NULL == stroke || NULL == stroke->points.points, ERSCRIBBLE_INVALID_COUNT, "Invalid pointer(s)!");
    return stroke->points.points->len;
}

Here is the caller graph for this function:

ScbPointPtr erscribble_stroke_get_point_data

(

ScbStrokePtr

stroke

)

Definition at line 240 of file scbstroke.c.

References erscribble_points_get_data(), ERSCRIBBLE_RET_NULL_IF, and _ScbStroke::points.

{
    ERSCRIBBLE_RET_NULL_IF(NULL == stroke, "Invalid pointer!");
    return erscribble_points_get_data(&stroke->points);
}

Here is the call graph for this function:

int erscribble_stroke_get_shape

(

ScbStrokePtr

stroke

)

Definition at line 527 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_INVALID_SHAPE.

{
    if (NULL == stroke)
    {
        return ERSCRIBBLE_INVALID_SHAPE;
    }

    return stroke->attributes.shape_id;
}

int erscribble_stroke_get_size

(

ScbStrokePtr

stroke

)

Definition at line 538 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_INVALID_SIZE.

{
    if (NULL == stroke)
    {
        return ERSCRIBBLE_INVALID_SIZE;
    }

    return stroke->attributes.size_id;
}

gboolean erscribble_stroke_line_hit_test	(	ScbStrokePtr	stroke,
		ScbDevPointPtr	point1,
		ScbDevPointPtr	point2,
		const ScbHitTestCtxPtr	ctx
	)

Definition at line 380 of file scbstroke.c.

References _ScbStroke::attributes, _ScbRect::bottom, erscribble_is_lines_intersect(), erscribble_is_rect_intersect(), ERSCRIBBLE_RET_FALSE_IF, _ScbRect::left, LOGPRINTF, _ScbDevPoint::point, _ScbStroke::points, _ScbStroke::rect, _ScbRect::right, _ScbHitTestCtx::size, _ScbRect::top, _ScbPoint::x, _ScbPoint::y, and _ScbHitTestCtx::zoom.

Referenced by erscribble_strokes_line_hit_test().

{
    ERSCRIBBLE_RET_FALSE_IF(NULL == stroke || NULL == point1 || NULL == point2 || NULL == ctx, 
        "Invalid pointer(s)!");

    // check line and line segment in stroke
    // not consider the line width here...
    
    // fast check
    ScbRect tmp; 
    double ratio = 1.0;
    ScbDevPoint p1, p2;
    if (fabs(stroke->attributes.zoom - ctx->zoom) >= e)
    {
        ratio = stroke->attributes.zoom / ctx->zoom;
        p1.point.x = (int)point1->point.x * ratio;
        p1.point.y = (int)point1->point.y * ratio;
        p2.point.x = (int)point2->point.x * ratio;
        p2.point.y = (int)point2->point.y * ratio;
    }
    else
    {
        p1 = *point1; p2 = *point2;
    }


    tmp.left    = MIN(p1.point.x, p2.point.x) - ctx->size;
    tmp.right   = MAX(p1.point.x, p2.point.x) + ctx->size;
    tmp.top     = MIN(p1.point.y, p2.point.y) - ctx->size;
    tmp.bottom  = MAX(p1.point.y, p2.point.y) + ctx->size;
    if (!erscribble_is_rect_intersect(&stroke->rect, &tmp))
    {
        return FALSE;
    }

    // check each line segment in stroke
    int len = stroke->points.points->len;
    ScbPointPtr begin = (ScbPointPtr)stroke->points.points->data;
    ScbPointPtr end   = begin;

    // only one point
    if (len == 1)
    {
        if (erscribble_is_lines_intersect((ScbPointPtr)&p1, (ScbPointPtr)&p2, begin, end))
        {
            LOGPRINTF("one point hit!");
            LOGPRINTF("line in stroke: (%d %d) - (%d %d)", 
                begin->x, begin->y, end->x, end->y);
            LOGPRINTF("user line: (%d %d) - (%d %d)",
                p1.point.x, p1.point.y, p2.point.x, p2.point.y);
            return TRUE;
        }
        return FALSE;
    }

    // others
    while (len > 1)
    {
        ++end;
        if (erscribble_is_lines_intersect((ScbPointPtr)&p1, (ScbPointPtr)&p2, begin, end))
        {
            // for debug
            LOGPRINTF("line in stroke: (%d %d) - (%d %d)", 
                begin->x, begin->y, end->x, end->y);
            LOGPRINTF("user line: (%d %d) - (%d %d)",
                p1.point.x, p1.point.y, p2.point.x, p2.point.y);
            return TRUE;
        }
        begin = end; --len;
    }
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean erscribble_stroke_load	(	ScbStrokePtr	stroke,
		ScbStreamPtr	stream
	)

Definition at line 457 of file scbstroke.c.

References _ScbStroke::attributes, erscribble_point_load(), erscribble_read_stream(), ERSCRIBBLE_RET_FALSE_IF, and erscribble_stroke_add_point().

Referenced by erscribble_strokes_load().

{
    ERSCRIBBLE_RET_FALSE_IF(NULL == stroke || NULL == stream, "Invalid stroke pointer or stream!");

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

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

    ScbDevPoint point;
    int i = 0;
    for (; i < stroke->attributes.points_number; ++i)
    {
        if (erscribble_point_load(&point, stream) == FALSE)
        {
            return FALSE;
        }

        erscribble_stroke_add_point(stroke, &point);
    }

    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbStrokePtr erscribble_stroke_new

(

)

Definition at line 122 of file scbstroke.c.

References _ScbStroke::attributes, _ScbRect::bottom, ERSCRIBBLE_DEF_SHAPE_LINE, ERSCRIBBLE_DEF_STROKE_LAYER, ERSCRIBBLE_DEF_STROKE_PENSIZE, ERSCRIBBLE_DEF_STROKE_POINTSIZE, ERSCRIBBLE_DEV_COLOR_BLACK, erscribble_driver_draw_reset_context(), erscribble_points_new(), ERSCRIBBLE_RET_NULL_IF, _ScbRect::left, _ScbStroke::points, _ScbStroke::rect, _ScbRect::right, and _ScbRect::top.

Referenced by erscribble_strokes_load().

{
    ScbStrokePtr ptr = g_new0(ScbStroke, 1);
    ERSCRIBBLE_RET_NULL_IF(NULL == ptr, "Not enough memory for stroke!");
    
    // allocate points array
    if (!erscribble_points_new(&ptr->points, ERSCRIBBLE_DEF_STROKE_POINTSIZE))
    {
        // could not alloc memory for list
        g_free(ptr);
        return NULL;
    }

    // init the stroke paramters
    ptr->attributes.color     = ERSCRIBBLE_DEV_COLOR_BLACK;
    ptr->attributes.layer     = ERSCRIBBLE_DEF_STROKE_LAYER;
    ptr->attributes.shape_id  = ERSCRIBBLE_DEF_SHAPE_LINE;
    ptr->attributes.size_id   = ERSCRIBBLE_DEF_STROKE_PENSIZE;

    // init out bound rect. used to fast hit test
    ptr->rect.left   = INT_MAX;
    ptr->rect.top    = INT_MAX;
    ptr->rect.right  = INT_MIN;
    ptr->rect.bottom = INT_MIN;

    // init fast draw context 
    erscribble_driver_draw_reset_context();
    return ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScbStrokePtr erscribble_stroke_new_with_attributes

(

ScbStrokeAttributesPtr

pAttr

)

Definition at line 153 of file scbstroke.c.

References _ScbStroke::attributes, _ScbRect::bottom, ERSCRIBBLE_DEF_STROKE_POINTSIZE, erscribble_driver_draw_reset_context(), erscribble_points_new(), ERSCRIBBLE_RET_NULL_IF, _ScbRect::left, _ScbStroke::points, _ScbStroke::rect, _ScbRect::right, and _ScbRect::top.

Referenced by notepad::CNotepadDoc::on_scribble_begin().

{
    ERSCRIBBLE_RET_NULL_IF(NULL == pAttr, "Invalid pointer!");

    ScbStrokePtr ptr = g_new0(ScbStroke, 1);
    ERSCRIBBLE_RET_NULL_IF(NULL == ptr, "Not enough memory for stroke!");
    
    // allocate points array
    if (!erscribble_points_new(&ptr->points, ERSCRIBBLE_DEF_STROKE_POINTSIZE))
    {
        // could not alloc memory for list
        g_free(ptr);
        return NULL;
    }

    // init the stroke paramters
    ptr->attributes  = *pAttr;

    // init out bound rect. used to fast hit test
    ptr->rect.left   = INT_MAX;
    ptr->rect.top    = INT_MAX;
    ptr->rect.right  = INT_MIN;
    ptr->rect.bottom = INT_MIN;

    // init fast draw context 
    erscribble_driver_draw_reset_context();
    return ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean erscribble_stroke_point_hit_test	(	ScbStrokePtr	stroke,
		ScbDevPointPtr	point,
		const ScbHitTestCtxPtr	ctx
	)

Definition at line 329 of file scbstroke.c.

References _ScbStroke::attributes, _ScbRect::bottom, erscribble_is_rect_intersect(), ERSCRIBBLE_RET_FALSE_IF, _ScbRect::left, LOGPRINTF, _ScbDevPoint::point, _ScbStroke::points, _ScbStroke::rect, _ScbRect::right, _ScbHitTestCtx::size, _ScbRect::top, _ScbPoint::x, _ScbPoint::y, and _ScbHitTestCtx::zoom.

Referenced by erscribble_strokes_point_hit_test().

{
    ERSCRIBBLE_RET_FALSE_IF(NULL == stroke || NULL == point || NULL == ctx, 
        "Invalid pointer(s)!");

    // hit test
    // 1. check out bound and the point (fast check)
    // 2. check points in the stroke

    // fast check
    ScbRect tmp; 
    double ratio = 1.0;
    if (fabs(stroke->attributes.zoom - ctx->zoom) >= e)
    {
        ratio = stroke->attributes.zoom / ctx->zoom;
    }
    tmp.left    = point->point.x * ratio - ctx->size;
    tmp.right   = point->point.x * ratio + ctx->size;
    tmp.top     = point->point.y * ratio - ctx->size;
    tmp.bottom  = point->point.y * ratio + ctx->size;
    if (!erscribble_is_rect_intersect(&stroke->rect, &tmp))
    {
        return FALSE;
    }

    // check each point in stroke
    ScbRect src;
    int size = stroke->attributes.size_id;
    int len = stroke->points.points->len;
    ScbPointPtr pts = (ScbPointPtr)stroke->points.points->data;
    while (len)
    {
        src.left    = pts->x - size;
        src.right   = pts->x + size;
        src.top     = pts->y - size;
        src.bottom  = pts->y + size;
        if (erscribble_is_rect_intersect(&src, &tmp))
        {
            LOGPRINTF("\nrect1: (%d %d %d %d)\nrect2: (%d %d %d %d)",
                src.left, src.top, src.right, src.bottom,
                tmp.left, tmp.top, tmp.right, tmp.bottom);
            return TRUE;
        }
        ++pts; --len;
    }
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void erscribble_stroke_set_color	(	ScbStrokePtr	stroke,
		const ScbDevColor	color
	)

Definition at line 567 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_RET_IF.

{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.color = color;
}

void erscribble_stroke_set_shape	(	ScbStrokePtr	stroke,
		const int	shape_id
	)

Definition at line 513 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_RET_IF.

{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.shape_id = shape_id;
}

void erscribble_stroke_set_size	(	ScbStrokePtr	stroke,
		const int	size_id
	)

Definition at line 520 of file scbstroke.c.

References _ScbStroke::attributes, and ERSCRIBBLE_RET_IF.

{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.size_id = size_id;
}

gboolean erscribble_stroke_write_stream	(	ScbStrokePtr	stroke,
		ScbStreamPtr	stream
	)

Definition at line 484 of file scbstroke.c.

References _ScbStroke::attributes, ERSCRIBBLE_RET_FALSE_IF, erscribble_write_stream(), and _ScbStroke::points.

Referenced by erscribble_strokes_write_stream().

{
    ERSCRIBBLE_RET_FALSE_IF(NULL == stroke || NULL == stream, "Invalid stroke pointer or stream!");

    if (erscribble_write_stream(stream, &stroke->attributes, sizeof(stroke->attributes)) == FALSE)
    {
        return FALSE;
    }

    int i = 0;
    for (; i < stroke->attributes.points_number; ++i)
    {
        ScbPoint point = g_array_index(stroke->points.points, ScbPoint, i);
        if (erscribble_write_stream(stream, &point, sizeof(ScbPoint)) == FALSE)
        {
            return FALSE;
        }

        int pressure = g_array_index(stroke->points.pressures, int, i);
        if (erscribble_write_stream(stream, &pressure, sizeof(int)) == FALSE)
        {
            return FALSE;
        }
    }

    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function: