scribble_manager.cpp

Go to the documentation of this file.

/*
 * File Name: scribble_manager.cpp
 */

/*
 * 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.
 */
 
#include <math.h>
#include <string>
#include <cstring>

#include "scribble_manager.h"

namespace test
{

template<class T>
void swap(T & a, T & b)
{
    T tmp = a; a = b; b = tmp;
}

static const float e = 0.001;

ScribbleMgr::ScribbleMgr(void)
: doc(0)
, page(0)
, stroke(0)
, last_absolute_point()
, last_page_point()
, last_page_position()
, dirty_pages()
{
    erscribble_init();
}

ScribbleMgr::~ScribbleMgr(void)
{
    erscribble_uninit();
}

bool ScribbleMgr::open(const char *doc_path)
{
    close();
    
    // check
    if (doc_path == 0)
    {
        printf("Invalid path name pointer!\n");
        return false;
    }

    // keep the path name.
    strncpy(path.document_path, doc_path, ERSCRIBBLE_MAX_PATH);

    // open file
    doc = erscribble_doc_open(&path);

    // if there is no scribble data stored in the data base
    // create a new scribble document
    if (doc == 0)
    {
        doc = erscribble_doc_new(&path);
    }

    return (doc != 0);
}

void ScribbleMgr::close(bool bSave)
{
    // TODO. need save the data of current page
    if (bSave)
    {
        save();
    }

    erscribble_doc_free(doc);
    doc = 0;
    memset(&path, 0, sizeof(path));
    page = 0;
    stroke = 0;
}

bool ScribbleMgr::is_page_dirty(ScbPagePtr page)
{
    DirtyPagesIter idx = dirty_pages.begin();
    for (; idx != dirty_pages.end(); ++idx)
    {
        if (*idx == page)
        {
            return true;
        }
    }
    return false;
}

// Add the page into dirty pages list
// NOTE: This function can only be called after is_page_dirty
void ScribbleMgr::set_page_dirty(ScbPagePtr page)
{
    dirty_pages.push_back(page);
}

void ScribbleMgr::save()
{
    if (doc)
    {
        DirtyPagesIter idx = dirty_pages.begin();
        for (; idx != dirty_pages.end(); ++idx)
        {
            ScbPagePtr ptr = *idx;
            erscribble_doc_save_page(doc, ptr);
        }
        // clear all dirty pages
        dirty_pages.clear();
    }
}

/// Removed should be provded by caller.
/// Should compare PLUGIN_MAX_ANCHOR_LENGTH and erscribble_MAX_PAGEID_LEN.
/// erscribble_MAX_PAGEID_LEN 256
/// PLUGIN_MAX_ANCHOR_LENGTH 1024.
/// It may cause some problem when anchors' first 256 bytes are equal.
/// Quite impossible.
void ScribbleMgr::generate_page_id(ScbPageId & pid, const std::string &anchor, const int pos)
{
    erscribble_page_set_id(&pid, pos, anchor.c_str(), -1);
}

void ScribbleMgr::copy_page_id(ScbPageId & dst, const ScbPageId & src)
{
    erscribble_page_copy_id(&dst, (const ScbPageIdPtr)(&src));
}

void ScribbleMgr::clear_page_id(ScbPageId & pageId)
{
    erscribble_page_reset_id(&pageId);
}

bool ScribbleMgr::is_page_id_empty(const ScbPageId & pageId)
{
    return pageId.id[0] == '\0';
}

bool ScribbleMgr::cmp_page_id(const ScbPageId & src, const ScbPageId & dst)
{
    return 0 == strncmp(src.id, dst.id, ERSCRIBBLE_MAX_PAGEID_LEN);
}

void ScribbleMgr::begin_stroke(const ScbPageId & pageId,
                               ScribbleGC & sgc,
                               const int absoluteX,
                               const int absoluteY,
                               const int offsetX,
                               const int offsetY)
{
    printf("Create new stroke!\n");

    // check page
    page = erscribble_doc_get_page(doc, (const ScbPageIdPtr)(&pageId));
    if (page == 0)
    {
        // does not exist, needs to create a new one
        printf("Page %s does not exist!\n", pageId.id);
        page = erscribble_page_new();
        erscribble_page_copy_id(&page->id, (const ScbPageIdPtr)(&pageId));
        page->attributes.style.orientation = sgc.rotation;

        // add page into dirty list
        set_page_dirty(page);
    }
    else if (!is_page_dirty(page))
    {
        // add page into dirty list
        set_page_dirty(page);
    }

    // check stroke
    if (stroke == 0)
    {
        stroke = erscribble_stroke_new_with_attributes(erscribble_doc_get_current_stroke_attributes(doc));
        stroke->attributes.zoom = sgc.realZoom;
        stroke->attributes.size_id = 3;
        erscribble_page_add_stroke(page, stroke);

        printf("Create new stroke %p!", stroke);
    }

    ScbDevPoint point;
    // stroke point data, in offset
    point.point.x = offsetX;
    point.point.y = offsetY;
    point.pressure = 0;
    erscribble_stroke_add_point(stroke, &point);

    // for drawing, use the absolute position now
    // TODO. Not a good way
    point.point.x = absoluteX;
    point.point.y = absoluteY;
    erscribble_stroke_driver_draw_point(stroke, &point, FALSE);

    // record the page id
    copy_page_id(last_page_id, pageId);

}

void ScribbleMgr::add_point(const ScbPageId & pageId,
                            ScribbleGC & sgc,
                            const int absoluteX,
                            const int absoluteY,
                            const int offsetX,
                            const int offsetY)
{
    ScbDevPoint point;
    point.point.x = offsetX;
    point.point.y = offsetY;
    erscribble_stroke_add_point(stroke, &point);
    
    point.point.x = absoluteX;
    point.point.y = absoluteY;
    erscribble_stroke_driver_draw_point(stroke, &point, FALSE);

}

void ScribbleMgr::end_stroke(const ScbPageId & pageId,
                             ScribbleGC & sgc,
                             const int absoluteX,
                             const int absoluteY,
                             const int offsetX,
                             const int offsetY,
                             const int pageX,
                             const int pageY)
{
    printf("End stroke!");

    ScbDevPoint point;

    // stroke data
    point.point.x = offsetX;
    point.point.y = offsetY;
    erscribble_stroke_add_point(stroke, &point);
    
    // drawing
    point.point.x = absoluteX;
    point.point.y = absoluteY;
    erscribble_stroke_driver_draw_point(stroke, &point, TRUE);
    
    // draw in display
    draw_stroke(stroke, sgc, pageX, pageY);

    // add & reset
    erscribble_doc_add_page(doc, page);
    page = 0;
    stroke = 0;

    // record the page id
    copy_page_id(last_page_id, pageId);

}

// end stroke without adding point
void ScribbleMgr::end_stroke(ScribbleGC & sgc,
                             const int absoluteX, 
                             const int absoluteY,
                             const int pageX,
                             const int pageY)
{
    printf("Finish stroke!");
    ScbDevPoint     point;

    // drawing
    point.point.x = absoluteX;
    point.point.y = absoluteY;
    erscribble_stroke_driver_draw_point(stroke, &point, TRUE);
    
    // draw
    draw_stroke(stroke, sgc, pageX, pageY);
    
    // add & reset
    erscribble_doc_add_page(doc, page);
    page = 0;
    stroke = 0;
}

void ScribbleMgr::on_scribble_begin(const ScbPageId & pageId,
                                    ScribbleGC & sgc,
                                    const int absoluteX,
                                    const int absoluteY,
                                    const int offsetX,
                                    const int offsetY,
                                    const int pageX,
                                    const int pageY)
{
    printf("PageId %s page %p stroke %p!", pageId.id, page, stroke);
    if (!is_page_id_empty(pageId))
    {
        if (page && stroke)
        {
            add_point(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY);
        }
        else if (page == 0 && stroke == 0)
        {
            begin_stroke(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY);
        }

        // record the last point
        last_absolute_point.x = absoluteX;
        last_absolute_point.y = absoluteY;
        last_page_point.x = offsetX;
        last_page_point.y = offsetY;
        last_page_position.x = pageX;
        last_page_position.y = pageY;
    }
}

/// @brief Should consider following situations:
/// - Move from page to window(out of page).
/// - Move from window(out of page) to page.
/// - Move from one page to the other.
void ScribbleMgr::on_scribble_move(const ScbPageId & pageId, 
                                   ScribbleGC & sgc,
                                   const int absoluteX, 
                                   const int absoluteY,      
                                   const int offsetX, 
                                   const int offsetY,
                                   const int pageX,
                                   const int pageY)
{
    // out of page, end stroke now.
    if (is_page_id_empty(pageId) && stroke && page)
    {
        // end without adding it
        end_stroke(sgc, absoluteX, absoluteY, pageX, pageY);
        return;
    }

    bool ret = false;
    // re-enter page bound
    if (!ret && !is_page_id_empty(pageId) && stroke == 0 && page == 0)
    {
        begin_stroke(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY);
        ret = true;
    }

    // from one page to the other, should use old pagex and pagey
    if (!ret && !is_page_id_empty(last_page_id) && 
        !is_page_id_empty(pageId) && 
        !cmp_page_id(pageId, last_page_id) && stroke && page)
    {
        end_stroke(last_page_id, sgc, last_absolute_point.x, last_absolute_point.y
            , last_page_point.x, last_page_point.y, last_page_position.x, last_page_position.y);
        begin_stroke(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY);
        ret = true;
    }

    // scribble mode
    if (!ret && stroke)
    {
        add_point(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY);
        // record the last point
        last_absolute_point.x = absoluteX;
        last_absolute_point.y = absoluteY;
        last_page_point.x = offsetX;
        last_page_point.y = offsetY;
        last_page_position.x = pageX;
        last_page_position.y = pageY;
        ret = true;
    }
}

void ScribbleMgr::on_scribble_end(const ScbPageId & pageId,
                                  ScribbleGC & sgc,
                                  const int absoluteX,
                                  const int absoluteY,
                                  const int offsetX,
                                  const int offsetY,
                                  const int pageX,
                                  const int pageY)
{
    if (!is_page_id_empty(pageId) && stroke && doc && page)
    {
        end_stroke(pageId, sgc, absoluteX, absoluteY, offsetX, offsetY, pageX, pageY);
        // record the last point
        last_absolute_point.x = absoluteX;
        last_absolute_point.y = absoluteY;
        last_page_point.x = offsetX;
        last_page_point.y = offsetY;
        last_page_position.x = pageX;
        last_page_position.y = pageY;
    }
}

/// When erasing, no need to check whether or not go into another page
void ScribbleMgr::on_erase_begin(const ScbPageId & pageId,
                                 ScribbleGC & sgc,
                                 const int absoluteX,
                                 const int absoluteY,
                                 const int offsetX,
                                 const int offsetY,
                                 const int pageX,
                                 const int pageY)
{
    if (is_page_id_empty(pageId))
    {
        return;
    }

    // prepare for erasing.
    erscribble_page_erase_init(&erase_context);
    page = erscribble_doc_get_page(doc, (const ScbPageIdPtr)(&pageId));
    if (page == 0)
    {
        return;
    }

    // record
    copy_page_id(last_page_id, pageId);

    ScbDevPoint point;
    point.point.x = offsetX, point.point.y = offsetY;
    erase_context.zoom = sgc.realZoom;
    ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);
    if (strokes)
    {
        printf("Erase strokes!");

        // draw and free
        if (sgc.rotation == 270)
        {
            draw_erased_strokes_landscape(strokes, sgc, pageX, pageY);
        }
        else
        {
            draw_erased_strokes_portrait(strokes, sgc, pageX, pageY);
        }

        // free
        erscribble_strokes_free(strokes);
    }
}

