gui_draw.h-Dateireferenz

#include "conf.h"
#include "palette.h"

Include-Abhängigkeitsdiagramm für gui_draw.h:

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	icon_cmd

Makrodefinitionen
#define	IDX_COLOR_TRANSPARENT   0
#define	IDX_COLOR_BLACK   1
#define	IDX_COLOR_WHITE   2
#define	IDX_COLOR_RED   3
#define	IDX_COLOR_RED_DK   4
#define	IDX_COLOR_RED_LT   5
#define	IDX_COLOR_GREEN   6
#define	IDX_COLOR_GREEN_DK   7
#define	IDX_COLOR_GREEN_LT   8
#define	IDX_COLOR_BLUE   9
#define	IDX_COLOR_BLUE_DK   10
#define	IDX_COLOR_BLUE_LT   11
#define	IDX_COLOR_GREY   12
#define	IDX_COLOR_GREY_DK   13
#define	IDX_COLOR_GREY_LT   14
#define	IDX_COLOR_YELLOW   15
#define	IDX_COLOR_YELLOW_DK   16
#define	IDX_COLOR_YELLOW_LT   17
#define	IDX_COLOR_GREY_DK_TRANS   18
#define	IDX_COLOR_MAGENTA   19
#define	IDX_COLOR_CYAN   IDX_COLOR_BLUE_LT
#define	IDX_COLOR_MAX   19
#define	COLOR_WHITE   (chdk_colors[IDX_COLOR_WHITE])
#define	COLOR_RED   (chdk_colors[IDX_COLOR_RED])
#define	COLOR_RED_DK   (chdk_colors[IDX_COLOR_RED_DK])
#define	COLOR_RED_LT   (chdk_colors[IDX_COLOR_RED_LT])
#define	COLOR_GREEN   (chdk_colors[IDX_COLOR_GREEN])
#define	COLOR_GREEN_DK   (chdk_colors[IDX_COLOR_GREEN_DK])
#define	COLOR_GREEN_LT   (chdk_colors[IDX_COLOR_GREEN_LT])
#define	COLOR_BLUE   (chdk_colors[IDX_COLOR_BLUE])
#define	COLOR_BLUE_DK   (chdk_colors[IDX_COLOR_BLUE_DK])
#define	COLOR_BLUE_LT   (chdk_colors[IDX_COLOR_BLUE_LT])
#define	COLOR_GREY   (chdk_colors[IDX_COLOR_GREY])
#define	COLOR_GREY_DK   (chdk_colors[IDX_COLOR_GREY_DK])
#define	COLOR_GREY_LT   (chdk_colors[IDX_COLOR_GREY_LT])
#define	COLOR_YELLOW   (chdk_colors[IDX_COLOR_YELLOW])
#define	COLOR_YELLOW_DK   (chdk_colors[IDX_COLOR_YELLOW_DK])
#define	COLOR_YELLOW_LT   (chdk_colors[IDX_COLOR_YELLOW_LT])
#define	COLOR_GREY_DK_TRANS   (chdk_colors[IDX_COLOR_GREY_DK_TRANS])
#define	COLOR_MAGENTA   (chdk_colors[IDX_COLOR_MAGENTA])
#define	COLOR_CYAN   (chdk_colors[IDX_COLOR_CYAN])
#define	FONT_REAL_WIDTH   8
#define	FONT_REAL_HEIGHT   16
#define	FONT_WIDTH   8
#define	FONT_HEIGHT   16
#define	DEFAULT_SYMBOL_FILE   "A/CHDK/SYMBOLS/icon_10.rbf"
#define	TEXT_LEFT   0
#define	TEXT_CENTER   1
#define	TEXT_RIGHT   2
#define	TEXT_FILL   16
#define	RECT_BORDER0   0
#define	RECT_BORDER1   1
#define	RECT_BORDER2   2
#define	RECT_BORDER3   3
#define	RECT_BORDER4   4
#define	RECT_BORDER5   5
#define	RECT_BORDER6   6
#define	RECT_BORDER7   7
#define	RECT_BORDER_MASK   7
#define	DRAW_FILLED   8
#define	RECT_SHADOW0   0
#define	RECT_SHADOW1   0x10
#define	RECT_SHADOW2   0x20
#define	RECT_SHADOW3   0x30
#define	RECT_SHADOW_MASK   0x30
#define	RECT_ROUND_CORNERS   0x40

Aufzählungen
enum	icon_actions {   IA_END, IA_HLINE, IA_VLINE, IA_LINE,   IA_RECT, IA_FILLED_RECT, IA_ROUND_RECT, IA_FILLED_ROUND_RECT }

