rleClock.c File Reference

#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include "rle.h"
#include <sys/types.h>
#include <time.h>
#include "font.h"

Include dependency graph for rleClock.c:

Go to the source code of this file.

Data Structures
struct	color_t
struct	_urt_stack

Macros
#define	XSIZE   128
#define	YTEXTSIZE   0
#define	YCLOCKSIZE   XSIZE
#define	TICKS   12
#define	DOTS   1
#define	FORMATSTRING   "%02l:%02b"
#define	FACE_EDGE_COLOR   { 255, 255, 255 }
#define	HAND_COLOR   { 255, 255, 255 }
#define	TEXT_COLOR   { 255, 255, 255 }
#define	LITTLEHANDSCALE   12
#define	BIGHANDSCALE   60
#define	HANDWIDTH   0.075
#define	TRUE   1
#define	FALSE   0
#define	RAST_FACE_EDGE   1
#define	RAST_FACE_MASK   2
#define	RAST_LHAND_EDGE   4
#define	RAST_LHAND_MASK   8
#define	RAST_BHAND_EDGE   16
#define	RAST_BHAND_MASK   32
#define	RAST_TEXT   64
#define	RAST_TEXT_BACK   128
#define	CHARPAD   25
#define	NORTH   0
#define	WEST   1
#define	SOUTH   2
#define	EAST   3

Typedefs
typedef char	bool

Functions
void	main ()
void	ifImageSet ()
void	drawHand ()
void	rasterAddBits ()
void	polarLine ()
void	setDot ()
int	polarToX ()
int	polarToY ()
double	radians ()
rle_pixel **	rasterAllocate ()
void	rasterWrite ()
void	lineDots ()
void	procargs ()
bool	argGiven ()
void	usageExit ()
void	charMinMaxWidth ()
void	charMinMaxHeight ()
char *	formatInterp ()
void	drawText ()
void	areaFlood ()
void	stackPush ()
int	stackPop ()
void	main (int argc, argv)
void	ifImageSet (int i, int j, int value, color_t *color)
void	drawHand (double place, double scale, double radius, int mask, int edge)
void	rasterAddBits (int mask, int match, int value)
void	polarLine (double r0, double a0, double r1, double a1, int arg1, int arg2)
void	setDot (int x, int y, int arg1, int arg2)
int	polarToX (double fRadius, double angle)
int	polarToY (double fRadius, double angle)
double	radians (double degrees)
rle_pixel **	rasterAllocate (int height, int width)
void	rasterWrite (FILE *fd)
void	lineDots (int x0, int y0, int x1, int y1, void(*func)(), int arg1, int arg2)
void	procargs (int argc, argv)
bool	argGiven (char *argVar)
void	usageExit (char *pgm)
void	charMinMaxWidth (int ch, int *min, int *max)
void	charMinMaxHeight (int ch, int *min, int *max)
char *	formatInterp (char *str) const
void	areaFlood (int firstX, int firstY, int mask, int match, int value)
void	stackPush (int x, int y, int dir)

Variables
static char	rcsid [] = "$Header: /l/spencer/src/urt/tools/clock/RCS/rleClock.c,v 3.0.1.2 1992/04/30 14:19:38 spencer Exp $"
color_t	FaceEdgeColor = { 255, 255, 255 }
color_t	FaceColor
color_t	HandEdgeColor
color_t	HandColor = { 255, 255, 255 }
color_t	TextColor = { 255, 255, 255 }
color_t	TextBackColor
rle_pixel **	RedLine
rle_pixel **	GreenLine
rle_pixel **	BlueLine
rle_pixel **	Raster
rle_pixel **	AlphaLine
int	XSize = 128
int	YSize
int	YClockSize = 128
int	YTextSize = 0
int	XRadius
int	YRadius
int	Ticks = 12
bool	DebugAlpha = 0
bool	Debug = 0
int	Dots = 1
float	BigHandValue
float	LittleHandValue
float	LittleHandScale = 12
float	BigHandScale = 60
const char *	FormatString = "%02l:%02b"
move_t	Moves []
int	Base []
char **	gargv
struct {
enum	{   INT, FLOAT, STRING, BOOL,   COLOR, HELP, TEXT }
bool   show
const char *   arg
enum { ... }    type
const char *   description
const char *   value
bool   given
}	Args []
struct {
_urt_stack *   s
int   top
int   allocked
}	Stack
int	XMove [4] = {0, 1, 0, -1}
int	YMove [4] = {1, 0, -1, 0}

Macro Definition Documentation

#define BIGHANDSCALE   60

Definition at line 60 of file rleClock.c.