void ScribbleMgr::on_erase_move(const ScbPageId & pageId,
                                ScribbleGC & sgc,
                                const int absoluteX,
                                const int absoluteY,
                                const int offsetX,
                                const int offsetY,
                                const int pageX,
                                const int pageY)
{
    if (is_page_id_empty(pageId))
    {
        return;
    }

    if (!cmp_page_id(last_page_id, pageId))
    {
        copy_page_id(last_page_id, pageId);
        erscribble_page_erase_init(&erase_context);
        erase_context.zoom = sgc.realZoom;
    }

    page = erscribble_doc_get_page(doc, (const ScbPageIdPtr)(&pageId));
    if (page == 0)
    {
        return;
    }

    ScbDevPoint point;
    point.point.x = offsetX; point.point.y = offsetY;

    ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);
    if (strokes)
    {
        printf("Erase strokes!");
        if (sgc.rotation == 270)
        {
            draw_erased_strokes_landscape(strokes, sgc, pageX, pageY);
        }
        else
        {
            draw_erased_strokes_portrait(strokes, sgc, pageX, pageY);
        }

        // free 
        erscribble_strokes_free(strokes);
    }
}

void ScribbleMgr::clear_page(const ScbPageId &pageId) 
{
    ScbPagePtr page;
    page = erscribble_doc_get_page(doc, (const ScbPageIdPtr)(&pageId));
    if (page == 0)
    {
        printf("no page to erase\n");
        return;
    }
    erscribble_page_clear_strokes(page);
}