Funktionen
void	draw_init ()
void	draw_set_draw_proc (void(*pixel_proc)(unsigned int offset, color cl))
void	update_draw_proc ()
void	draw_set_guard ()
int	draw_test_guard ()
color	draw_get_pixel (coord x, coord y)
void	draw_pixel (coord x, coord y, color cl)
void	draw_or_erase_edge_pixel (coord x, coord y, color cl, int is_draw)
void	draw_dblpixel_raw (unsigned int offset, unsigned int px, unsigned int op)
void	erase_zebra ()
unsigned int	color_to_rawpx (color cl, unsigned int *op)
void	draw_line (coord x1, coord y1, coord x2, coord y2, color cl)
void	draw_hline (coord x, coord y, int len, color cl)
void	draw_vline (coord x, coord y, int len, color cl)
void	draw_rectangle (coord x1, coord y1, coord x2, coord y2, twoColors cl, int flags)
void	draw_ellipse (coord xc, coord yc, unsigned int a, unsigned int b, color cl, int flags)
int	text_dimensions (const char *s, int width, int max_chars, int *max_lines)
void	draw_char (coord x, coord y, const char ch, twoColors cl)
int	draw_string_clipped (coord x, coord y, const char *s, twoColors cl, int max_width)
int	draw_string (coord x, coord y, const char *s, twoColors cl)
int	draw_string_justified (coord x, coord y, const char *s, twoColors cl, int xo, int max_width, int justification)
int	draw_text_justified (coord x, coord y, const char *s, twoColors cl, int max_chars, int max_lines, int justification)
void	draw_string_scaled (coord x, coord y, const char *s, twoColors cl, int xsize, int ysize)
void	draw_osd_string (OSD_pos pos, int xo, int yo, char *s, twoColors c, OSD_scale scale)
void	draw_button (int x, int y, int w, int str_id, int active)
void	draw_txt_string (coord col, coord row, const char *str, twoColors cl)
void	draw_suspend (int ms)
int	draw_is_suspended (void)
void	draw_restore ()
color	get_script_color (int cl)
color	chdkColorToCanonColor (chdkColor c)
twoColors	user_color (confColor c)
void	draw_icon_cmds (coord x, coord y, icon_cmd *cmds)

Variablen
unsigned char *	chdk_colors

Makro-Dokumentation

#define COLOR_BLUE   (chdk_colors[IDX_COLOR_BLUE])

Definiert in Zeile 42 der Datei gui_draw.h.

#define COLOR_BLUE_DK   (chdk_colors[IDX_COLOR_BLUE_DK])

Definiert in Zeile 43 der Datei gui_draw.h.

#define COLOR_BLUE_LT   (chdk_colors[IDX_COLOR_BLUE_LT])

Definiert in Zeile 44 der Datei gui_draw.h.

#define COLOR_CYAN   (chdk_colors[IDX_COLOR_CYAN])

Definiert in Zeile 53 der Datei gui_draw.h.

#define COLOR_GREEN   (chdk_colors[IDX_COLOR_GREEN])

Definiert in Zeile 39 der Datei gui_draw.h.

#define COLOR_GREEN_DK   (chdk_colors[IDX_COLOR_GREEN_DK])

Definiert in Zeile 40 der Datei gui_draw.h.

#define COLOR_GREEN_LT   (chdk_colors[IDX_COLOR_GREEN_LT])

Definiert in Zeile 41 der Datei gui_draw.h.

#define COLOR_GREY   (chdk_colors[IDX_COLOR_GREY])

Definiert in Zeile 45 der Datei gui_draw.h.

#define COLOR_GREY_DK   (chdk_colors[IDX_COLOR_GREY_DK])

Definiert in Zeile 46 der Datei gui_draw.h.

#define COLOR_GREY_DK_TRANS   (chdk_colors[IDX_COLOR_GREY_DK_TRANS])

Definiert in Zeile 51 der Datei gui_draw.h.

#define COLOR_GREY_LT   (chdk_colors[IDX_COLOR_GREY_LT])

Definiert in Zeile 47 der Datei gui_draw.h.

#define COLOR_MAGENTA   (chdk_colors[IDX_COLOR_MAGENTA])

Definiert in Zeile 52 der Datei gui_draw.h.

#define COLOR_RED   (chdk_colors[IDX_COLOR_RED])

Definiert in Zeile 36 der Datei gui_draw.h.

#define COLOR_RED_DK   (chdk_colors[IDX_COLOR_RED_DK])

Definiert in Zeile 37 der Datei gui_draw.h.

#define COLOR_RED_LT   (chdk_colors[IDX_COLOR_RED_LT])

Definiert in Zeile 38 der Datei gui_draw.h.

#define COLOR_WHITE   (chdk_colors[IDX_COLOR_WHITE])

Definiert in Zeile 35 der Datei gui_draw.h.

#define COLOR_YELLOW   (chdk_colors[IDX_COLOR_YELLOW])

Definiert in Zeile 48 der Datei gui_draw.h.

#define COLOR_YELLOW_DK   (chdk_colors[IDX_COLOR_YELLOW_DK])

Definiert in Zeile 49 der Datei gui_draw.h.

#define COLOR_YELLOW_LT   (chdk_colors[IDX_COLOR_YELLOW_LT])

Definiert in Zeile 50 der Datei gui_draw.h.

#define DEFAULT_SYMBOL_FILE   "A/CHDK/SYMBOLS/icon_10.rbf"

Definiert in Zeile 64 der Datei gui_draw.h.

#define DRAW_FILLED   8

Definiert in Zeile 91 der Datei gui_draw.h.

#define FONT_HEIGHT   16

Definiert in Zeile 62 der Datei gui_draw.h.

#define FONT_REAL_HEIGHT   16

Definiert in Zeile 57 der Datei gui_draw.h.

#define FONT_REAL_WIDTH   8

Definiert in Zeile 56 der Datei gui_draw.h.

#define FONT_WIDTH   8

Definiert in Zeile 61 der Datei gui_draw.h.

#define IDX_COLOR_BLACK   1