#define CHARPAD   25

Definition at line 842 of file rleClock.c.

#define DOTS   1

Definition at line 54 of file rleClock.c.

#define EAST   3

Definition at line 917 of file rleClock.c.

#define FACE_EDGE_COLOR   { 255, 255, 255 }

Definition at line 56 of file rleClock.c.

#define FALSE   0

Definition at line 66 of file rleClock.c.

#define FORMATSTRING   "%02l:%02b"

Definition at line 55 of file rleClock.c.

#define HAND_COLOR   { 255, 255, 255 }

Definition at line 57 of file rleClock.c.

#define HANDWIDTH   0.075

Definition at line 62 of file rleClock.c.

#define LITTLEHANDSCALE   12

Definition at line 59 of file rleClock.c.

#define NORTH   0

Definition at line 914 of file rleClock.c.

#define RAST_BHAND_EDGE   16

Definition at line 78 of file rleClock.c.

#define RAST_BHAND_MASK   32

Definition at line 79 of file rleClock.c.

#define RAST_FACE_EDGE   1

Definition at line 74 of file rleClock.c.

#define RAST_FACE_MASK   2

Definition at line 75 of file rleClock.c.

#define RAST_LHAND_EDGE   4

Definition at line 76 of file rleClock.c.

#define RAST_LHAND_MASK   8

Definition at line 77 of file rleClock.c.

#define RAST_TEXT   64

Definition at line 80 of file rleClock.c.

#define RAST_TEXT_BACK   128

Definition at line 81 of file rleClock.c.

#define SOUTH   2

Definition at line 916 of file rleClock.c.

#define TEXT_COLOR   { 255, 255, 255 }

Definition at line 58 of file rleClock.c.

#define TICKS   12

Definition at line 53 of file rleClock.c.

#define TRUE   1

Definition at line 65 of file rleClock.c.

#define WEST   1

Definition at line 915 of file rleClock.c.

#define XSIZE   128

Definition at line 50 of file rleClock.c.

#define YCLOCKSIZE   XSIZE

Definition at line 52 of file rleClock.c.

#define YTEXTSIZE   0

Definition at line 51 of file rleClock.c.

Typedef Documentation

typedef char bool

Definition at line 68 of file rleClock.c.

Function Documentation

void areaFlood

(

)

void areaFlood	(	int	firstX,
		int	firstY,
		int	mask,
		int	match,
		int	value
	)

Definition at line 928 of file rleClock.c.

{
    register _urt_stack *sp;

    Stack.s = (_urt_stack *) calloc(256, sizeof(_urt_stack));
    Stack.allocked = 256;
    Stack.top = -1;
    stackPush(firstX, firstY, NORTH);

    while (Stack.top >= 0) {
    sp = &Stack.s[Stack.top];
    if ((Raster[sp->y][sp->x]&mask)==match && (Raster[sp->y][sp->x]&value)!=value) {
        Raster[sp->y][sp->x] |= value;
        if (Debug)
        fprintf(stderr, "Marking %d, %d at stack %d\n", sp->x, sp->y, Stack.top);
        stackPush(sp->x + XMove[sp->dir], sp->y + YMove[sp->dir],
              NORTH);
    } else {
        do {
        if (stackPop())
            break;
        sp = &Stack.s[Stack.top];
        sp->dir++;
        } while (sp->dir >= 4);
        if (Stack.top >= 0)
        stackPush(sp->x + XMove[sp->dir], sp->y + YMove[sp->dir],
              NORTH);
    }
    }
}

bool argGiven

(

)

bool argGiven

(

char *

argVar

)

Definition at line 662 of file rleClock.c.

{
    int i;

    for ( i=0 ; Args[i].arg != NULL ; i++) {
    if (Args[i].value == argVar) {
        return Args[i].given;
    }
    }
    return FALSE;
}

void charMinMaxHeight

(

)

void charMinMaxHeight	(	int	ch,
		int *	min,
		int *	max
	)

Definition at line 747 of file rleClock.c.

Referenced by drawText().

{
    int epos, pos;

    if (!isprint(ch)) {
    *min = *max = 0;
    return;
    }
    if (ch == ' ') {
    ch = 'n';
    }
    *min = 999;
    *max = -999;
    epos = Base[(int)ch - 33 + 1];
    pos = Base[(int)ch - 33];
    for (; pos < epos; pos++) {
    if (Moves[pos].y > *max) {
        *max = Moves[pos].y;
    }
    if (Moves[pos].y < *min) {
        *min = Moves[pos].y;
    }
    }
}

Here is the caller graph for this function:

void charMinMaxWidth

(

)