void ScribbleMgr::on_erase_end(const ScbPageId & pageId, 
                               ScribbleGC & sgc,
                               const int absoluteX, 
                               const int absoluteY,      
                               const int offsetX, 
                               const int offsetY,
                               const int pageX,
                               const int pageY)
{
    if (is_page_id_empty(pageId) || page == 0)
    {
        return;
    }

    ScbDevPoint point;
    point.point.x = offsetX;
    point.point.y = offsetY;
    ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);

    if (!is_page_dirty(page))
    {
        // add page into dirty list
        set_page_dirty(page);
    }

    // reset
    page = 0;
    if (strokes) 
    {
        printf("Erase strokes!");
        if (sgc.rotation == 270)
        {
            draw_erased_strokes_landscape(strokes, sgc, pageX, pageY);
        }
        else
        {
            draw_erased_strokes_portrait(strokes, sgc, pageX, pageY);
        }

        // draw and free
        erscribble_strokes_free(strokes);
    }
}

//////////////////////////////////////////////////////////////////////////
// x & y is the page start position in screen
void ScribbleMgr::draw_scribble_page(const ScbPageId & pageId,
                                     ScribbleGC & sgc,
                                     const int pageX, 
                                     const int pageY)
{

    // page from page id
    ScbPagePtr ptr = erscribble_doc_get_page(doc, (const ScbPageIdPtr)(&pageId));
    if (ptr == 0)
    {
        printf("page %s not found!", pageId.id);
        return;
    }

    if (sgc.rotation == 270)
    {
        draw_scribble_page_landscape(ptr, sgc, pageX, pageY);
    }
    else
    {
        draw_scribble_page_portrait(ptr, sgc, pageX, pageY);
    }
}

