scbstroke.c

Go to the documentation of this file.

/*
 * File Name: scbstroke.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>
#include <limits.h>
#include <math.h>

// ereader include files, between < >

// local include files, between " "
#include "scbutil.h"
#include "scbtype.h"
#include "scbstroke.h"
#include "scblog.h"
#include "scbconfig.h"
#include "driver.h"


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

typedef struct _LineStrTab
{
    ScbLineStyle    style;
    char *          name;
} LineStrTab;


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

#ifdef WIN32
#define strcasecmp strcmp
#endif

const LineStrTab _Tab[] =
{
    {ERSCRIBBLE_LINE_SOLID, "solid"},
    {ERSCRIBBLE_LINE_INVALID, ""},
};

const int LineTabSize = sizeof(_Tab)/sizeof(_Tab[0]);

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

static const double e = 0.001;


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


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

const char *erscribble_line_style_to_str(const ScbLineStyle style)
{
    int i;
    for(i = 0; i < LineTabSize; ++i)
    {
        if (style == _Tab[i].style)
        {
            return _Tab[i].name;
        }
    }
    return NULL;
}


ScbLineStyle erscribble_line_style_from_str(const char * str)
{
    int i;
    for(i = 0; i < LineTabSize; ++i)
    {
        if (0 == strcasecmp(str, _Tab[i].name))
        {
            return _Tab[i].style;
        }
    }
    return ERSCRIBBLE_LINE_INVALID;
}


ScbStrokePtr erscribble_stroke_new()
{
    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;
}


ScbStrokePtr erscribble_stroke_new_with_attributes(ScbStrokeAttributesPtr pAttr)
{
    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;
}


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


int erscribble_stroke_add_point(ScbStrokePtr stroke, ScbDevPointPtr point)
{
    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;
}


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


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


void erscribble_stroke_driver_draw_point(ScbStrokePtr stroke, ScbDevPointPtr point, gboolean is_last_point)
{
    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);
    }
}


void erscribble_stroke_driver_draw(ScbStrokePtr stroke)
{
    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];
        }
    }
}


gboolean erscribble_stroke_point_hit_test(ScbStrokePtr stroke, 
                                   ScbDevPointPtr point,
                                   const ScbHitTestCtxPtr ctx)
{
    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;
}


gboolean erscribble_stroke_line_hit_test(ScbStrokePtr stroke, 
                                  ScbDevPointPtr point1,
                                  ScbDevPointPtr point2,
                                  const ScbHitTestCtxPtr ctx)
{
    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;
}


gboolean erscribble_stroke_load(ScbStrokePtr stroke, ScbStreamPtr stream)
{
    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;
}


gboolean erscribble_stroke_write_stream(ScbStrokePtr stroke, ScbStreamPtr 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;
}


void erscribble_stroke_set_shape(ScbStrokePtr stroke, const int shape_id)
{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.shape_id = shape_id;
}


void erscribble_stroke_set_size(ScbStrokePtr stroke, const int size_id)
{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.size_id = size_id;
}


int erscribble_stroke_get_shape(ScbStrokePtr stroke)
{
    if (NULL == stroke)
    {
        return ERSCRIBBLE_INVALID_SHAPE;
    }

    return stroke->attributes.shape_id;
}


int erscribble_stroke_get_size(ScbStrokePtr stroke)
{
    if (NULL == stroke)
    {
        return ERSCRIBBLE_INVALID_SIZE;
    }

    return stroke->attributes.size_id;
}


void erscribble_stroke_dump(ScbStrokePtr ptr)
{
    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;
    }
}

//----------------------------------------------------------------------------
// Deprecated functions
//----------------------------------------------------------------------------

void erscribble_stroke_set_color(ScbStrokePtr stroke, const ScbDevColor color)
{
    ERSCRIBBLE_RET_IF(NULL == stroke, "Invalid pointer!");
    stroke->attributes.color = color;
}


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