notepad::GCtx Class Reference

#include <notepad_utils.h>

Public Member Functions
	GCtx ()
	~GCtx ()
void	set_color (const ScbDevColor c)
void	set_line_attributes (const int width)
	Change the X11 gc to use new line attributes. Currently, only change the width. Always use LineSolid.
void	draw_line (GdkImage *image, const int x1, const int y1, const int x2, const int y2)
	Draw line on image by using current line color, line width and line style.
void	draw_line (GdkImage *image, const ScbPoint &p1, const ScbPoint &p2)
void	draw_brush (GdkImage *image, const int x, const int y)
void	draw_points (GdkImage *image, const GdkPoint *shape, const int npoints_in_shape)
Data Fields
GdkGC *	gc
	X11 graphics context.
np_rotation	rotation
	rotation
int	width
	width, max y when in landscape, max x otherwise
int	height
	height, max x when in landscape, max y otherwise
int	margin
	border

---

Detailed Description

Definition at line 67 of file notepad_utils.h.

---

Constructor & Destructor Documentation

notepad::GCtx::GCtx

(

)

[inline]

Definition at line 80 of file notepad_utils.h.

                : size(0)
                , gc(0)
                , rotation(NP_PORTRAIT)
                , width(0)
                , height(0)
                , margin(0)
            {
            }

notepad::GCtx::~GCtx

(

)

[inline]

Definition at line 90 of file notepad_utils.h.

References gc.

            {
                if (gc) { g_object_unref(gc); gc = 0; } 
            }

---

Member Function Documentation

void notepad::GCtx::draw_brush	(	GdkImage *	image,
		const int	x,
		const int	y
	)

Definition at line 170 of file notepad_utils.cpp.

References draw_points().

Referenced by draw_line().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::GCtx::draw_line	(	GdkImage *	image,
		const ScbPoint &	p1,
		const ScbPoint &	p2
	)			[inline]

Definition at line 121 of file notepad_utils.h.

References draw_line(), _ScbPoint::x, and _ScbPoint::y.

            {
                draw_line(image, p1.x, p1.y, p2.x, p2.y);
            }

Here is the call graph for this function:

void notepad::GCtx::draw_line	(	GdkImage *	image,
		const int	x1,
		const int	y1,
		const int	x2,
		const int	y2
	)

Draw line on image by using current line color, line width and line style.

Definition at line 63 of file notepad_utils.cpp.

References draw_brush(), test::swap(), notepad::Point::x, and notepad::Point::y.

Referenced by draw_line().

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

    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::GCtx::draw_points	(	GdkImage *	image,
		const GdkPoint *	shape,
		const int	npoints_in_shape
	)

Definition at line 237 of file notepad_utils.cpp.

References margin.

Referenced by draw_brush().

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

Here is the caller graph for this function:

void notepad::GCtx::set_color

(

const ScbDevColor

c

)

Definition at line 38 of file notepad_utils.cpp.

References ERSCRIBBLE_DEV_COLOR_BLACK, ERSCRIBBLE_DEV_COLOR_DARK_GRAY, ERSCRIBBLE_DEV_COLOR_LIGHT_GRAY, ERSCRIBBLE_DEV_COLOR_UNKNOWN, and ERSCRIBBLE_DEV_COLOR_WHITE.

    {
        // 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 notepad::GCtx::set_line_attributes

(

const int

width

)

[inline]

Change the X11 gc to use new line attributes. Currently, only change the width. Always use LineSolid.

Definition at line 106 of file notepad_utils.h.

References gc.

            {
                this->size = width ;

                gdk_gc_set_line_attributes(gc
                        , this->size
                        , GDK_LINE_SOLID
                        , GDK_CAP_PROJECTING
                        , GDK_JOIN_MITER);
            }

---

Field Documentation

GdkGC* notepad::GCtx::gc

X11 graphics context.

Definition at line 74 of file notepad_utils.h.

Referenced by notepad::CNotepadWindow::init(), set_line_attributes(), notepad::CNotepadWindow::update(), notepad::CNotepadWindow::~CNotepadWindow(), and ~GCtx().

int notepad::GCtx::height

height, max x when in landscape, max y otherwise

Definition at line 77 of file notepad_utils.h.

Referenced by notepad::CNotepadWindow::save(), and notepad::CNotepadWindow::set_rotation().

int notepad::GCtx::margin

border

Definition at line 78 of file notepad_utils.h.

Referenced by draw_points(), notepad::CNotepadWindow::quit(), notepad::CNotepadWindow::save(), and notepad::CNotepadWindow::set_rotation().

np_rotation notepad::GCtx::rotation

rotation

Definition at line 75 of file notepad_utils.h.

Referenced by notepad::CNotepadWindow::set_rotation().

int notepad::GCtx::width

width, max y when in landscape, max x otherwise

Definition at line 76 of file notepad_utils.h.

Referenced by notepad::CNotepadWindow::save(), and notepad::CNotepadWindow::set_rotation().

---

The documentation for this class was generated from the following files:

• notepad_utils.h
• notepad_utils.cpp