// should not exceed the max pen line size.
int ScribbleMgr::calc_line_size(const int penSize, 
                                const float strokeZoom, 
                                const float dispZoom)
{
    if (fabs(strokeZoom - dispZoom) < e)
    {
        return penSize;
    }
    int ret = (int)(penSize * strokeZoom / dispZoom);
    if (ret < 1)
    {
        return 1;
    }
    else if (ret > 10) 
    {
        return 10;
    }
    return ret;
}

void ScribbleMgr::draw_scribble_page_portrait(ScbPagePtr page,
                                              ScribbleGC & sgc,
                                              const int pageX,
                                              const int pageY)
{
    ScbStrokesPtr strokes = erscribble_page_get_strokes(page);
    float z = sgc.realZoom;
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // point data
                int count  = erscribble_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);

                // select color. 
                ScbColor color;
                erscribble_dev_color_to_color(&color, stroke->attributes.color);
                sgc.set_line_color(color.pixel);

                // select line width and line style.
                sgc.set_line_attributes(calc_line_size(stroke->attributes.size_id, z, stroke->attributes.zoom));

                // draw lines now
                if (fabs(z - stroke->attributes.zoom) < e)
                {
                    int i = 0;
                    int x1 = pageX + pts[i].x, y1 = pageY + pts[i].y; ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = pageX + pts[i].x, y2 = pageY + pts[i].y; ++i;
                        sgc.draw_line(x1, y1, x2, y2);
                        x1 = x2; y1 = y2;
                    }
                    
                    if (count <= 1)
                    {
                        sgc.draw_line(x1, y1, x1, y1);
                    }
                }
                else
                {
                    float ratio = z / stroke->attributes.zoom;
                    int i = 0;
                    int x1 = pageX + (int)(ratio * pts[i].x), y1 = pageY + (int)(ratio * pts[i].y); ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = pageX + (int)(ratio * pts[i].x); y2 = pageY + (int)(ratio * pts[i].y); ++i;
                        sgc.draw_line(x1, y1, x2, y2);
                        x1 = x2; y1 = y2;
                    }

                    if (count <= 1)
                    {
                        sgc.draw_line(x1, y1, x1, y1);
                    }
                }
            }
            ptr = g_list_next(ptr);
        }
    }
}