void charMinMaxWidth	(	int	ch,
		int *	min,
		int *	max
	)

Definition at line 719 of file rleClock.c.

Referenced by drawText().

{
    int epos, pos;

    if (!isprint(ch)) {
    *min = *max = 0;
    return;
    }
    if (ch == ' ') {
    ch = 'n';
    }
    *min = 999;
    *max = -999;
    epos = Base[(int)ch - 33 + 1];
    pos = Base[(int)ch - 33];
    for (; pos < epos; pos++) {
    if (Moves[pos].x > *max) {
        *max = Moves[pos].x;
    }
    if (Moves[pos].x < *min) {
        *min = Moves[pos].x;
    }
    }
}

Here is the caller graph for this function:

void drawHand

(

)

void drawHand	(	double	place,
		double	scale,
		double	radius,
		int	mask,
		int	edge
	)

Definition at line 323 of file rleClock.c.

{
    float angle;
    angle = place / scale * 360;
    polarLine(HANDWIDTH,    angle+180.0,  HANDWIDTH,    angle-90.0,  edge, 1);
    polarLine(HANDWIDTH,    angle-90.0,   radius,       angle,       edge, 1);
    polarLine(radius,       angle,        HANDWIDTH,    angle+90.0,  edge, 1);
    polarLine(HANDWIDTH,    angle+90.0,   HANDWIDTH,    angle+180.0, edge, 1);
    areaFlood(polarToX(0.0, 0.0), polarToY(0.0, 0.0), edge, 0,
    mask);
    polarLine(HANDWIDTH,    angle+180.0,  HANDWIDTH,    angle-90.0,  edge, Dots);
    polarLine(HANDWIDTH,    angle-90.0,   radius,       angle,       edge, Dots);
    polarLine(radius,       angle,        HANDWIDTH,    angle+90.0,  edge, Dots);
    polarLine(HANDWIDTH,    angle+90.0,   HANDWIDTH,    angle+180.0, edge, Dots);
    rasterAddBits(edge, edge, mask);
}

void drawText

(

)

Definition at line 845 of file rleClock.c.

References Base, charMinMaxHeight(), charMinMaxWidth(), Dots, formatInterp(), FormatString, lineDots(), Moves, Raster, setDot(), move_t::type, move_t::x, XSize, move_t::y, YClockSize, YSize, and YTextSize.

{
    char           *string;
    int             i, j, xsize, ysize, min, max, basex;
    int             curx, cury, x, y, pos, epos, charBasex;
    float           scale, scalex;

    string = formatInterp(FormatString);
    xsize = CHARPAD+Dots;
    ysize = 0;
    for (i = 0; string[i] != 0; i++) {
    charMinMaxWidth(string[i], &min, &max);
    xsize += (max - min) + CHARPAD+Dots;
    charMinMaxHeight(string[i], &min, &max);
    if (ysize < (max - min)+Dots) {
        ysize = max - min+Dots;
    }
    }
    scale = (float) YTextSize / (float) ysize;
    scalex = (float) XSize / (float) xsize;
    if (scale > scalex) {
    scale = scalex;
    }
    basex = (XSize - (int) ((float)xsize * scale)) / 2;
    curx = cury = 0;
    charBasex = CHARPAD;
    for (i = 0; string[i] != 0; i++) {
    if (isprint(string[i]) && string[i] != ' ') {
        charMinMaxWidth(string[i], &min, &max);
        epos = Base[((int) (string[i])) - 33 + 1];
        for (pos = Base[(int) string[i] - 33]; pos < epos; pos++) {
        x = basex + (int) (scale * (charBasex + Moves[pos].x + (-min)));
        y = (int) (scale * Moves[pos].y);
        if (Moves[pos].type == 'n') {
            lineDots(curx, YClockSize + Dots + 1 + cury, x, YClockSize + Dots + 1 + y, setDot, RAST_TEXT, Dots);
        }
        curx = x;
        cury = y;
        }
    }
    charBasex += (max-min) + CHARPAD + Dots;
    }
    x = basex + (int)(scale * charBasex);
    if (x > XSize) {
    x = XSize;
    }
    y = scale * ysize + YClockSize+Dots+1;
    if (y+Dots > YSize) {
    y = YSize-Dots;
    }
    for (i = YClockSize+Dots; i < y+Dots ; i++) {
    for (j = basex; j < x; j++) {
        Raster[i][j] |= RAST_TEXT_BACK;
    }
    }
}

Here is the call graph for this function:

char* formatInterp

(

)

char* formatInterp

(

char *

str

)

const

Definition at line 782 of file rleClock.c.

