notepad_utils.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_utils.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad 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.
 *
 * notepad 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) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include <algorithm>

#include <glib.h>
#include <glib/gprintf.h>

#include <liberscribble/scb.h> // for ScbDevColor
#include "notepad_utils.h"
#include "log.h"

namespace notepad 
{
    void GCtx::set_color(const ScbDevColor scribblecolor)
    {
        // assume 8 bit depth: 0x00 00 00 .. 0xFF FF FF
        switch (scribblecolor)
        {
            case ERSCRIBBLE_DEV_COLOR_WHITE:
                color = 0xFFFFFF;
                break;
            case ERSCRIBBLE_DEV_COLOR_LIGHT_GRAY:
                color = 0xAAAAAA;
                break;
            case ERSCRIBBLE_DEV_COLOR_DARK_GRAY:
                color = 0x888888; // or 55
                break;
            case ERSCRIBBLE_DEV_COLOR_BLACK:
                color = 0x000000;
                break;
            case ERSCRIBBLE_DEV_COLOR_UNKNOWN:
            default:
                color = 0x000000;
                break;
        }
    }


    void GCtx::draw_line(GdkImage* image, const int x1, const int y1, const int x2, const int y2)
    {
        g_assert(image != 0);

        Point p1(x1, y1);
        Point p2(x2, y2);

        // draw the end point
        draw_brush(image, p2.x, p2.y);

        bool is_steep = abs(p2.y - p1.y) > abs(p2.x - p1.x);
        if (is_steep)
        {
            std::swap(p1.x, p1.y);
            std::swap(p2.x, p2.y);
        }

        // setup line draw
        int deltax   = abs(p2.x - p1.x);
        int deltaerr = abs(p2.y - p1.y);
        int error = 0;
        int x = p1.x;
        int y = p1.y;

        // setup step increment
        int xstep = (p1.x < p2.x) ? 1 : -1;
        int ystep = (p1.y < p2.y) ? 1 : -1;

        if (is_steep)
        {
            // draw swapped line
            for (int numpix = 0; numpix < deltax; numpix++)
            {
                x += xstep;
                error += deltaerr;

                if (2 * error > deltax) 
                {
                    y += ystep;
                    error -= deltax;
                }

                draw_brush(image, y, x);
            }
        }
        else
        {
            // draw normal line
            for (int numpix = 0; numpix < deltax; numpix++)
            {
                x += xstep;
                error += deltaerr;

                if (2 * error > deltax) 
                {
                    y += ystep;
                    error -= deltax;
                }

                draw_brush(image, x, y);
            }
        }

    }


/*
    Below, the different kernel brush shapes are shown as defined in the linux kernel (delta.c).
    0 is the centerpoint of the brush
        
        Defined brushes:

        Brush #1:
                        .......0 0x01
        
        Brush #2:
                        ......O0 0x03
                        ......OO 0x03

        Brush #3:
                        ......O. 0x02
                        .....O0O 0x07
                        ......O. 0x02

        Brush #4:
                        .....OO. 0x06
                        ....OO0O 0x0F
                        ....OOOO 0x0F
                        .....OO. 0x06

        Brush #5:
                        .....O.. 0x04
                        ....OOO. 0x0E
                        ...OO0OO 0x1F
                        ....OOO. 0x0E
                        .....O.. 0x04

        Brush #6:
                        ....OO.. 0x0C
                        ...OOOO. 0x1E
                        ..OOO0OO 0x3F
                        ..OOOOOO 0x3F
                        ...OOOO. 0x1E
                        ....OO.. 0x0C

*/

    void GCtx::draw_brush(GdkImage* image, const int x, const int y)
    {
        g_assert(image != 0);
        // draw a brush of size: this->size
        // at coordinate (x,y)
        gint npoints_in_shape = 0;

        // portrait only for now
        GdkPoint brush1[1]  = { {x,  y  } };
        GdkPoint brush2[4]  = { 
                                {x-1,y  } , {x  ,y  } , 
                                {x-1,y+1} , {x  ,y+1} 
                              };

        GdkPoint brush3[5]  = { 
                                            {x  ,y-1} , 
                                {x-1,y  } , {x  ,y  } , {x+1,y  } , 
                                            {x  ,y+1} 
                              };

        GdkPoint brush4[12] = { 
                                            {x-1,y-1} , {x  ,y-1} , 
                                {x-2,y  } , {x-1,y  } , {x  ,y  } , {x+1,y  }, 
                                {x-2,y+1} , {x-1,y+1} , {x  ,y+1} , {x+1,y+1}, 
                                            {x-1,y+2} , {x  ,y+2} 
                              };

        GdkPoint brush5[13] = { 
                                                        {x  ,y-2} , 
                                            {x-1,y-1} , {x  ,y-1} , {x+1,y-1} , 
                                {x-2,y  } , {x-1,y  } , {x  ,y  } , {x+1,y  } , {x+2,y} ,
                                            {x-1,y+1} , {x  ,y+1} , {x+1,y+1} ,       
                                                        {x  ,y+2} 
                              };

        GdkPoint* shape = NULL;

        switch(size)
        {
            case 1:
                npoints_in_shape = 1;
                shape = brush1;
                break;
            case 2:
                npoints_in_shape = 4;
                shape = brush2;
                break;
            case 3:
                npoints_in_shape = 5;
                shape = brush3;
                break;
            case 4:
                npoints_in_shape = 12;
                shape = brush4;
                break;
            case 5:
                npoints_in_shape = 13;
                shape = brush5;
                break;
            default:
                npoints_in_shape = 13;
                break;

        }
        draw_points(image, shape, npoints_in_shape);
    }

    void GCtx::draw_points(GdkImage* image, const GdkPoint* shape, const int npoints_in_shape)
    {
        g_assert(image != 0);
        g_assert(shape != 0);
        g_assert(npoints_in_shape > 0);

#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        gint w = image->width;
#endif
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
        gint w = image->width - margin;
#endif
        gint h = image->height;

        for (int i = 0; i < npoints_in_shape; i++)
        {
            // filter part of brush out of region
            if (  (shape[i].x > margin && shape[i].x < w) 
               && (shape[i].y > margin && shape[i].y < h) )
            {
                gdk_image_put_pixel(image, shape[i].x, shape[i].y, color);
            }
        }
    }


}