Definiert in Zeile 12 der Datei gui_draw.h.

#define IDX_COLOR_BLUE   9

Definiert in Zeile 20 der Datei gui_draw.h.

#define IDX_COLOR_BLUE_DK   10

Definiert in Zeile 21 der Datei gui_draw.h.

#define IDX_COLOR_BLUE_LT   11

Definiert in Zeile 22 der Datei gui_draw.h.

#define IDX_COLOR_CYAN   IDX_COLOR_BLUE_LT

Definiert in Zeile 31 der Datei gui_draw.h.

#define IDX_COLOR_GREEN   6

Definiert in Zeile 17 der Datei gui_draw.h.

#define IDX_COLOR_GREEN_DK   7

Definiert in Zeile 18 der Datei gui_draw.h.

#define IDX_COLOR_GREEN_LT   8

Definiert in Zeile 19 der Datei gui_draw.h.

#define IDX_COLOR_GREY   12

Definiert in Zeile 23 der Datei gui_draw.h.

#define IDX_COLOR_GREY_DK   13

Definiert in Zeile 24 der Datei gui_draw.h.

#define IDX_COLOR_GREY_DK_TRANS   18

Definiert in Zeile 29 der Datei gui_draw.h.

#define IDX_COLOR_GREY_LT   14

Definiert in Zeile 25 der Datei gui_draw.h.

#define IDX_COLOR_MAGENTA   19

Definiert in Zeile 30 der Datei gui_draw.h.

#define IDX_COLOR_MAX   19

Definiert in Zeile 33 der Datei gui_draw.h.

#define IDX_COLOR_RED   3

Definiert in Zeile 14 der Datei gui_draw.h.

#define IDX_COLOR_RED_DK   4

Definiert in Zeile 15 der Datei gui_draw.h.

#define IDX_COLOR_RED_LT   5

Definiert in Zeile 16 der Datei gui_draw.h.

#define IDX_COLOR_TRANSPARENT   0

Definiert in Zeile 11 der Datei gui_draw.h.

#define IDX_COLOR_WHITE   2

Definiert in Zeile 13 der Datei gui_draw.h.

#define IDX_COLOR_YELLOW   15

Definiert in Zeile 26 der Datei gui_draw.h.

#define IDX_COLOR_YELLOW_DK   16

Definiert in Zeile 27 der Datei gui_draw.h.

#define IDX_COLOR_YELLOW_LT   17

Definiert in Zeile 28 der Datei gui_draw.h.

#define RECT_BORDER0   0

Definiert in Zeile 82 der Datei gui_draw.h.

#define RECT_BORDER1   1

Definiert in Zeile 83 der Datei gui_draw.h.

#define RECT_BORDER2   2

Definiert in Zeile 84 der Datei gui_draw.h.

#define RECT_BORDER3   3

Definiert in Zeile 85 der Datei gui_draw.h.

#define RECT_BORDER4   4

Definiert in Zeile 86 der Datei gui_draw.h.

#define RECT_BORDER5   5

Definiert in Zeile 87 der Datei gui_draw.h.

#define RECT_BORDER6   6

Definiert in Zeile 88 der Datei gui_draw.h.

#define RECT_BORDER7   7

Definiert in Zeile 89 der Datei gui_draw.h.

#define RECT_BORDER_MASK   7

Definiert in Zeile 90 der Datei gui_draw.h.

#define RECT_ROUND_CORNERS   0x40

Definiert in Zeile 97 der Datei gui_draw.h.

#define RECT_SHADOW0   0

Definiert in Zeile 92 der Datei gui_draw.h.

#define RECT_SHADOW1   0x10

Definiert in Zeile 93 der Datei gui_draw.h.

#define RECT_SHADOW2   0x20

Definiert in Zeile 94 der Datei gui_draw.h.

#define RECT_SHADOW3   0x30

Definiert in Zeile 95 der Datei gui_draw.h.

#define RECT_SHADOW_MASK   0x30

Definiert in Zeile 96 der Datei gui_draw.h.

#define TEXT_CENTER   1

Definiert in Zeile 77 der Datei gui_draw.h.

#define TEXT_FILL   16

Definiert in Zeile 79 der Datei gui_draw.h.

#define TEXT_LEFT   0

Definiert in Zeile 76 der Datei gui_draw.h.

#define TEXT_RIGHT   2

Definiert in Zeile 78 der Datei gui_draw.h.

Dokumentation der Aufzählungstypen

enum icon_actions

Aufzählungswerte
IA_END
IA_HLINE
IA_VLINE
IA_LINE
IA_RECT
IA_FILLED_RECT
IA_ROUND_RECT
IA_FILLED_ROUND_RECT

Definiert in Zeile 149 der Datei gui_draw.h.

{
    IA_END,
    IA_HLINE,
    IA_VLINE,
    IA_LINE,
    IA_RECT,
    IA_FILLED_RECT,
    IA_ROUND_RECT,
    IA_FILLED_ROUND_RECT
};

Dokumentation der Funktionen

color chdkColorToCanonColor

(

chdkColor

c)

Definiert in Zeile 1672 der Datei gui_draw.c.

{
    if (col.type)
        return chdk_colors[col.col];
    return col.col;
}

unsigned int color_to_rawpx	(	color	cl,
		unsigned int *	op
	)

void draw_button	(	int	x,
		int	y,
		int	w,
		int	str_id,
		int	active
	)