Referenced by drawText().

{
    char *buf, *bufp;
    int state;
    static char outBuf[1024];
    char tmpBuf[1024];

    buf = (char *)malloc(strlen(str)*2+1);
    bufp = buf;
    state = 0;
    strcpy(outBuf, "");
    while ( *str != 0) {
    switch (state) {
    case 0:
        *bufp++ = *str;
        if (*str == '%') {
        state = 1;
        }
        break;
    case 1:
        if (isdigit(*str) || *str == '.') {
        *bufp++ = *str;
        } else {
        if ( *str=='B' || *str=='L') {
            *bufp++ = 'f';
            *bufp = 0;
            sprintf(tmpBuf, buf, *str == 'B' ? (float)BigHandValue
                             : (float)LittleHandValue);
        } else if ( *str=='b' || *str=='l') {
            *bufp++ = 'd';
            *bufp = 0;
            sprintf(tmpBuf, buf, *str == 'b' ? (int)BigHandValue
                             : (int)LittleHandValue);
        } else {
            *bufp++ = *str;
            *bufp = 0;
            strcpy(tmpBuf, buf);
        }
        strcat(outBuf, tmpBuf);
        bufp = buf;
        state = 0;
        }
        break;
    }
    str++;
    }
    *bufp = 0;
    strcat(outBuf, buf);
    free(buf);
    return outBuf;
}

Here is the caller graph for this function:

void ifImageSet

(

)

void ifImageSet	(	int	i,
		int	j,
		int	value,
		color_t *	color
	)

Definition at line 311 of file rleClock.c.

{
    if (Raster[i][j] & value) {
    RedLine[i][j] = color->red;
    GreenLine[i][j] = color->green;
    BlueLine[i][j] = color->blue;
    }
}

void lineDots

(

)

void lineDots	(	int	x0,
		int	y0,
		int	x1,
		int	y1,
		void (*)()	func,
		int	arg1,
		int	arg2
	)

Definition at line 504 of file rleClock.c.

Referenced by drawText().

{
    int             e, x, y, delta_x, delta_y, tmp;
    bool            interchg = FALSE;
    int         dir_x, dir_y;
    int             two_dy, two_dx; /* calculated outside of loop */
    register int    i;


    if (x0 == x1 && y0 == y1) { /* is starting point = end point ? */
    (*func)(x0, y0, arg1, arg2);
    return;
    }
    x = x0;
    y = y0;

    delta_x = x1 - x0;
    delta_y = y1 - y0;

    delta_x = delta_x > 0 ? delta_x : -delta_x; /* absolute value,
                         * abs(x1-x0) */
    delta_y = delta_y > 0 ? delta_y : -delta_y; /* absolute value,
                         * abs(y1-x0) */

    dir_x = (x1 - x0) > 0 ? 1 : -1; /* sign (x1 - x0) */
    dir_y = (y1 - y0) > 0 ? 1 : -1; /* sign (y1 - y0) */

    if (delta_y > delta_x) {
    tmp = delta_x;
    delta_x = delta_y;
    delta_y = tmp;
    interchg = TRUE;
    }
    two_dx = 2 * delta_x;
    two_dy = 2 * delta_y;

    e = two_dy - delta_x;
    for (i = 1; i <= delta_x; ++i) {
    (*func) (x, y, arg1, arg2);
    while (e >= 0) {
        if (interchg)
        x += dir_x;
        else
        y += dir_y;
        e -= two_dx;
    }
    if (interchg)
        y += dir_y;
    else
        x += dir_x;
    e += two_dy;
    }
}

Here is the caller graph for this function:

void main

(

)

Definition at line 28 of file wedge.c.

References color_names, and raster.