void ScribbleMgr::draw_scribble_page_landscape(ScbPagePtr page, 
                                               ScribbleGC & sgc, 
                                               const int pageX, 
                                               const int pageY)
{
    ScbStrokesPtr strokes = erscribble_page_get_strokes(page);
    float z = sgc.realZoom;
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // point data
                int count  = erscribble_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);

                // select color.
                ScbColor color;
                erscribble_dev_color_to_color(&color, stroke->attributes.color);
                sgc.set_line_color(color.pixel);

                // select pen size
                sgc.set_line_attributes(calc_line_size(stroke->attributes.size_id, z, stroke->attributes.zoom));

                // draw lines now
                if (fabs(z - stroke->attributes.zoom) < e)
                {
                    int i = 0;
                    int x1 = pageY - pts[i].x,
                        y1 = pageX + pts[i].y; ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = pageY - pts[i].x,
                        y2 = pageX + pts[i].y; ++i;
                        sgc.draw_line(y1, x1, y2, x2);  // swap
                        x1 = x2; y1 = y2;
                    }
                    
                    // single point
                    if (1 >= count)
                    {
                        sgc.draw_line(y1, x1, y1, x1);
                    }
                }
                else
                {
                    float ratio = z / stroke->attributes.zoom;
                    int i = 0;
                    int x1 = pageY - (int)(ratio * pts[i].x),
                        y1 = pageX + (int)(ratio * pts[i].y);
                    ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = pageY - (int)(ratio * pts[i].x),
                        y2 = pageX + (int)(ratio * pts[i].y);
                        ++i;
                        sgc.draw_line(y1, x1, y2, x2);
                        x1 = x2; y1 = y2;
                    }

                    // single point
                    if (1 >= count)
                    {
                        sgc.draw_line(y1, x1, y1, x1);
                    }
                }
            }
            ptr = g_list_next(ptr);
        }
    }
}

//////////////////////////////////////////////////////////////////////////
// redraw stroke by driver
void ScribbleMgr::draw_erased_strokes_portrait(ScbStrokesPtr strokes,
                                            ScribbleGC & sgc, 
                                            const int pageX, 
                                            const int pageY)
{
    printf("Going to draw erased strokes %p!", strokes);
    float z = sgc.realZoom;
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // adjust position
                int count  = erscribble_stroke_get_point_count(stroke);
                printf("Going to draw erased stroke %p count %d now!", stroke, count);
                ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);
                
                // draw                
                if (fabs(z - stroke->attributes.zoom) < e)
                {
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x += pageX, pts[i].y += pageY; ++i;
                    }                        
                }
                else
                {
                    float ratio = z / stroke->attributes.zoom;
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = pageX + (int)(pts[i].x * ratio);
                        pts[i].y = pageY + (int)(pts[i].y * ratio);
                        ++i;
                    }                        
                }
                stroke->attributes.color = ERSCRIBBLE_DEV_COLOR_WHITE;
                erscribble_stroke_driver_draw(stroke);
                draw_stroke_directly(stroke, sgc);                
            }
            ptr = g_list_next(ptr);
        }
    }
}