Definiert in Zeile 1554 der Datei gui_draw.c.

{
    twoColors cl = MAKE_COLOR((active) ? COLOR_RED : COLOR_BLACK, COLOR_WHITE);
    w = w * FONT_WIDTH;

    draw_rectangle(x-2, y-2, x+w+2, y+FONT_HEIGHT+2, cl, RECT_BORDER1|DRAW_FILLED|RECT_SHADOW1);     // main box
    draw_string(x+((w-(strlen(lang_str(str_id))*FONT_WIDTH))>>1), y, lang_str(str_id), cl);
}

void draw_char	(	coord	x,
		coord	y,
		const char	ch,
		twoColors	cl
	)

Definiert in Zeile 890 der Datei gui_draw.c.

{
    unsigned i, ii;

    unsigned int offset, size;
    unsigned char *sym = get_cdata(&offset, &size, ch);

    // First draw blank lines at top
    for (i=0; i<offset; i++)
        draw_hline(x, y+i, FONT_WIDTH, BG_COLOR(cl));

    // Now draw character data

    unsigned j;
    for (j=i; i<size;)
    {
        unsigned int dsym;
        int rep;
#ifdef BUILTIN_FONT_RLE_COMPRESSED
        dsym = fontdata_lookup[sym[j] & 0x7f];
        rep = sym[j] & 0x80;
#else
        dsym = sym[j];
        rep = 0;
#endif
        for (ii=0; ii<FONT_WIDTH; ii++)
        {
            draw_pixel(x+ii, y+i, (dsym & (0x80>>ii))? FG_COLOR(cl) : BG_COLOR(cl));
        }
        if (rep)
        {
            i++;
            for (ii=0; ii<FONT_WIDTH; ii++)
            {
                draw_pixel(x+ii, y+i, (dsym & (0x80>>ii))? FG_COLOR(cl) : BG_COLOR(cl));
            }
        }
        i++;
        j++;
    }

    // Last draw blank lines at bottom
    for (; i<FONT_HEIGHT; i++)
        draw_hline(x, y+i, FONT_WIDTH, BG_COLOR(cl));
}

void draw_dblpixel_raw	(	unsigned int	offset,
		unsigned int	px,
		unsigned int	op
	)

void draw_ellipse	(	coord	xc,
		coord	yc,
		unsigned int	a,
		unsigned int	b,
		color	cl,
		int	flags
	)

Definiert in Zeile 1468 der Datei gui_draw.c.

{
    // Bresenham fast ellipse algorithm - http://homepage.smc.edu/kennedy_john/BELIPSE.PDF
    int X, Y;
    int XChange, YChange;
    int EllipseError;
    int TwoASquare, TwoBSquare;
    int StoppingX, StoppingY;
    TwoASquare = 2*XRadius*XRadius;
    TwoBSquare = 2*YRadius*YRadius;
    X = XRadius;
    Y = 0;
    XChange = YRadius*YRadius*(1-2*XRadius);
    YChange = XRadius*XRadius;
    EllipseError = 0;
    StoppingX = TwoBSquare*XRadius;
    StoppingY = 0;
    while ( StoppingX >= StoppingY ) 
    {
        if (flags & DRAW_FILLED)
        {
            draw_hline(CX-X,CY-Y,X*2+1,cl);
            draw_hline(CX-X,CY+Y,X*2+1,cl);
        }
        else
        {
            draw_pixel(CX-X,CY-Y,cl);
            draw_pixel(CX-X,CY+Y,cl);
            draw_pixel(CX+X,CY-Y,cl);
            draw_pixel(CX+X,CY+Y,cl);
        }
        Y++;
        StoppingY += TwoASquare;
        EllipseError += YChange;
        YChange += TwoASquare;
        if ((2*EllipseError + XChange) > 0 )
        {
            X--;
            StoppingX -= TwoBSquare;
            EllipseError += XChange;
            XChange += TwoBSquare;
        }
    }
    X = 0;
    Y = YRadius;
    XChange = YRadius*YRadius;
    YChange = XRadius*XRadius*(1-2*YRadius);
    EllipseError = 0;
    StoppingX = 0;
    StoppingY = TwoASquare*YRadius;
    int lastY = Y + 1;
    while ( StoppingX <= StoppingY )
    {
        if (flags & DRAW_FILLED)
        {
            // Only draw lines if Y has changed
            if (lastY != Y)
            {
                draw_hline(CX-X,CY-Y,X*2+1,cl);
                draw_hline(CX-X,CY+Y,X*2+1,cl);
                lastY = Y;
            }
        }
        else
        {
            draw_pixel(CX-X,CY-Y,cl);
            draw_pixel(CX-X,CY+Y,cl);
            draw_pixel(CX+X,CY-Y,cl);
            draw_pixel(CX+X,CY+Y,cl);
        }
        X++;
        StoppingX += TwoBSquare;
        EllipseError += XChange;
        XChange += TwoBSquare;
        if ((2*EllipseError + YChange) > 0 )
        {
            Y--;
            StoppingY -= TwoASquare;
            EllipseError += YChange;
            YChange += TwoASquare;
        }
    }
}

color draw_get_pixel	(	coord	x,
		coord	y
	)

Definiert in Zeile 669 der Datei gui_draw.c.