{
    register rle_pixel * rptr;
    register int i,j,color, val;

    raster = (rle_pixel *) malloc( (STEPS * 2 + 2) * IMG_HEIGHT /*/4*/ );
    rptr = raster;

    init_qcr( 1 );

    for (color = 0; color < 3; color++)
    for (j = 0; j < IMG_HEIGHT/4; j++)
    {
        for (i = 0; i < STEPS; i++)
        {
        *rptr = IMG_WIDTH / STEPS;
        val = i * (256 / (STEPS-1));
        if (val >= 256)
        {
            val = 255;
            /* Add round-off to fill out scanline */
            *rptr += IMG_WIDTH - (STEPS * (IMG_WIDTH / STEPS));
        }
        rptr++;
        *rptr++ = val;
        }
    }

    /* Do first three color bars. */
    for (color = 0; color < 3; color++)
    {
    set_up_qcr( IMG_WIDTH, IMG_HEIGHT, IMG_HEIGHT/4,
           color * (IMG_HEIGHT/4) );

    fprintf(stderr, "Sending color %s...\n", color_names[color] );
    write_qcr_cmd( RED_RLE + color );

    if (write_data( raster, (STEPS * 2) * (IMG_HEIGHT / 4) ) <= 0)
        perror("wedge: error sending data");
    qcr_wait_srq();
    fprintf(stderr, "...sent\n\n");
    }

    color = 3;
    set_up_qcr( IMG_WIDTH, IMG_HEIGHT, IMG_HEIGHT/4,
           color * (IMG_HEIGHT/4) );

    fprintf(stderr, "Sending three passes (for gray)...\n");
    write_qcr_cmd( THREE_PASS_RLE );

    if (write_data( raster, ((STEPS * 2) * (IMG_HEIGHT / 4)) * 3 ) <= 0)
    perror("wedge: error sending data");
    qcr_wait_srq();
    fprintf(stderr, "...sent\n\n");
}

void main	(	int	argc,
		argv
	)

Definition at line 185 of file rleClock.c.

{
    int             i, j;
    float           theta;
    time_t      now;
    struct tm      *tm, *localtime();
    bool haveFaceColor;
    bool haveHandEdgeColor;
    bool haveTextBackColor;

    gargv = argv;

    procargs(argc, argv);
    YRadius = (YClockSize - Dots) / 2;
    XRadius = (XSize - Dots) / 2;
    YSize = YClockSize + YTextSize + Dots + Dots;
    if (!argGiven((char *) &LittleHandValue) || !argGiven((char *) &BigHandValue)) {
    (void)time(&now);
    tm = localtime(&now);

    if (!argGiven((char *) &BigHandValue))
        BigHandValue = (float) tm->tm_min;
    if (!argGiven((char *) &LittleHandValue))
        LittleHandValue = (float) ((tm->tm_hour % 12)) + BigHandValue / 60.0;
    }
    /*
     * Allocate the storage for the raster 
     */

    RedLine = (rle_pixel **) rasterAllocate(YSize, XSize);
    GreenLine = (rle_pixel **) rasterAllocate(YSize, XSize);
    BlueLine = (rle_pixel **) rasterAllocate(YSize, XSize);
    AlphaLine = (rle_pixel **) rasterAllocate(YSize, XSize);
    Raster = (rle_pixel **) rasterAllocate(YSize, XSize);

    /*
     * Initialize the raster to the background color 
     */

    for (i = 0; i < YSize; i++) {
    for (j = 0; j < XSize; j++) {
        Raster[i][j] = 0;
    }
    }

    /*
     * Draw the clock face as a circle with tick marks 
     */

    for (i = 0; i < 360; i++) {
    polarLine(1.0, (float) i, 1.0, (float) (i + 1), RAST_FACE_EDGE, Dots);
    }
    for (i = 0; i < Ticks; i++) {
    theta = (float) i *360.0 / (float) Ticks;

    polarLine(1.0, theta, 0.85, theta, RAST_FACE_EDGE, Dots);
    }

    /*
     * Compute the RAST_FACE_MASK portion - includes what is inside the
     * dial face plus the dial face itself.  So first flood the inside, and
     * then OR in the stuff under the face lines 
     */

    areaFlood(polarToX(0.0, 0.0), polarToY(0.0, 0.0), RAST_FACE_EDGE, 0, RAST_FACE_MASK);
    rasterAddBits(RAST_FACE_EDGE, RAST_FACE_EDGE, RAST_FACE_MASK);

    /*
     * Draw the hands and the text... 
     */

    drawHand(BigHandValue, BigHandScale, 0.85, RAST_BHAND_MASK, RAST_BHAND_EDGE);
    drawHand(LittleHandValue, LittleHandScale, 0.60, RAST_LHAND_MASK, RAST_LHAND_EDGE);
    if (YTextSize > 0) {
    drawText();
    }
    /*
     * Compose the clock image from the generated raster and program
     * arguments 
     */

    haveFaceColor = argGiven((char *)&FaceColor);
    haveHandEdgeColor = argGiven((char *)&HandEdgeColor);
    haveTextBackColor = argGiven((char *)&TextBackColor);
    for (i = 0; i < YSize; i++) {
    for (j = 0; j < XSize; j++) {
        if (haveFaceColor) {
        ifImageSet(i, j, RAST_FACE_MASK, &FaceColor);
        }
        ifImageSet(i, j, RAST_FACE_EDGE, &FaceEdgeColor);
        ifImageSet(i, j, RAST_LHAND_MASK|RAST_BHAND_MASK, &HandColor);
        if (haveHandEdgeColor) {
        ifImageSet(i, j, RAST_LHAND_EDGE|RAST_BHAND_EDGE, &HandEdgeColor);
        }
        if (haveTextBackColor) {
        ifImageSet(i, j, RAST_TEXT_BACK, &TextBackColor);
        }
        ifImageSet(i, j, RAST_TEXT, &TextColor);

        /*
         * Now compute the Alpha channel
         */

            if ( (haveFaceColor && (Raster[i][j]&RAST_FACE_MASK)!=0)
         || ((Raster[i][j]&(RAST_FACE_EDGE|RAST_LHAND_MASK|RAST_BHAND_MASK))!=0)
         || (haveTextBackColor && (Raster[i][j] & RAST_TEXT_BACK)!=0)
         || ((Raster[i][j] & RAST_TEXT)!=0)) {
        AlphaLine[i][j] = 255;
        } else {
        AlphaLine[i][j] = 0;
        }
    }
    }

    /*
     * Dump the raster file to stdout... 
     */

    rasterWrite(stdout);

    exit(0);
}