void ScribbleMgr::draw_erased_strokes_landscape(ScbStrokesPtr strokes,
                                             ScribbleGC & sgc, 
                                             const int pageX, 
                                             const int pageY)
{
    printf("Going to draw erased strokes %p!", strokes);
    float z = sgc.realZoom;
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                printf("Going to draw erased stroke now %p!", stroke);
                // adjust position
                int count  = erscribble_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);
                
                // draw                
                if (fabs(z - stroke->attributes.zoom) < e)
                {
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = pageY - pts[i].x;
                        pts[i].y = pageX + pts[i].y;
                        swap(pts[i].x, pts[i].y);
                        ++i;
                    }                        
                }
                else
                {
                    float ratio = z / stroke->attributes.zoom;
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = pageY - (int)(pts[i].x * ratio);
                        pts[i].y = pageX + (int)(pts[i].y * ratio);
                        swap(pts[i].x, pts[i].y);
                        ++i;
                    }                        
                }
                stroke->attributes.color = ERSCRIBBLE_DEV_COLOR_WHITE;
                erscribble_stroke_driver_draw(stroke);
                printf("Draw stroke on gdk screen!");                
                draw_stroke_directly(stroke, sgc);
            }
            ptr = g_list_next(ptr);
        }
    }
}

void ScribbleMgr::draw_stroke(ScbStrokePtr stroke, 
                              ScribbleGC & sgc, 
                              const int pageX, 
                              const int pageY)
{
    if (sgc.rotation == 0)
    {
        // point data
        int count  = erscribble_stroke_get_point_count(stroke);
        ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);

        // select color. 
        ScbColor color;
        erscribble_dev_color_to_color(&color, stroke->attributes.color);
        sgc.set_line_color(color.pixel);

        // select pen size
        sgc.set_line_attributes(stroke->attributes.size_id);

        int i = 0;
        int x1 = pageX + pts[i].x, y1 = pageY + pts[i].y; ++i;
        int x2, y2;

        while (i < count)
        {
            x2 = pageX + pts[i].x, y2 = pageY + pts[i].y; ++i;
            sgc.draw_line(x1, y1, x2, y2);
            x1 = x2; y1 = y2;
        }
        
        if (count <= 1)
        {
            sgc.draw_line(x1, y1, x1, y1);
        }            
    }
    else if (sgc.rotation == 270)
    {
        // point data
        int count  = erscribble_stroke_get_point_count(stroke);
        ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);

        // select color. 
        ScbColor color;
        erscribble_dev_color_to_color(&color, stroke->attributes.color);
        sgc.set_line_color(color.pixel);

        // select pen size
        sgc.set_line_attributes(stroke->attributes.size_id);
        int i = 0;
        int x1 = pageY - pts[i].x, y1 = pageX + pts[i].y; ++i;
        int x2, y2;
        while (i < count)
        {
            x2 = pageY - pts[i].x, y2 = pageX + pts[i].y; ++i;
            sgc.draw_line(y1, x1, y2, x2);    // swap x & y
            x1 = x2; y1 = y2;
        }
         
        if (count <= 1)
        {
            sgc.draw_line(y1, x1, y1, x1);
        }            
    }
}

void ScribbleMgr::draw_stroke_directly(ScbStrokePtr stroke, 
                                     ScribbleGC & sgc)               
{
    // point data
    int count  = erscribble_stroke_get_point_count(stroke);
    ScbPoint * pts = (ScbPoint *)erscribble_stroke_get_point_data(stroke);

    // select color. 
    ScbColor color;
    erscribble_dev_color_to_color(&color, stroke->attributes.color);
    sgc.set_line_color(color.pixel);

    // select pen size
    sgc.set_line_attributes(stroke->attributes.size_id);

    printf("Lines count %d!", count - 1);
    for(int i = 0; i < count - 1; ++i)
    {
        sgc.draw_line(pts[i].x, pts[i].y, pts[i + 1].x, pts[i + 1].y);
    }
}

}//namespace test