{
#ifndef THUMB_FW
    if ((x < 0) || (y < 0) || (x >= camera_screen.width) || (y >= camera_screen.height)) return 0;
    if (conf.rotate_osd)
    {
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
        return bitmap_buffer[0][rotate_base - (y * camera_screen.buffer_width + ASPECT_XCORRECTION(x))];
#else
        return frame_buffer[0][rotate_base - (y * camera_screen.buffer_width + ASPECT_XCORRECTION(x))];
#endif
    }
    else
    {
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
        return bitmap_buffer[0][y * camera_screen.buffer_width + ASPECT_XCORRECTION(x)];
#else
        return frame_buffer[0][y * camera_screen.buffer_width + ASPECT_XCORRECTION(x)];
#endif
    }
#else
    // DIGIC 6 not supported
    (void)x; (void)y;
    return 0;
#endif
}

void draw_hline	(	coord	x,
		coord	y,
		int	len,
		color	cl
	)

Definiert in Zeile 776 der Datei gui_draw.c.

{
    if ((y < 0) || (x >= camera_screen.width) || (y >= camera_screen.height)) return;
    if (x < 0) { len += x; x = 0; }
    if ((x + len) > camera_screen.width) len = camera_screen.width - x;
#ifndef CAM_HAS_DISPLAY_REFRESH_FLAG
    if (conf.rotate_osd)
    {
        if ((y == camera_screen.height-1) && ((x+len) >= camera_screen.width-1)) { x--; len--; }   // Skip guard pixel
    }
    else
    {
        if ((y == 0) && (x == 0)) { x++; len--; }   // Skip guard pixel
    }
#endif
    register unsigned int offset = y * camera_screen.buffer_width + ASPECT_XCORRECTION(x);
    len = ASPECT_XCORRECTION(len);      // Scale the line length if needed
    for (; len>0; len--, offset++)
        draw_pixel_proc(offset, cl);
}

void draw_icon_cmds	(	coord	x,
		coord	y,
		icon_cmd *	cmds
	)

Definiert in Zeile 1566 der Datei gui_draw.c.

{
    int x1, y1, x2, y2;
#ifdef THUMB_FW
    int thickness = RECT_BORDER2;
#else
    int thickness = RECT_BORDER1;
#endif
    while (1)
    {
#ifdef THUMB_FW
        x1 = cmds->x1<<1;
        y1 = cmds->y1<<1;
        x2 = cmds->x2<<1;
        y2 = cmds->y2<<1;
#else
        x1 = cmds->x1;
        y1 = cmds->y1;
        x2 = cmds->x2;
        y2 = cmds->y2;
#endif
        color cf = chdk_colors[cmds->cf];       // Convert color indexes to actual colors
        color cb = chdk_colors[cmds->cb];
        switch (cmds->action)
        {
        default:
        case IA_END:
            return;
        case IA_HLINE:
            draw_hline(x+x1, y+y1, x2, cb);
#ifdef THUMB_FW
            draw_hline(x+x1, y+y1+1, x2, cb);
#endif
            break;
        case IA_VLINE:
            draw_vline(x+x1, y+y1, y2, cb);
#ifdef THUMB_FW
            draw_vline(x+x1+1, y+y1, y2, cb);
#endif
            break;
        case IA_LINE:
#ifdef THUMB_FW
            draw_line_x2(x+x1, y+y1, x+x2, y+y2, cb);
#else
            draw_line(x+x1, y+y1, x+x2, y+y2, cb);
#endif
            break;
        case IA_RECT:
#ifdef THUMB_FW
            draw_rectangle(x+x1, y+y1, x+x2+1, y+y2+1, MAKE_COLOR(cb,cf), thickness);
#else
            draw_rectangle(x+x1, y+y1, x+x2, y+y2, MAKE_COLOR(cb,cf), thickness);
#endif
            break;
        case IA_FILLED_RECT:
#ifdef THUMB_FW
            draw_rectangle(x+x1, y+y1, x+x2+1, y+y2+1, MAKE_COLOR(cb,cf), thickness|DRAW_FILLED);
#else
            draw_rectangle(x+x1, y+y1, x+x2, y+y2, MAKE_COLOR(cb,cf), thickness|DRAW_FILLED);
#endif
            break;
        case IA_ROUND_RECT:
#ifdef THUMB_FW
            draw_rectangle(x+x1, y+y1, x+x2+1, y+y2+1, MAKE_COLOR(cb,cf), thickness|RECT_ROUND_CORNERS);
#else
            draw_rectangle(x+x1, y+y1, x+x2, y+y2, MAKE_COLOR(cb,cf), thickness|RECT_ROUND_CORNERS);
#endif
            break;
        case IA_FILLED_ROUND_RECT:
#ifdef THUMB_FW
            draw_rectangle(x+x1, y+y1, x+x2+1, y+y2+1, MAKE_COLOR(cb,cf), thickness|DRAW_FILLED|RECT_ROUND_CORNERS);
#else
            draw_rectangle(x+x1, y+y1, x+x2, y+y2, MAKE_COLOR(cb,cf), thickness|DRAW_FILLED|RECT_ROUND_CORNERS);
#endif
            break;
        }
        cmds++;
    }
}

void draw_init

(

)

Definiert in Zeile 521 der Datei gui_draw.c.