void polarLine

(

)

void polarLine	(	double	r0,
		double	a0,
		double	r1,
		double	a1,
		int	arg1,
		int	arg2
	)

Definition at line 359 of file rleClock.c.

{
    lineDots(polarToX(r0, a0), 
         polarToY(r0, a0), 
         polarToX(r1, a1), 
         polarToY(r1, a1), 
         setDot, arg1, arg2);
}

int polarToX

(

)

int polarToX	(	double	fRadius,
		double	angle
	)

Definition at line 402 of file rleClock.c.

{
    return (int)(fRadius * sin(radians(angle)) * XRadius) + XSize/2;
}

int polarToY

(

)

int polarToY	(	double	fRadius,
		double	angle
	)

Definition at line 410 of file rleClock.c.

{
    return (int)(fRadius * cos(radians(angle)) * YRadius) + YRadius;
}

void procargs

(

)

void procargs	(	int	argc,
		argv
	)

Definition at line 605 of file rleClock.c.

{
    int arg, i;
    color_t *color;

    for ( arg = 1 ; arg<argc ; arg++) {
    for ( i=0 ; Args[i].arg != NULL ; i++) {
        if (Args[i].type != TEXT && strcmp(argv[arg], Args[i].arg) == 0) {
        break;
        }
    }
    if (Args[i].arg==NULL) {
        fprintf(stderr, "Unknown argument: \"%s\"\n", argv[arg]);
        usageExit(argv[0]);
    }
    Args[i].given = TRUE;
    switch (Args[i].type) {
    case HELP:
        usageExit(argv[0]);
        break;
    case INT:
        arg += 1;
        *(int *)Args[i].value = atoi(argv[arg]);
        break;
    case FLOAT:
        arg += 1;
        *(float *)Args[i].value = atof(argv[arg]);
        break;
    case BOOL:
        *(bool *)Args[i].value = TRUE;
        break;
    case STRING:
        arg += 1;
        *(char **)Args[i].value = (char *)malloc(strlen(argv[arg])+1);
        strcpy(*(char **)Args[i].value, argv[arg]);
        break;
    case COLOR:
        color = (color_t *)Args[i].value;
        if ( arg+3 >= argc || !isdigit(argv[arg+1][0]) 
                           || !isdigit(argv[arg+2][0]) 
                   || !isdigit(argv[arg+3][0])) {
        fprintf(stderr, "%s: %s takes three numeric arguments\n", argv[0],
            Args[i].arg);
        usageExit(argv[0]);
        }
        color->red = atoi(argv[arg+1]);
        color->green = atoi(argv[arg+2]);
        color->blue = atoi(argv[arg+3]);
        arg += 3;
        break;
    default:
        break;
    }
    }
}

double radians

(

)

double radians

(

double

degrees

)

Definition at line 418 of file rleClock.c.

{
    return degrees/180.0 * 3.1415926;
}

void rasterAddBits

(

)

void rasterAddBits	(	int	mask,
		int	match,
		int	value
	)

Definition at line 345 of file rleClock.c.

{
    int i, j;

    for (i = 0 ; i < YSize; i++) {
    for (j = 0; j < XSize; j++) {
        if ( (Raster[i][j]&mask) == match )
        Raster[i][j] |= value;
    }
    }
}

rle_pixel** rasterAllocate

(

)

rle_pixel** rasterAllocate	(	int	height,
		int	width
	)

Definition at line 432 of file rleClock.c.