{
#ifndef THUMB_FW
#ifndef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
    frame_buffer[0] = vid_get_bitmap_fb();
    frame_buffer[1] = frame_buffer[0] + camera_screen.buffer_size;
#endif
#endif
    draw_set_draw_proc(NULL);

    draw_set_guard();
}

int draw_is_suspended

(

void

)

Definiert in Zeile 544 der Datei gui_draw.c.

{
    return (draw_restore_suspend_tick > get_tick_count());
}

void draw_line	(	coord	x1,
		coord	y1,
		coord	x2,
		coord	y2,
		color	cl
	)

Definiert in Zeile 699 der Datei gui_draw.c.

{
     unsigned char steep = abs(y2 - y1) > abs(x2 - x1);
     if (steep)
     {
         swap(x1, y1);
         swap(x2, y2);
     }
     if (x1 > x2)
     {
         swap(x1, x2);
         swap(y1, y2);
     }
     int deltax = x2 - x1;
     int deltay = abs(y2 - y1);
     int error = 0;
     int y = y1;
     int ystep = (y1 < y2)?1:-1;
     int x;
     for (x=x1; x<=x2; ++x)
     {
         if (steep) draw_pixel(y, x, cl);
         else draw_pixel(x, y, cl);
         error += deltay;
         if ((error<<1) >= deltax)
         {
             y += ystep;
             error -= deltax;
         }
     }
}

void draw_or_erase_edge_pixel	(	coord	x,
		coord	y,
		color	cl,
		int	is_draw
	)

Definiert in Zeile 581 der Datei gui_draw.c.

{
    // Make sure pixel is on screen. Skip top left pixel if screen erase detection is on to avoid triggering the detector.
    if ((px < 0) || (py < 0) || (px >= camera_screen.width) || (py >= camera_screen.height) || ((px == 0) && (py == 0))) return;

    // bitmap buffer offset
    register unsigned int offset = py * camera_screen.buffer_width + ASPECT_XCORRECTION(px);

#ifndef THUMB_FW

    // See if we need to erase, do nothing if not drawing and current pixel is not edge pixel, otherwise set draw color to transparent.
    if (!is_draw)
    {
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
        if (bitmap_buffer[active_bitmap_buffer][offset] != cl) return;
#else
        if (frame_buffer[0][offset] != cl) return;
#endif
        cl = 0;     // Transparent
    }

    // Draw pixel
    draw_pixel_proc_norm(offset,   cl);
#if CAM_USES_ASPECT_CORRECTION
    draw_pixel_proc_norm(offset+1, cl);  // Draw second pixel if screen scaling is needed
#endif

#else // THUMB_FW

    // See if we need to erase, do nothing if not drawing and current pixel is not edge pixel, otherwise set draw color to transparent.
    if (!is_draw)
    {
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
        if (opacity_buffer[active_bitmap_buffer&1][offset] != 254) return;
#else
        if (opacity_buffer[0][offset] != 254) return;
#endif
        cl = 0;     // Transparent
    }

    unsigned int y;
    unsigned int o;
    CALC_YUV_LUMA_OPACITY_FOR_COLOR(cl,y,o);
    unsigned int u;
    unsigned int v;
    CALC_YUV_CHROMA_FOR_COLOR(cl,u,v);

    if (o == 255) o = 254;  // Adjust opacity so we can test for erasing later

    register unsigned int offs2 = (offset>>1)<<2;

#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
    unsigned char *obu = (unsigned char *)(&opacity_buffer[active_bitmap_buffer&1][0]);
    unsigned char *bbu = (unsigned char *)(&bitmap_buffer[active_bitmap_buffer&1][0]);
    obu[offset] = o;
    if (offset&1) // x is odd
    {
        bbu[offs2+3] = y; // Y
    }
    else // x is even
    {
        bbu[offs2+1] = y; // Y
    }
    bbu[offs2+0] = u; // U?
    bbu[offs2+2] = v; // V?
#else
    opacity_buffer[0][offset] = o;
    opacity_buffer[1][offset] = o;
    if (offset&1) // x is odd
    {
        (bitmap_buffer[0])[offs2+3] = y; // Y
        (bitmap_buffer[1])[offs2+3] = y; // Y
    }
    else // x is even
    {
        (bitmap_buffer[0])[offs2+1] = y; // Y
        (bitmap_buffer[1])[offs2+1] = y; // Y
    }
    (bitmap_buffer[0])[offs2+0] = u; // U?
    (bitmap_buffer[1])[offs2+0] = u; // U?
    (bitmap_buffer[0])[offs2+2] = v; // V?
    (bitmap_buffer[1])[offs2+2] = v; // V?
#endif

#endif // THUMB_FW
}

void draw_osd_string	(	OSD_pos	pos,
		int	xo,
		int	yo,
		char *	s,
		twoColors	c,
		OSD_scale	scale
	)

Definiert in Zeile 1403 der Datei gui_draw.c.

{
    if ((scale.x == 0) || (scale.y == 0) || ((scale.x == 1) && (scale.y == 1)))
        draw_string(pos.x+xo, pos.y+yo, s, c);
    else
        draw_string_scaled(pos.x+(xo*scale.x), pos.y+(yo*scale.y), s, c, scale.x, scale.y);
}

void draw_pixel	(	coord	x,
		coord	y,
		color	cl
	)

Definiert in Zeile 564 der Datei gui_draw.c.

{
    // Make sure pixel is on screen. Skip top left pixel if screen erase detection is on to avoid triggering the detector.
    if ((x < 0) || (y < 0) || (x >= camera_screen.width) || (y >= camera_screen.height) || ((x == 0) && (y == 0))) return;
    else
    {
        register unsigned int offset = y * camera_screen.buffer_width + ASPECT_XCORRECTION(x);
        draw_pixel_proc(offset,   cl);
#if CAM_USES_ASPECT_CORRECTION
        draw_pixel_proc(offset+1, cl);  // Draw second pixel if screen scaling is needed
#endif
   }
}

void draw_rectangle	(	coord	x1,
		coord	y1,
		coord	x2,
		coord	y2,
		twoColors	cl,
		int	flags
	)

Definiert in Zeile 809 der Datei gui_draw.c.

{
    // Normalise values
    if (x1 > x2)
        swap(x1, x2);
    if (y1 > y2)
        swap(y1, y2);

    // Check if completely off screen
    if ((x2 < 0) || (y2 < 0) || (x1 >= camera_screen.width) || (y1 >= camera_screen.height))
        return;

    int round = (flags & RECT_ROUND_CORNERS) ? 1 : 0;
    int thickness;
    int i;

    // Shadow (do this first, as edge draw shrinks rectangle for fill)
    if (flags & RECT_SHADOW_MASK)
    {
        thickness = ((flags & RECT_SHADOW_MASK) >> 4);
        for (i=1; i<=thickness; i++)
        {
            draw_vline(x2+i, y1+1, y2 - y1, COLOR_BLACK);
            draw_hline(x1+1, y2+i, x2 - x1 + thickness, COLOR_BLACK);
        }
    }

    // Edge
    thickness = flags & RECT_BORDER_MASK;
    for (i=0; i<thickness; i++)
    {
        // Clipping done in draw_hline and draw_vline
        draw_vline(x1, y1 + round * 2, y2 - y1 - round * 4 + 1, FG_COLOR(cl));
        draw_vline(x2, y1 + round * 2, y2 - y1 - round * 4 + 1, FG_COLOR(cl));
        draw_hline(x1 + 1 + round, y1, x2 - x1 - round * 2 - 1, FG_COLOR(cl));
        draw_hline(x1 + 1 + round, y2, x2 - x1 - round * 2 - 1, FG_COLOR(cl));

        x1++; x2--;
        y1++; y2--;

        round = 0;
    }

    // Fill
    if (flags & DRAW_FILLED)
    {
        // Clip values
        if (x1 < 0) x1 = 0;
        if (y1 < 0) y1 = 0;
        if (x2 >= camera_screen.width)  x2 = camera_screen.width - 1;
        if (y2 >= camera_screen.height) y2 = camera_screen.height - 1;

        coord y;
        for (y = y1; y <= y2; ++y)
            draw_hline(x1, y, x2 - x1 + 1, BG_COLOR(cl));
    }
}

void draw_restore

(

)

Definiert in Zeile 550 der Datei gui_draw.c.

{
    if(draw_is_suspended()) {
        return;
    }
    vid_bitmap_refresh();

    draw_set_guard();
#ifdef CAM_TOUCHSCREEN_UI
    redraw_buttons = 1;
#endif
}

void draw_set_draw_proc

(

void(*)(unsigned int offset, color cl)

pixel_proc)

Definiert in Zeile 220 der Datei gui_draw.c.

{
    draw_pixel_proc_norm = (pixel_proc)?pixel_proc:draw_pixel_std;
    if (conf.rotate_osd)
    {
        rotate_base = (camera_screen.height - 1) * camera_screen.buffer_width + ASPECT_XCORRECTION(camera_screen.width) - 1;
        draw_pixel_proc = draw_pixel_proc_rotated;
    }
    else
    {
        draw_pixel_proc = draw_pixel_proc_norm;
    }
}

void draw_set_guard

(

)

Definiert in Zeile 473 der Datei gui_draw.c.

{
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
    *((unsigned char*)(bitmap_buffer[0])) = GUARD_VAL;
    *((unsigned char*)(bitmap_buffer[1])) = GUARD_VAL;
#else
    *((unsigned char*)(frame_buffer[0])) = GUARD_VAL;
    *((unsigned char*)(frame_buffer[1])) = GUARD_VAL;
#endif
}

int draw_string	(	coord	x,
		coord	y,
		const char *	s,
		twoColors	cl
	)

Definiert in Zeile 1249 der Datei gui_draw.c.

{
    return draw_string_clipped(x, y, s, cl, camera_screen.width);
}

int draw_string_clipped	(	coord	x,
		coord	y,
		const char *	s,
		twoColors	cl,
		int	max_width
	)

Definiert in Zeile 1231 der Datei gui_draw.c.

{
    while (*s && (*s != '\n') && (max_width >= FONT_WIDTH))
    {
        draw_char(x, y, *s, cl);
        s++;
        max_width -= FONT_WIDTH;
        x += FONT_WIDTH;
        if ((x>=camera_screen.width) && (*s))
        {
            draw_char(x-FONT_WIDTH,y, '>', cl);
            break;
        }
    }
    return x;
}

int draw_string_justified	(	coord	x,
		coord	y,
		const char *	s,
		twoColors	cl,
		int	xo,
		int	max_width,
		int	justification
	)

Definiert in Zeile 1259 der Datei gui_draw.c.