{
    rle_pixel **new, *row;
    int i;

    new = (rle_pixel **)calloc(height, sizeof(rle_pixel *));
    row = (rle_pixel *)calloc(height*width, sizeof(rle_pixel));
    for ( i=0 ; i<height ; i++) {
    new[i] = row;
    row += width;
    }
    return new;
}

void rasterWrite

(

)

void rasterWrite

(

FILE *

fd

)

Definition at line 455 of file rleClock.c.

{
    rle_hdr         the_hdr;
    rle_pixel      *rows[4];
    int             i;

    the_hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &the_hdr, cmd_name( gargv ), NULL, 0 );

    RLE_SET_BIT(the_hdr, RLE_ALPHA);
    the_hdr.rle_file = fd;
    the_hdr.xmax = XSize;
    the_hdr.ymax = YSize;
    the_hdr.alpha = 1;
    rle_addhist( gargv, NULL, &the_hdr );

    rle_put_setup(&the_hdr);
    for (i = 0; i < YSize; i++) {
    rows[0] = AlphaLine[i];
    if (DebugAlpha) {
        rows[1] = AlphaLine[i];
        rows[2] = AlphaLine[i];
        rows[3] = AlphaLine[i];
    } else {
        rows[1] = RedLine[i];
        rows[2] = GreenLine[i];
        rows[3] = BlueLine[i];
    }
    rle_putrow(rows + 1, XSize, &the_hdr);
    }
    rle_close_f( the_hdr.rle_file );
}

void setDot

(

)

void setDot	(	int	x,
		int	y,
		int	arg1,
		int	arg2
	)

Definition at line 379 of file rleClock.c.

Referenced by drawText().

{
    int i, j;

if(Debug)fprintf(stderr, "Setting %d, %d\n", x, y);
    for (i = 0; i < arg2; i++) {
    for (j = 0; j < arg2; j++) {
        Raster[y+i][x+j] |= arg1;
    }
    }
}

Here is the caller graph for this function:

int stackPop

(

)

Definition at line 976 of file rleClock.c.

{
    Stack.top -= 1;
    return Stack.top < 0;
}

void stackPush

(

)

void stackPush	(	int	x,
		int	y,
		int	dir
	)

Definition at line 962 of file rleClock.c.

{
    if (++Stack.top >= Stack.allocked) {
        Stack.allocked += 256;
        Stack.s = (_urt_stack *) realloc(Stack.s, Stack.allocked * sizeof(_urt_stack));
if(Debug)fprintf(stderr, "Stack growing to %d\n", Stack.allocked);
    }
    Stack.s[Stack.top].x = x;
    Stack.s[Stack.top].y = y;
    Stack.s[Stack.top].dir = dir;
}

void usageExit

(

)

void usageExit

(

char *

pgm

)

Definition at line 676 of file rleClock.c.

{
    int             i;

    fprintf(stderr, "Usage: %s [args]\n", pgm);
    for (i = 0; Args[i].arg != NULL; i++) {
    if (Args[i].show) {
        fprintf(stderr, "\t%s", Args[i].arg);
        switch (Args[i].type) {
        case INT:
        fprintf(stderr, " INT");
        break;
        case FLOAT:
        fprintf(stderr, " FLOAT");
        break;
        case BOOL:
        break;
        case STRING:
        fprintf(stderr, " STR");
        break;
        case COLOR:
        fprintf(stderr, " RED GREEN BLUE");
        break;
        default:
        break;
        }
        fprintf(stderr, " ... %s\n", Args[i].description);
    }
    }
    exit(1);

}

Variable Documentation

int allocked

Definition at line 921 of file rleClock.c.

rle_pixel** AlphaLine

Definition at line 106 of file rleClock.c.

const char* arg

Definition at line 571 of file rleClock.c.

struct { ... } Args[]

Initial value:

={
    {  1 ,  "-x",  INT,    "Image width in pixels",              (char *)&XSize }, 
    {  1 ,  "-cy", INT,    "Clock image height in pixels",       (char *)&YClockSize },
    {  1 ,  "-ty", INT,    "Text image height in pixels",        (char *)&YTextSize },
    {  1 ,  "-help", HELP, "Prints this help message",            ((void *)0)  },

    {  1 ,  "-bv", FLOAT,  "Big hand value",                     (char *)&BigHandValue }, 
    {  1 ,  "-bs", FLOAT,  "Big hand full scale value",          (char *)&BigHandScale }, 
    {  1 ,  "-lv", FLOAT,  "Little hand value",                  (char *)&LittleHandValue },
    {  1 ,  "-ls", FLOAT,  "Little hand full scale value",       (char *)&LittleHandScale },
    {  1 ,  "-t",  INT,    "Number of ticks around the face",    (char *)&Ticks },
    {  1 ,  "-lw", INT,    "Line width in pixels",               (char *)&Dots },

    {  1 ,  "-fc", COLOR,  "Clock face edges color",             (char *)&FaceEdgeColor }, 
    {  1 ,  "-Fc", COLOR,  "Clock face background color",        (char *)&FaceColor }, 
    {  1 ,  "",    TEXT,   " - if omitted, then the clock is transparent" },  
    {  1 ,  "-hc", COLOR,  "Clock hands edges color",            (char *)&HandEdgeColor },
    {  1 ,  "",    TEXT,   " - if omitted,  no hand edges shown" }, 
    {  1 ,  "-Hc", COLOR,  "Clock hands fill color",             (char *)&HandColor }, 
    {  1 ,  "-tc", COLOR,  "Text color",              (char *)&TextColor}, 
    {  1 ,  "-Tc", COLOR,  "Text background color",           (char *)&TextBackColor}, 
    {  1 ,  "",    TEXT,   " - if omitted, then the text is transparent" },  
    {  1 ,  "-tf", STRING, "Text area format string",             (char *)&FormatString }, 
    {  0 , "-Xm", BOOL,   "Output the alpha channel on RGB",    (char *)&DebugAlpha },
    {  0 , "-D",  BOOL,   "Turn on debugging",            (char *)&Debug },
    {  0 ,  ((void *)0)  }
}

int Base[]

Definition at line 303 of file font.c.

Referenced by drawText().

float BigHandScale = 60

Definition at line 121 of file rleClock.c.

float BigHandValue

Definition at line 118 of file rleClock.c.

rle_pixel** BlueLine

Definition at line 104 of file rleClock.c.

bool Debug = 0

Definition at line 116 of file rleClock.c.

Referenced by EndPage(), ReadFonts(), and ReadInput().

bool DebugAlpha = 0

Definition at line 115 of file rleClock.c.

const char* description

Definition at line 573 of file rleClock.c.

int Dots = 1

Definition at line 117 of file rleClock.c.

Referenced by drawText().

color_t FaceColor

Definition at line 96 of file rleClock.c.

color_t FaceEdgeColor = { 255, 255, 255 }

Definition at line 95 of file rleClock.c.

const char* FormatString = "%02l:%02b"

Definition at line 122 of file rleClock.c.

Referenced by drawText().

char** gargv

Definition at line 182 of file rleClock.c.

bool given

Definition at line 575 of file rleClock.c.

rle_pixel** GreenLine

Definition at line 103 of file rleClock.c.

color_t HandColor = { 255, 255, 255 }

Definition at line 98 of file rleClock.c.

color_t HandEdgeColor

Definition at line 97 of file rleClock.c.

float LittleHandScale = 12

Definition at line 120 of file rleClock.c.

float LittleHandValue

Definition at line 119 of file rleClock.c.

move_t Moves[]

Definition at line 2 of file font.c.

Referenced by drawText().

rle_pixel** Raster

Definition at line 105 of file rleClock.c.

Referenced by drawText().

char rcsid[] = "$Header: /l/spencer/src/urt/tools/clock/RCS/rleClock.c,v 3.0.1.2 1992/04/30 14:19:38 spencer Exp $"

static

Definition at line 30 of file rleClock.c.

rle_pixel** RedLine

Definition at line 102 of file rleClock.c.

_urt_stack* s

Definition at line 919 of file rleClock.c.

bool show

Definition at line 570 of file rleClock.c.

struct { ... } Stack

color_t TextBackColor

Definition at line 100 of file rleClock.c.

color_t TextColor = { 255, 255, 255 }

Definition at line 99 of file rleClock.c.

int Ticks = 12

Definition at line 114 of file rleClock.c.

int top

Definition at line 920 of file rleClock.c.

enum { ... } type

const char* value

Definition at line 574 of file rleClock.c.

int XMove[4] = {0, 1, 0, -1}

Definition at line 924 of file rleClock.c.

int XRadius

Definition at line 112 of file rleClock.c.

int XSize = 128

Definition at line 108 of file rleClock.c.

Referenced by drawText().

int YClockSize = 128

Definition at line 110 of file rleClock.c.

Referenced by drawText().

int YMove[4] = {1, 0, -1, 0}

Definition at line 925 of file rleClock.c.

int YRadius

Definition at line 113 of file rleClock.c.

int YSize

Definition at line 109 of file rleClock.c.

Referenced by drawText().

int YTextSize = 0

Definition at line 111 of file rleClock.c.

Referenced by drawText().