{
    // Get length in pixels
    const char *e = strchr(s, '\n');
    int l;
    if (e)
        l = (e - s) * FONT_WIDTH;
    else
        l = strlen(s) * FONT_WIDTH;
    if (l > max_width) l = max_width;

    // Calculate justification offset
    switch (justification & 0xF)
    {
    case TEXT_RIGHT:
        xo = (max_width - l);
        break;
    case TEXT_CENTER:
        xo = ((max_width - l) >> 1);
        break;
    }

    // Fill left side
    if ((justification & TEXT_FILL) && (xo > 0))
        draw_rectangle(x, y, x+xo-1, y+FONT_HEIGHT-1, cl, RECT_BORDER0|DRAW_FILLED);

    // Draw string (get length drawn in pixels)
    l = draw_string_clipped(x+xo, y, s, cl, max_width - xo) - x;

    // Fill right side
    if ((justification & TEXT_FILL) && (l < max_width))
        draw_rectangle(x+l, y, x+max_width-1, y+FONT_HEIGHT-1, cl, RECT_BORDER0|DRAW_FILLED);

    // Return start of first character
    return x+xo;
}

void draw_string_scaled	(	coord	x,
		coord	y,
		const char *	s,
		twoColors	cl,
		int	xsize,
		int	ysize
	)

Definiert in Zeile 1351 der Datei gui_draw.c.

{
    while (*s && (*s != '\n'))
    {
        draw_char_scaled(x, y, *s, cl, xsize, ysize);
        s++;
        x+=FONT_WIDTH*xsize;
        if ((x>=camera_screen.width) && (*s))
        {
            draw_char_scaled(x-FONT_WIDTH*xsize,y, '>', cl, xsize, ysize);
            break;
        }
    }
}

void draw_suspend

(

int

ms)

Definiert in Zeile 535 der Datei gui_draw.c.

{
    int t=get_tick_count() + ms;
    // only change if not already suspended to a later time
    if(t > draw_restore_suspend_tick) {
        draw_restore_suspend_tick = t;
    }
}

int draw_test_guard

(

)

Definiert in Zeile 484 der Datei gui_draw.c.

{
#ifdef DRAW_ON_ACTIVE_BITMAP_BUFFER_ONLY
    if (*((unsigned char*)(bitmap_buffer[active_bitmap_buffer])) != GUARD_VAL) return 0;
#else
    if (*((unsigned char*)(frame_buffer[0])) != GUARD_VAL) return 0;
    if (*((unsigned char*)(frame_buffer[1])) != GUARD_VAL) return 0;
#endif
    return 1;
}

int draw_text_justified	(	coord	x,
		coord	y,
		const char *	s,
		twoColors	cl,
		int	max_chars,
		int	max_lines,
		int	justification
	)

Definiert in Zeile 1332 der Datei gui_draw.c.

{
    int rx = 0;
    while (s && *s && (max_lines > 0))
    {
        const char *e = strchr(s, '\n');
        if (e) e++;

        rx = draw_string_justified(x, y, s, cl, 0, max_chars*FONT_WIDTH, justification);

        s = e;
        y += FONT_HEIGHT;
        max_lines--;
    }
    return rx;
}

void draw_txt_string	(	coord	col,
		coord	row,
		const char *	str,
		twoColors	cl
	)

Definiert in Zeile 1433 der Datei gui_draw.c.

{
    draw_string(col*FONT_WIDTH, row*FONT_HEIGHT, str, cl);
}

void draw_vline	(	coord	x,
		coord	y,
		int	len,
		color	cl
	)

Definiert in Zeile 797 der Datei gui_draw.c.

{
    if ((x < 0) || (x >= camera_screen.width) || (y >= camera_screen.height)) return;
    if (y < 0) { len += y; y = 0; }
    if ((y + len) > camera_screen.height) len = camera_screen.height - y;
    for (; len>0; len--, y++)
        draw_pixel(x, y, cl);
}

void erase_zebra

(

)

Definiert in Zeile 209 der Datei gui_draw.c.

{}

color get_script_color

(

int

cl)

Definiert in Zeile 1663 der Datei gui_draw.c.

{
    if (cl < 256)
        return cl;
    else
        return chdk_colors[cl-256];
}

int text_dimensions	(	const char *	s,
		int	width,
		int	max_chars,
		int *	max_lines
	)

Definiert in Zeile 1301 der Datei gui_draw.c.

{
    int l = 0, n;
    while (s && *s && (l < *max_lines))
    {
        const char *e = strchr(s, '\n');
        if (e)
        {
            n = e - s;
            e++;
        }
        else
        {
            n = strlen(s);
        }

        if (n > width) width = n;

        s = e;
        l++;
    }
    *max_lines = l;
    if (width > max_chars) width = max_chars;
    return width;
}

void update_draw_proc

(

)

Definiert in Zeile 234 der Datei gui_draw.c.

{
    draw_set_draw_proc(draw_pixel_proc_norm);
}

twoColors user_color

(

confColor

c)

Definiert in Zeile 1679 der Datei gui_draw.c.

{
    color fg = chdkColorToCanonColor(cc.fg);
    color bg = chdkColorToCanonColor(cc.bg);

    return MAKE_COLOR(bg,fg);
}

Variablen-Dokumentation

unsigned char* chdk_colors

Definiert in Zeile 1651 der Datei gui_draw.c.