snow/dockapps
1
0
Fork 0
Code Issues Releases Activity

indent -linux -l144 -i4 -ts4 **/*.[ch]

Browse source
This commit is contained in:
Alexey I. Froloff 2012-08-14 17:04:20 +04:00 committed by Carlos R. Mafra
parent cb310ed1a1
commit 324a28e4ba
9 changed files with 719 additions and 784 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
wmMatrix/config.h
View file

@ -9,7 +9,6 @@
* that your changes will be lost if you ever run `configure' again. * that your changes will be lost if you ever run `configure' again.
*/ */
/* ************************************************************************* /* *************************************************************************
CONFIGURING SERVER EXTENSIONS CONFIGURING SERVER EXTENSIONS
************************************************************************* */ ************************************************************************* */
@ -110,8 +109,6 @@
*/ */
/* #undef HAVE_PROC_INTERRUPTS */ /* #undef HAVE_PROC_INTERRUPTS */
/* ************************************************************************* /* *************************************************************************
CONFIGURING GRAPHICS TOOLKITS CONFIGURING GRAPHICS TOOLKITS
************************************************************************* */ ************************************************************************* */
@ -184,8 +181,6 @@
*/ */
#define ZIPPY_PROGRAM "/packages/libexec/emacs/20.2/sparc-sun-solaris2.6/yow" #define ZIPPY_PROGRAM "/packages/libexec/emacs/20.2/sparc-sun-solaris2.6/yow"
/* ************************************************************************* /* *************************************************************************
CONFIGURING PASSWORD AUTHENTICATION CONFIGURING PASSWORD AUTHENTICATION
************************************************************************* */ ************************************************************************* */
@ -258,13 +253,11 @@
*/ */
/* #undef HAVE_VT_LOCKSWITCH */ /* #undef HAVE_VT_LOCKSWITCH */
/* Define this if you the openlog(), syslog(), and closelog() functions. /* Define this if you the openlog(), syslog(), and closelog() functions.
This is used for logging failed login attempts. This is used for logging failed login attempts.
*/ */
#define HAVE_SYSLOG 1 #define HAVE_SYSLOG 1
/* ************************************************************************* /* *************************************************************************
OTHER C ENVIRONMENT JUNK OTHER C ENVIRONMENT JUNK
************************************************************************* */ ************************************************************************* */

517
wmMatrix/matrix.c
View file

@ -31,323 +31,328 @@
#include "resources.h" #include "resources.h"
*/ */
extern GC NormalGC; extern GC NormalGC;
extern GC EraseGC; extern GC EraseGC;
extern Pixel back_pix, fore_pix; extern Pixel back_pix, fore_pix;
extern int PixmapSize; extern int PixmapSize;
int CHAR_HEIGHT; int CHAR_HEIGHT;
static void load_images(m_state * state)
{
if (state->xgwa.depth > 1) {
XpmAttributes xpmattrs;
int result;
xpmattrs.valuemask = 0;
xpmattrs.valuemask |= XpmCloseness;
xpmattrs.closeness = 40000;
xpmattrs.valuemask |= XpmVisual;
xpmattrs.visual = state->xgwa.visual;
xpmattrs.valuemask |= XpmDepth;
xpmattrs.depth = state->xgwa.depth;
xpmattrs.valuemask |= XpmColormap;
xpmattrs.colormap = state->xgwa.colormap;
static void load_images (m_state *state) { if (PixmapSize == 1) {
if (state->xgwa.depth > 1) { CHAR_HEIGHT = 4;
result = XpmCreatePixmapFromData(state->dpy, state->window, small, &state->images, 0 /* mask */ ,
&xpmattrs);
} else if (PixmapSize == 2) {
XpmAttributes xpmattrs; CHAR_HEIGHT = 6;
int result; result = XpmCreatePixmapFromData(state->dpy, state->window, medium, &state->images, 0 /* mask */ ,
&xpmattrs);
} else {
xpmattrs.valuemask = 0; CHAR_HEIGHT = 8;
xpmattrs.valuemask |= XpmCloseness; result = XpmCreatePixmapFromData(state->dpy, state->window, large, &state->images, 0 /* mask */ ,
xpmattrs.closeness = 40000; &xpmattrs);
xpmattrs.valuemask |= XpmVisual; }
xpmattrs.visual = state->xgwa.visual;
xpmattrs.valuemask |= XpmDepth;
xpmattrs.depth = state->xgwa.depth;
xpmattrs.valuemask |= XpmColormap;
xpmattrs.colormap = state->xgwa.colormap;
if (PixmapSize == 1){ if (!state->images || (result != XpmSuccess && result != XpmColorError))
state->images = 0;
CHAR_HEIGHT = 4; state->image_width = xpmattrs.width;
result = XpmCreatePixmapFromData (state->dpy, state->window, small, state->image_height = xpmattrs.height;
&state->images, 0 /* mask */, state->nglyphs = state->image_height / CHAR_HEIGHT;
&xpmattrs);
} else if (PixmapSize == 2){
CHAR_HEIGHT = 6; } else {
result = XpmCreatePixmapFromData (state->dpy, state->window, medium,
&state->images, 0 /* mask */,
&xpmattrs);
} else {
CHAR_HEIGHT = 8; state->image_width = matrix_width;
result = XpmCreatePixmapFromData (state->dpy, state->window, large, state->image_height = matrix_height;
&state->images, 0 /* mask */, state->nglyphs = state->image_height / CHAR_HEIGHT;
&xpmattrs);
}
if (!state->images || (result != XpmSuccess && result != XpmColorError)) state->images = XCreatePixmapFromBitmapData(state->dpy, state->window,
state->images = 0; (char *)matrix_bits,
state->image_width, state->image_height, back_pix, fore_pix, state->xgwa.depth);
state->image_width = xpmattrs.width; }
state->image_height = xpmattrs.height;
state->nglyphs = state->image_height / CHAR_HEIGHT;
} else {
state->image_width = matrix_width;
state->image_height = matrix_height;
state->nglyphs = state->image_height / CHAR_HEIGHT;
state->images = XCreatePixmapFromBitmapData (state->dpy, state->window,
(char *) matrix_bits,
state->image_width, state->image_height,
back_pix, fore_pix, state->xgwa.depth);
}
} }
m_state *init_matrix(Display * dpy, Window window)
{
m_state *init_matrix( Display *dpy, Window window ) { m_state *state = (m_state *) calloc(sizeof(*state), 1);
m_state *state = (m_state *) calloc (sizeof(*state), 1); state->dpy = dpy;
state->window = window;
XGetWindowAttributes(dpy, window, &state->xgwa);
load_images(state);
state->dpy = dpy; state->draw_gc = NormalGC;
state->window = window; state->erase_gc = EraseGC;
XGetWindowAttributes (dpy, window, &state->xgwa); state->char_width = state->image_width / 2;
load_images (state); state->char_height = CHAR_HEIGHT;
state->draw_gc = NormalGC; state->grid_width = state->xgwa.width / state->char_width;
state->erase_gc = EraseGC; state->grid_height = state->xgwa.height / state->char_height;
state->grid_width++;
state->grid_height++;
state->char_width = state->image_width / 2; state->cells = (m_cell *) calloc(sizeof(m_cell), state->grid_width * state->grid_height);
state->char_height = CHAR_HEIGHT; state->feeders = (m_feeder *) calloc(sizeof(m_feeder), state->grid_width);
state->grid_width = state->xgwa.width / state->char_width; state->density = 40;
state->grid_height = state->xgwa.height / state->char_height;
state->grid_width++;
state->grid_height++;
state->cells = (m_cell *)calloc (sizeof(m_cell), state->grid_width * state->grid_height); state->insert_top_p = False;
state->feeders = (m_feeder *)calloc (sizeof(m_feeder), state->grid_width); state->insert_bottom_p = True;
state->density = 40; return state;
state->insert_top_p = False;
state->insert_bottom_p = True;
return state;
} }
static void insert_glyph(m_state * state, int glyph, int x, int y)
{
static void insert_glyph (m_state *state, int glyph, int x, int y) { Bool bottom_feeder_p = (y >= 0);
m_cell *from, *to;
Bool bottom_feeder_p = (y >= 0); if (y >= state->grid_height)
m_cell *from, *to; return;
if (y >= state->grid_height) return; if (bottom_feeder_p) {
if (bottom_feeder_p) { to = &state->cells[state->grid_width * y + x];
to = &state->cells[state->grid_width * y + x]; } else {
} else { for (y = state->grid_height - 1; y > 0; y--) {
for (y = state->grid_height-1; y > 0; y--) { from = &state->cells[state->grid_width * (y - 1) + x];
to = &state->cells[state->grid_width * y + x];
*to = *from;
to->changed = True;
from = &state->cells[state->grid_width * (y-1) + x]; }
to = &state->cells[state->grid_width * y + x]; to = &state->cells[x];
*to = *from;
to->changed = True;
}
to = &state->cells[x];
}
to->glyph = glyph;
to->changed = True;
if (!to->glyph) ;
else if (bottom_feeder_p) to->glow = 1 + (random() % 2);
else to->glow = 0;
}
static void feed_matrix (m_state *state) {
int x;
/*
* Update according to current feeders.
*/
for (x = 0; x < state->grid_width; x++) {
m_feeder *f = &state->feeders[x];
if (f->throttle) { /* this is a delay tick, synced to frame. */
f->throttle--;
} else if (f->remaining > 0) { /* how many items are in the pipe */
int g = (random() % state->nglyphs) + 1;
insert_glyph (state, g, x, f->y);
f->remaining--;
if (f->y >= 0) f->y++; /* bottom_feeder_p */
} else { /* if pipe is empty, insert spaces */
insert_glyph (state, 0, x, f->y);
if (f->y >= 0) f->y++; /* bottom_feeder_p */
}
if ((random() % 10) == 0) { /* randomly change throttle speed */
f->throttle = ((random() % 5) + (random() % 5));
} }
} to->glyph = glyph;
to->changed = True;
if (!to->glyph) ;
else if (bottom_feeder_p)
to->glow = 1 + (random() % 2);
else
to->glow = 0;
} }
static int densitizer (m_state *state) { static void feed_matrix(m_state * state)
{
/* Horrid kludge that converts percentages (density of screen coverage) int x;
to the parameter that actually controls this. I got this mapping
empirically, on a 1024x768 screen. Sue me. */
if (state->density < 10) return 85;
else if (state->density < 15) return 60;
else if (state->density < 20) return 45;
else if (state->density < 25) return 25;
else if (state->density < 30) return 20;
else if (state->density < 35) return 15;
else if (state->density < 45) return 10;
else if (state->density < 50) return 8;
else if (state->density < 55) return 7;
else if (state->density < 65) return 5;
else if (state->density < 80) return 3;
else if (state->density < 90) return 2;
else return 1;
} /*
* Update according to current feeders.
*/
static void hack_matrix (m_state *state) {
int x;
/* Glow some characters. */
if (!state->insert_bottom_p) {
int i = random() % (state->grid_width / 2);
while (--i > 0) {
int x = random() % state->grid_width;
int y = random() % state->grid_height;
m_cell *cell = &state->cells[state->grid_width * y + x];
if (cell->glyph && cell->glow == 0) {
cell->glow = random() % 10;
cell->changed = True;
}
}
}
/* Change some of the feeders. */
for (x = 0; x < state->grid_width; x++) {
m_feeder *f = &state->feeders[x];
Bool bottom_feeder_p;
if (f->remaining > 0) /* never change if pipe isn't empty */
continue;
if ((random() % densitizer(state)) != 0) /* then change N% of the time */
continue;
f->remaining = 3 + (random() % state->grid_height);
f->throttle = ((random() % 5) + (random() % 5));
if ((random() % 4) != 0)
f->remaining = 0;
if (state->insert_top_p && state->insert_bottom_p)
bottom_feeder_p = (random() & 1);
else
bottom_feeder_p = state->insert_bottom_p;
if (bottom_feeder_p)
f->y = random() % (state->grid_height / 2);
else
f->y = -1;
}
}
void draw_matrix (m_state *state, int d) {
int x, y;
int count = 0;
state->density = d;
feed_matrix( state );
hack_matrix( state );
for (y = 0; y < state->grid_height; y++) {
for (x = 0; x < state->grid_width; x++) { for (x = 0; x < state->grid_width; x++) {
m_cell *cell = &state->cells[state->grid_width * y + x]; m_feeder *f = &state->feeders[x];
if ( cell->glyph ) count++; if (f->throttle) { /* this is a delay tick, synced to frame. */
if ( !cell->changed ) continue; f->throttle--;
if ( cell->glyph == 0 ) { } else if (f->remaining > 0) { /* how many items are in the pipe */
XFillRectangle( state->dpy, state->window, state->erase_gc, int g = (random() % state->nglyphs) + 1;
x * state->char_width, y * state->char_height, insert_glyph(state, g, x, f->y);
state->char_width, state->char_height ); f->remaining--;
} else { if (f->y >= 0)
f->y++; /* bottom_feeder_p */
XCopyArea( state->dpy, state->images, state->window, state->draw_gc, } else { /* if pipe is empty, insert spaces */
(cell->glow ? state->char_width : 0), (cell->glyph - 1) * state->char_height,
state->char_width, state->char_height, x * state->char_width, y * state->char_height );
}
cell->changed = False; insert_glyph(state, 0, x, f->y);
if (f->y >= 0)
f->y++; /* bottom_feeder_p */
if (cell->glow > 0) { }
cell->glow--; if ((random() % 10) == 0) { /* randomly change throttle speed */
cell->changed = True;
} f->throttle = ((random() % 5) + (random() % 5));
}
} }
}
}
static int densitizer(m_state * state)
{
/* Horrid kludge that converts percentages (density of screen coverage)
to the parameter that actually controls this. I got this mapping
empirically, on a 1024x768 screen. Sue me. */
if (state->density < 10)
return 85;
else if (state->density < 15)
return 60;
else if (state->density < 20)
return 45;
else if (state->density < 25)
return 25;
else if (state->density < 30)
return 20;
else if (state->density < 35)
return 15;
else if (state->density < 45)
return 10;
else if (state->density < 50)
return 8;
else if (state->density < 55)
return 7;
else if (state->density < 65)
return 5;
else if (state->density < 80)
return 3;
else if (state->density < 90)
return 2;
else
return 1;
}
static void hack_matrix(m_state * state)
{
int x;
/* Glow some characters. */
if (!state->insert_bottom_p) {
int i = random() % (state->grid_width / 2);
while (--i > 0) {
int x = random() % state->grid_width;
int y = random() % state->grid_height;
m_cell *cell = &state->cells[state->grid_width * y + x];
if (cell->glyph && cell->glow == 0) {
cell->glow = random() % 10;
cell->changed = True;
}
}
}
/* Change some of the feeders. */
for (x = 0; x < state->grid_width; x++) {
m_feeder *f = &state->feeders[x];
Bool bottom_feeder_p;
if (f->remaining > 0) /* never change if pipe isn't empty */
continue;
if ((random() % densitizer(state)) != 0) /* then change N% of the time */
continue;
f->remaining = 3 + (random() % state->grid_height);
f->throttle = ((random() % 5) + (random() % 5));
if ((random() % 4) != 0)
f->remaining = 0;
if (state->insert_top_p && state->insert_bottom_p)
bottom_feeder_p = (random() & 1);
else
bottom_feeder_p = state->insert_bottom_p;
if (bottom_feeder_p)
f->y = random() % (state->grid_height / 2);
else
f->y = -1;
}
}
void draw_matrix(m_state * state, int d)
{
int x, y;
int count = 0;
state->density = d;
feed_matrix(state);
hack_matrix(state);
for (y = 0; y < state->grid_height; y++) {
for (x = 0; x < state->grid_width; x++) {
m_cell *cell = &state->cells[state->grid_width * y + x];
if (cell->glyph)
count++;
if (!cell->changed)
continue;
if (cell->glyph == 0) {
XFillRectangle(state->dpy, state->window, state->erase_gc,
x * state->char_width, y * state->char_height, state->char_width, state->char_height);
} else {
XCopyArea(state->dpy, state->images, state->window, state->draw_gc,
(cell->glow ? state->char_width : 0), (cell->glyph - 1) * state->char_height,
state->char_width, state->char_height, x * state->char_width, y * state->char_height);
}
cell->changed = False;
if (cell->glow > 0) {
cell->glow--;
cell->changed = True;
}
}
}
#if 0 #if 0
{ {
static int i = 0; static int i = 0;
static int ndens = 0; static int ndens = 0;
static int tdens = 0; static int tdens = 0;
i++; i++;
if (i > 50) if (i > 50) {
{ int dens = (100.0 * (((double)count) / ((double)(state->grid_width * state->grid_height))));
int dens = (100.0 * tdens += dens;
(((double)count) / ndens++;
((double) (state->grid_width * state->grid_height)))); printf("density: %d%% (%d%%)\n", dens, (tdens / ndens));
tdens += dens; i = 0;
ndens++; }
printf ("density: %d%% (%d%%)\n", dens, (tdens / ndens)); }
i = 0;
}
}
#endif #endif
} }

40
wmMatrix/matrix.h
View file

@ -6,34 +6,32 @@
#include <X11/Xutil.h> #include <X11/Xutil.h>
#include <X11/xpm.h> #include <X11/xpm.h>
typedef struct { typedef struct {
int glyph; int glyph;
int changed; int changed;
int glow; int glow;
} m_cell; } m_cell;
typedef struct { typedef struct {
int remaining; int remaining;
int throttle; int throttle;
int y; int y;
} m_feeder; } m_feeder;
typedef struct { typedef struct {
Display *dpy; Display *dpy;
Window window; Window window;
XWindowAttributes xgwa; XWindowAttributes xgwa;
GC draw_gc, erase_gc; GC draw_gc, erase_gc;
int grid_width, grid_height; int grid_width, grid_height;
int char_width, char_height; int char_width, char_height;
m_cell *cells; m_cell *cells;
m_feeder *feeders; m_feeder *feeders;
int insert_top_p, insert_bottom_p; int insert_top_p, insert_bottom_p;
int density; int density;
Pixmap images; Pixmap images;
int image_width, image_height; int image_width, image_height;
int nglyphs; int nglyphs;
} m_state; } m_state;

3
wmMatrix/version.h
View file

@ -1,2 +1 @@
static const char screensaver_id[] = static const char screensaver_id[] = "@(#)xscreensaver 3.17 (15-Jul-99), by Jamie Zawinski (jwz@jwz.org)";
"@(#)xscreensaver 3.17 (15-Jul-99), by Jamie Zawinski (jwz@jwz.org)";

323
wmMatrix/wmMatrix.c
View file

@ -38,7 +38,6 @@
* *
*/ */
/* /*
* Includes * Includes
*/ */
@ -54,157 +53,155 @@
#include "wmMatrix_mask.xbm" #include "wmMatrix_mask.xbm"
#include "matrix.h" #include "matrix.h"
/* /*
* Delay between refreshes (in microseconds) * Delay between refreshes (in microseconds)
*/ */
#define DELAY 20000UL /* 0.020000 sec */ #define DELAY 20000UL /* 0.020000 sec */
#define WMMATRIX_VERSION "0.2" #define WMMATRIX_VERSION "0.2"
void ParseCMDLine(int argc, char *argv[]);
void ButtonPressEvent(XButtonEvent *);
void print_usage();
m_state *init_matrix(Display *, Window);
void draw_matrix(m_state *, int);
void ParseCMDLine(int argc, char *argv[]); int GotFirstClick1, GotDoubleClick1;
void ButtonPressEvent(XButtonEvent *); int GotFirstClick2, GotDoubleClick2;
void print_usage(); int GotFirstClick3, GotDoubleClick3;
m_state *init_matrix( Display *, Window ); int DblClkDelay;
void draw_matrix( m_state *, int );
int GotFirstClick1, GotDoubleClick1;
int GotFirstClick2, GotDoubleClick2;
int GotFirstClick3, GotDoubleClick3;
int DblClkDelay;
/*int HasExecute;*/ /*int HasExecute;*/
/*char* ExecuteCommand = "xmatrixsmall";*/ /*char* ExecuteCommand = "xmatrixsmall";*/
char *progname = "wmMatrix"; char *progname = "wmMatrix";
char *progclass = "WMMatrix"; char *progclass = "WMMatrix";
int PixmapSize; int PixmapSize;
char *DoubleClickCmd = NULL; char *DoubleClickCmd = NULL;
char *RDoubleClickCmd = NULL; char *RDoubleClickCmd = NULL;
char* TimeColor = "#ffff00"; char *TimeColor = "#ffff00";
char* BackgroundColor = "#181818"; char *BackgroundColor = "#181818";
/* /*
* main * main
*/ */
int main(int argc, char *argv[]) { int main(int argc, char *argv[])
XEvent event; {
m_state *state; XEvent event;
m_state *state;
/*
* Parse any command line arguments.
*/
ParseCMDLine(argc, argv);
if(DoubleClickCmd==NULL)
DoubleClickCmd=strdup("xscreensaver-demo");
if(RDoubleClickCmd==NULL)
RDoubleClickCmd=strdup("xscreensaver-command -activate");
initXwindow(argc, argv);
openXwindow(argc, argv, wmMatrix_master, wmMatrix_mask_bits, wmMatrix_mask_width, wmMatrix_mask_height);
state = init_matrix( display, iconwin );
/*
* Loop until we die
*/
while(1) {
draw_matrix( state, 40 );
/*
* Double Click Delays
* Keep track of click events. If Delay too long, set GotFirstClick's to False.
*/
/* 25 * 0.02 = .5 sec */
if (DblClkDelay > 25) {
DblClkDelay = 0;
GotFirstClick1 = 0; GotDoubleClick1 = 0;
GotFirstClick2 = 0; GotDoubleClick2 = 0;
GotFirstClick3 = 0; GotDoubleClick3 = 0;
} else {
++DblClkDelay;
}
/* /*
* Process any pending X events. * Parse any command line arguments.
*/ */
while(XPending(display)){ ParseCMDLine(argc, argv);
XNextEvent(display, &event); if (DoubleClickCmd == NULL)
switch(event.type){ DoubleClickCmd = strdup("xscreensaver-demo");
case Expose: if (RDoubleClickCmd == NULL)
RedrawWindow(); RDoubleClickCmd = strdup("xscreensaver-command -activate");
break; initXwindow(argc, argv);
case ButtonPress: openXwindow(argc, argv, wmMatrix_master, wmMatrix_mask_bits, wmMatrix_mask_width, wmMatrix_mask_height);
ButtonPressEvent(&event.xbutton); state = init_matrix(display, iconwin);
break;
case ButtonRelease:
break;
}
}
/* /*
* sleep till next update. I cant seem to get usleep or select to work properly * Loop until we die
* with args smaller than 10000. A kernel tick problem? If I comment out the next line,
* the app screams (chews up cpu too). Or if I use DELAY of 0 it also screams.
* But a delay of 1 or higher is slow.....
*
*/ */
short_uusleep(DELAY); while (1) {
} draw_matrix(state, 40);
/*
* Double Click Delays
* Keep track of click events. If Delay too long, set GotFirstClick's to False.
*/
/* 25 * 0.02 = .5 sec */
if (DblClkDelay > 25) {
DblClkDelay = 0;
GotFirstClick1 = 0;
GotDoubleClick1 = 0;
GotFirstClick2 = 0;
GotDoubleClick2 = 0;
GotFirstClick3 = 0;
GotDoubleClick3 = 0;
} else {
++DblClkDelay;
}
/*
* Process any pending X events.
*/
while (XPending(display)) {
XNextEvent(display, &event);
switch (event.type) {
case Expose:
RedrawWindow();
break;
case ButtonPress:
ButtonPressEvent(&event.xbutton);
break;
case ButtonRelease:
break;
}
}
/*
* sleep till next update. I cant seem to get usleep or select to work properly
* with args smaller than 10000. A kernel tick problem? If I comment out the next line,
* the app screams (chews up cpu too). Or if I use DELAY of 0 it also screams.
* But a delay of 1 or higher is slow.....
*
*/
short_uusleep(DELAY);
}
} }
/* /*
* ParseCMDLine() * ParseCMDLine()
*/ */
void ParseCMDLine(int argc, char *argv[]) { void ParseCMDLine(int argc, char *argv[])
int i; {
PixmapSize = 2; int i;
for (i = 1; i < argc; i++) { PixmapSize = 2;
if (!strcmp(argv[i], "-display")){ for (i = 1; i < argc; i++) {
++i; if (!strcmp(argv[i], "-display")) {
} else if (!strcmp(argv[i], "-c")){ ++i;
if ((i+1 >= argc)||(argv[i+1][0] == '-')) { } else if (!strcmp(argv[i], "-c")) {
fprintf(stderr, "wmMatrix: No command given\n"); if ((i + 1 >= argc) || (argv[i + 1][0] == '-')) {
print_usage(); fprintf(stderr, "wmMatrix: No command given\n");
exit(-1); print_usage();
} exit(-1);
if(DoubleClickCmd!=NULL) }
free(DoubleClickCmd); if (DoubleClickCmd != NULL)
DoubleClickCmd=strdup(argv[++i]); free(DoubleClickCmd);
} else if (!strcmp(argv[i], "-cr")){ DoubleClickCmd = strdup(argv[++i]);
if ((i+1 >= argc)||(argv[i+1][0] == '-')) { } else if (!strcmp(argv[i], "-cr")) {
fprintf(stderr, "wmMatrix: No command given\n"); if ((i + 1 >= argc) || (argv[i + 1][0] == '-')) {
print_usage(); fprintf(stderr, "wmMatrix: No command given\n");
exit(-1); print_usage();
} exit(-1);
if(RDoubleClickCmd!=NULL) }
free(RDoubleClickCmd); if (RDoubleClickCmd != NULL)
RDoubleClickCmd=strdup(argv[++i]); free(RDoubleClickCmd);
} else if (!strcmp(argv[i], "-sml")){ RDoubleClickCmd = strdup(argv[++i]);
PixmapSize = 1; } else if (!strcmp(argv[i], "-sml")) {
} else if (!strcmp(argv[i], "-med")){ PixmapSize = 1;
PixmapSize = 2; } else if (!strcmp(argv[i], "-med")) {
} else if (!strcmp(argv[i], "-lrg")){ PixmapSize = 2;
PixmapSize = 3; } else if (!strcmp(argv[i], "-lrg")) {
} else { PixmapSize = 3;
print_usage(); } else {
exit(1); print_usage();
exit(1);
}
} }
}
} }
void print_usage()
void print_usage() { {
printf("\nwmMatrix version: %s\n", WMMATRIX_VERSION); printf("\nwmMatrix version: %s\n", WMMATRIX_VERSION);
printf("\t-h\t\tDisplay help screen.\n"); printf("\t-h\t\tDisplay help screen.\n");
printf("\t-c cmd\t\tCommand executed on doubleclick.\n"); printf("\t-c cmd\t\tCommand executed on doubleclick.\n");
printf("\t-cr cmd\t\tCommand executed on right doubleclick\n"); printf("\t-cr cmd\t\tCommand executed on right doubleclick\n");
printf("\t-sml\t\tUse small size pixmap.\n"); printf("\t-sml\t\tUse small size pixmap.\n");
printf("\t-med\t\tUse medium size pixmap.\n"); printf("\t-med\t\tUse medium size pixmap.\n");
printf("\t-lrg\t\tUse large size pixmap.\n"); printf("\t-lrg\t\tUse large size pixmap.\n");
} }
/* /*
* This routine handles button presses. * This routine handles button presses.
* *
@ -215,46 +212,50 @@ void print_usage() {
* *
* *
*/ */
void ButtonPressEvent(XButtonEvent *xev){ void ButtonPressEvent(XButtonEvent * xev)
DblClkDelay = 0; {
if ((xev->button == Button1) && (xev->type == ButtonPress)){ DblClkDelay = 0;
if (GotFirstClick1) GotDoubleClick1 = 1; if ((xev->button == Button1) && (xev->type == ButtonPress)) {
else GotFirstClick1 = 1; if (GotFirstClick1)
} else if ((xev->button == Button2) && (xev->type == ButtonPress)){ GotDoubleClick1 = 1;
if (GotFirstClick2) GotDoubleClick2 = 1; else
else GotFirstClick2 = 1; GotFirstClick1 = 1;
} else if ((xev->button == Button3) && (xev->type == ButtonPress)){ } else if ((xev->button == Button2) && (xev->type == ButtonPress)) {
if (GotFirstClick3) GotDoubleClick3 = 1; if (GotFirstClick2)
else GotFirstClick3 = 1; GotDoubleClick2 = 1;
} else
GotFirstClick2 = 1;
} else if ((xev->button == Button3) && (xev->type == ButtonPress)) {
if (GotFirstClick3)
GotDoubleClick3 = 1;
else
GotFirstClick3 = 1;
}
/*
* We got a double click on Mouse Button1 (i.e. the left one)
*/
if (GotDoubleClick1) {
GotFirstClick1 = 0;
GotDoubleClick1 = 0;
system(DoubleClickCmd);
}
/* /*
* We got a double click on Mouse Button1 (i.e. the left one) * We got a double click on Mouse Button2 (i.e. the middle one)
*/ */
if (GotDoubleClick1) { if (GotDoubleClick2) {
GotFirstClick1 = 0; GotFirstClick2 = 0;
GotDoubleClick1 = 0; GotDoubleClick2 = 0;
system(DoubleClickCmd); }
}
/*
/* * We got a double click on Mouse Button3 (i.e. the right one)
* We got a double click on Mouse Button2 (i.e. the middle one) */
*/ if (GotDoubleClick3) {
if (GotDoubleClick2) { GotFirstClick3 = 0;
GotFirstClick2 = 0; GotDoubleClick3 = 0;
GotDoubleClick2 = 0; system(RDoubleClickCmd);
} }
return;
/*
* We got a double click on Mouse Button3 (i.e. the right one)
*/
if (GotDoubleClick3) {
GotFirstClick3 = 0;
GotDoubleClick3 = 0;
system(RDoubleClickCmd);
}
return;
} }

461
wmMatrix/xutils.c
View file

@ -27,7 +27,7 @@
* *
* *
* *
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@ -41,342 +41,297 @@
#include <sys/select.h> #include <sys/select.h>
#include "xutils.h" #include "xutils.h"
/* /*
* X11 Variables * X11 Variables
*/ */
int x_fd; int x_fd;
XSizeHints mysizehints; XSizeHints mysizehints;
XWMHints mywmhints; XWMHints mywmhints;
Pixel back_pix, fore_pix; Pixel back_pix, fore_pix;
char *Geometry = ""; char *Geometry = "";
GC NormalGC; GC NormalGC;
GC EraseGC; GC EraseGC;
XpmIcon wmgen; XpmIcon wmgen;
Pixmap pixmask; Pixmap pixmask;
/* /*
* Colors for wmCalClock * Colors for wmCalClock
*/ */
extern char TimeColor[30]; extern char TimeColor[30];
extern char BackgroundColor[30]; extern char BackgroundColor[30];
/* /*
* flush_expose * flush_expose
*/ */
static int flush_expose(Window w) { static int flush_expose(Window w)
{
XEvent dummy; XEvent dummy;
int i=0; int i = 0;
while (XCheckTypedWindowEvent(display, w, Expose, &dummy)) while (XCheckTypedWindowEvent(display, w, Expose, &dummy))
i++; i++;
return i; return i;
} }
/* /*
* RedrawWindow * RedrawWindow
* RedrawWindowXY * RedrawWindowXY
*/ */
void RedrawWindow(void) { void RedrawWindow(void)
{
flush_expose(iconwin);
XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, 0,0, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
flush_expose(win); flush_expose(iconwin);
XCopyArea(display, wmgen.pixmap, win, NormalGC, 0,0, wmgen.attributes.width, wmgen.attributes.height, 0, 0); XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, 0, 0, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
flush_expose(win);
XCopyArea(display, wmgen.pixmap, win, NormalGC, 0, 0, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
} }
void RedrawWindowXY(int x, int y) { void RedrawWindowXY(int x, int y)
{
flush_expose(iconwin);
XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, x,y, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
flush_expose(win); flush_expose(iconwin);
XCopyArea(display, wmgen.pixmap, win, NormalGC, x,y, wmgen.attributes.width, wmgen.attributes.height, 0, 0); XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, x, y, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
flush_expose(win);
XCopyArea(display, wmgen.pixmap, win, NormalGC, x, y, wmgen.attributes.width, wmgen.attributes.height, 0, 0);
} }
/* /*
* copyXPMArea * copyXPMArea
* copyXBMArea * copyXBMArea
*/ */
void copyXPMArea(int x, int y, int sx, int sy, int dx, int dy) { void copyXPMArea(int x, int y, int sx, int sy, int dx, int dy)
{
XCopyArea(display, wmgen.pixmap, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy); XCopyArea(display, wmgen.pixmap, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy);
} }
void copyXBMArea(int x, int y, int sx, int sy, int dx, int dy) { void copyXBMArea(int x, int y, int sx, int sy, int dx, int dy)
{
XCopyArea(display, wmgen.mask, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy); XCopyArea(display, wmgen.mask, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy);
} }
/* /*
* initXwindow * initXwindow
*/ */
void initXwindow(int argc, char *argv[]){ void initXwindow(int argc, char *argv[])
{
int i; int i;
char *display_name = NULL; char *display_name = NULL;
for (i=1; argv[i]; ++i) { for (i = 1; argv[i]; ++i) {
if (!strcmp(argv[i], "-display")) display_name = argv[i+1]; if (!strcmp(argv[i], "-display"))
} display_name = argv[i + 1];
}
if (!(display = XOpenDisplay(display_name))) {
fprintf(stderr, "%s: can't open display %s\n", argv[0], XDisplayName(display_name));
exit(1);
}
if (!(display = XOpenDisplay(display_name))) { screen = DefaultScreen(display);
fprintf(stderr, "%s: can't open display %s\n", Root = RootWindow(display, screen);
argv[0], XDisplayName(display_name)); DisplayDepth = DefaultDepth(display, screen);
exit(1); x_fd = XConnectionNumber(display);
}
screen = DefaultScreen(display);
Root = RootWindow(display, screen);
DisplayDepth = DefaultDepth(display, screen);
x_fd = XConnectionNumber(display);
} }
/* /*
* openXwindow * openXwindow
*/ */
void openXwindow(int argc, char *argv[], char *pixmap_bytes[], char *pixmask_bits, void openXwindow(int argc, char *argv[], char *pixmap_bytes[], char *pixmask_bits, int pixmask_width, int pixmask_height)
int pixmask_width, int pixmask_height) { {
unsigned int borderwidth = 1; unsigned int borderwidth = 1;
XClassHint classHint; XClassHint classHint;
char *wname = argv[0]; char *wname = argv[0];
XTextProperty name; XTextProperty name;
XGCValues gcv; XGCValues gcv;
unsigned long gcm; unsigned long gcm;
int dummy=0, red, grn, blu; int dummy = 0, red, grn, blu;
XpmColorSymbol cols[10]={ {"Back", NULL, 0}, XpmColorSymbol cols[10] = { {"Back", NULL, 0},
{"Color1", NULL, 0}, {"Color1", NULL, 0},
{"Color2", NULL, 0}, {"Color2", NULL, 0},
{"Color3", NULL, 0}, {"Color3", NULL, 0},
{"Color4", NULL, 0}, {"Color4", NULL, 0},
{"Color5", NULL, 0}, {"Color5", NULL, 0},
{"Color6", NULL, 0}, {"Color6", NULL, 0},
{"Color7", NULL, 0}, {"Color7", NULL, 0},
{"Color8", NULL, 0}, {"Color8", NULL, 0},
{"Color9", NULL, 0}}; {"Color9", NULL, 0}
};
/*
* Create Pixmap
*/
cols[0].pixel = getColor(BackgroundColor, 1.0000, &red, &grn, &blu);
cols[1].pixel = getBlendedColor(TimeColor, 0.1522, red, grn, blu);
cols[2].pixel = getBlendedColor(TimeColor, 0.2602, red, grn, blu);
cols[3].pixel = getBlendedColor(TimeColor, 0.3761, red, grn, blu);
cols[4].pixel = getBlendedColor(TimeColor, 0.4841, red, grn, blu);
cols[5].pixel = getBlendedColor(TimeColor, 0.5922, red, grn, blu);
cols[6].pixel = getBlendedColor(TimeColor, 0.6980, red, grn, blu);
cols[7].pixel = getBlendedColor(TimeColor, 0.7961, red, grn, blu);
cols[8].pixel = getBlendedColor(TimeColor, 0.8941, red, grn, blu);
cols[9].pixel = getBlendedColor(TimeColor, 1.0000, red, grn, blu);
wmgen.attributes.numsymbols = 10;
wmgen.attributes.colorsymbols = cols;
wmgen.attributes.exactColors = False;
wmgen.attributes.closeness = 40000;
wmgen.attributes.valuemask = XpmReturnPixels | XpmReturnExtensions | XpmColorSymbols | XpmExactColors | XpmCloseness | XpmSize;
if (XpmCreatePixmapFromData(display, Root, pixmap_bytes, &(wmgen.pixmap), &(wmgen.mask), &(wmgen.attributes)) != XpmSuccess) {
fprintf(stderr, "Not enough free colorcells.\n");
exit(1);
}
/* /*
* Create Pixmap * Create a window
*/ */
cols[0].pixel = getColor(BackgroundColor, 1.0000, &red, &grn, &blu); mysizehints.flags = USSize | USPosition;
cols[1].pixel = getBlendedColor(TimeColor, 0.1522, red, grn, blu); mysizehints.x = 0;
cols[2].pixel = getBlendedColor(TimeColor, 0.2602, red, grn, blu); mysizehints.y = 0;
cols[3].pixel = getBlendedColor(TimeColor, 0.3761, red, grn, blu);
cols[4].pixel = getBlendedColor(TimeColor, 0.4841, red, grn, blu);
cols[5].pixel = getBlendedColor(TimeColor, 0.5922, red, grn, blu);
cols[6].pixel = getBlendedColor(TimeColor, 0.6980, red, grn, blu);
cols[7].pixel = getBlendedColor(TimeColor, 0.7961, red, grn, blu);
cols[8].pixel = getBlendedColor(TimeColor, 0.8941, red, grn, blu);
cols[9].pixel = getBlendedColor(TimeColor, 1.0000, red, grn, blu);
wmgen.attributes.numsymbols = 10; back_pix = getColor("black", 1.0, &red, &grn, &blu);
wmgen.attributes.colorsymbols = cols; fore_pix = getColor("white", 1.0, &red, &grn, &blu);
wmgen.attributes.exactColors = False;
wmgen.attributes.closeness = 40000;
wmgen.attributes.valuemask = XpmReturnPixels | XpmReturnExtensions | XpmColorSymbols
| XpmExactColors | XpmCloseness | XpmSize;
if (XpmCreatePixmapFromData(display, Root, pixmap_bytes,
&(wmgen.pixmap), &(wmgen.mask), &(wmgen.attributes)) != XpmSuccess){
fprintf(stderr, "Not enough free colorcells.\n");
exit(1);
}
XWMGeometry(display, screen, Geometry, NULL, borderwidth, &mysizehints,
&mysizehints.x, &mysizehints.y, &mysizehints.width, &mysizehints.height, &dummy);
mysizehints.width = 64;
mysizehints.height = 64;
win = XCreateSimpleWindow(display, Root, mysizehints.x, mysizehints.y,
mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);
/* iconwin = XCreateSimpleWindow(display, win, mysizehints.x, mysizehints.y,
* Create a window mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);
*/
mysizehints.flags = USSize | USPosition;
mysizehints.x = 0;
mysizehints.y = 0;
back_pix = getColor("black", 1.0, &red, &grn, &blu); /*
fore_pix = getColor("white", 1.0, &red, &grn, &blu); * Activate hints
*/
XSetWMNormalHints(display, win, &mysizehints);
classHint.res_name = wname;
classHint.res_class = wname;
XSetClassHint(display, win, &classHint);
XWMGeometry(display, screen, Geometry, NULL, borderwidth, &mysizehints, /*
&mysizehints.x, &mysizehints.y,&mysizehints.width,&mysizehints.height, &dummy); * Set up the xevents that you want the relevent windows to inherit
* Currently, its seems that setting KeyPress events here has no
* effect. I.e. for some you will need to Grab the focus and then return
* it after you are done...
*/
XSelectInput(display, win, ButtonPressMask | ExposureMask | ButtonReleaseMask
| PointerMotionMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask | KeyPressMask | KeyReleaseMask);
XSelectInput(display, iconwin, ButtonPressMask | ExposureMask | ButtonReleaseMask
| PointerMotionMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask | KeyPressMask | KeyReleaseMask);
mysizehints.width = 64; if (XStringListToTextProperty(&wname, 1, &name) == 0) {
mysizehints.height = 64; fprintf(stderr, "%s: can't allocate window name\n", wname);
exit(1);
}
XSetWMName(display, win, &name);
win = XCreateSimpleWindow(display, Root, mysizehints.x, mysizehints.y, /*
mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix); * Create Graphics Context (GC) for drawing
*/
iconwin = XCreateSimpleWindow(display, win, mysizehints.x, mysizehints.y, gcm = GCForeground | GCBackground | GCGraphicsExposures;
mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix); gcv.foreground = fore_pix;
gcv.background = back_pix;
gcv.graphics_exposures = 0;
NormalGC = XCreateGC(display, Root, gcm, &gcv);
/*
* Create Graphics Context (GC) for erasing
*/
gcm = GCForeground | GCBackground | GCGraphicsExposures;
gcv.foreground = back_pix;
gcv.background = back_pix;
gcv.graphics_exposures = 0;
EraseGC = XCreateGC(display, Root, gcm, &gcv);
pixmask = XCreateBitmapFromData(display, win, pixmask_bits, pixmask_width, pixmask_height);
XShapeCombineMask(display, win, ShapeBounding, 0, 0, pixmask, ShapeSet);
XShapeCombineMask(display, iconwin, ShapeBounding, 0, 0, pixmask, ShapeSet);
/* mywmhints.initial_state = WithdrawnState;
* Activate hints mywmhints.icon_window = iconwin;
*/ mywmhints.icon_x = mysizehints.x;
XSetWMNormalHints(display, win, &mysizehints); mywmhints.icon_y = mysizehints.y;
classHint.res_name = wname; mywmhints.window_group = win;
classHint.res_class = wname; mywmhints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint;
XSetClassHint(display, win, &classHint);
XSetWMHints(display, win, &mywmhints);
XSetCommand(display, win, argv, argc);
/* XMapWindow(display, win);
* Set up the xevents that you want the relevent windows to inherit
* Currently, its seems that setting KeyPress events here has no
* effect. I.e. for some you will need to Grab the focus and then return
* it after you are done...
*/
XSelectInput(display, win, ButtonPressMask | ExposureMask | ButtonReleaseMask
| PointerMotionMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask
| KeyPressMask | KeyReleaseMask);
XSelectInput(display, iconwin, ButtonPressMask | ExposureMask | ButtonReleaseMask
| PointerMotionMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask
| KeyPressMask | KeyReleaseMask);
if (XStringListToTextProperty(&wname, 1, &name) == 0) {
fprintf(stderr, "%s: can't allocate window name\n", wname);
exit(1);
}
XSetWMName(display, win, &name);
/*
* Create Graphics Context (GC) for drawing
*/
gcm = GCForeground | GCBackground | GCGraphicsExposures;
gcv.foreground = fore_pix;
gcv.background = back_pix;
gcv.graphics_exposures = 0;
NormalGC = XCreateGC(display, Root, gcm, &gcv);
/*
* Create Graphics Context (GC) for erasing
*/
gcm = GCForeground | GCBackground | GCGraphicsExposures;
gcv.foreground = back_pix;
gcv.background = back_pix;
gcv.graphics_exposures = 0;
EraseGC = XCreateGC(display, Root, gcm, &gcv);
pixmask = XCreateBitmapFromData(display, win, pixmask_bits, pixmask_width, pixmask_height);
XShapeCombineMask(display, win, ShapeBounding, 0, 0, pixmask, ShapeSet);
XShapeCombineMask(display, iconwin, ShapeBounding, 0, 0, pixmask, ShapeSet);
mywmhints.initial_state = WithdrawnState;
mywmhints.icon_window = iconwin;
mywmhints.icon_x = mysizehints.x;
mywmhints.icon_y = mysizehints.y;
mywmhints.window_group = win;
mywmhints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint;
XSetWMHints(display, win, &mywmhints);
XSetCommand(display, win, argv, argc);
XMapWindow(display, win);
} }
unsigned long getColor(char *ColorName, float fac, int *red, int *grn, int *blu) { unsigned long getColor(char *ColorName, float fac, int *red, int *grn, int *blu)
{
XColor Color; XColor Color;
XWindowAttributes Attributes; XWindowAttributes Attributes;
XGetWindowAttributes(display, Root, &Attributes); XGetWindowAttributes(display, Root, &Attributes);
Color.pixel = 0; Color.pixel = 0;
XParseColor(display, Attributes.colormap, ColorName, &Color); XParseColor(display, Attributes.colormap, ColorName, &Color);
Color.red = (unsigned short)(fac*(Color.red-24) + 24); Color.red = (unsigned short)(fac * (Color.red - 24) + 24);
Color.blue = (unsigned short)(fac*(Color.blue-24) + 24); Color.blue = (unsigned short)(fac * (Color.blue - 24) + 24);
Color.green = (unsigned short)(fac*(Color.green-24) + 24); Color.green = (unsigned short)(fac * (Color.green - 24) + 24);
Color.flags = DoRed | DoGreen | DoBlue; Color.flags = DoRed | DoGreen | DoBlue;
XAllocColor(display, Attributes.colormap, &Color); XAllocColor(display, Attributes.colormap, &Color);
*red = Color.red;
*red = Color.red; *grn = Color.green;
*grn = Color.green; *blu = Color.blue;
*blu = Color.blue; return Color.pixel;
return Color.pixel;
} }
unsigned long getBlendedColor(char *ColorName, float fac, int red, int grn, int blu) { unsigned long getBlendedColor(char *ColorName, float fac, int red, int grn, int blu)
{
XColor Color; XColor Color;
XWindowAttributes Attributes; XWindowAttributes Attributes;
XGetWindowAttributes(display, Root, &Attributes); XGetWindowAttributes(display, Root, &Attributes);
Color.pixel = 0; Color.pixel = 0;
XParseColor(display, Attributes.colormap, ColorName, &Color); XParseColor(display, Attributes.colormap, ColorName, &Color);
Color.red = (unsigned short)(fac*(Color.red-red) + red); Color.red = (unsigned short)(fac * (Color.red - red) + red);
Color.blue = (unsigned short)(fac*(Color.blue-grn) + grn); Color.blue = (unsigned short)(fac * (Color.blue - grn) + grn);
Color.green = (unsigned short)(fac*(Color.green-blu) + blu); Color.green = (unsigned short)(fac * (Color.green - blu) + blu);
Color.flags = DoRed | DoGreen | DoBlue; Color.flags = DoRed | DoGreen | DoBlue;
XAllocColor(display, Attributes.colormap, &Color); XAllocColor(display, Attributes.colormap, &Color);
return Color.pixel; return Color.pixel;
} }
/* /*
* Here is a faster version of usleep using select() * Here is a faster version of usleep using select()
*/ */
void uusleep(unsigned long usecs) { void uusleep(unsigned long usecs)
{
struct timeval tv; struct timeval tv;
fd_set fds; fd_set fds;
tv.tv_sec = usecs / 1000000UL; tv.tv_sec = usecs / 1000000UL;
tv.tv_usec = usecs % 1000000UL; tv.tv_usec = usecs % 1000000UL;
FD_ZERO(&fds); FD_ZERO(&fds);
FD_SET(x_fd, &fds); FD_SET(x_fd, &fds);
select(x_fd + 1, &fds, NULL, NULL, &tv); select(x_fd + 1, &fds, NULL, NULL, &tv);
} }
@ -385,15 +340,15 @@ void uusleep(unsigned long usecs) {
* will be less than 1 second. This allows us to save on a div operation. * will be less than 1 second. This allows us to save on a div operation.
* *
*/ */
void short_uusleep(unsigned long usecs) { void short_uusleep(unsigned long usecs)
{
struct timeval tv; struct timeval tv;
fd_set fds; fd_set fds;
tv.tv_sec = 0; tv.tv_sec = 0;
tv.tv_usec = usecs; tv.tv_usec = usecs;
FD_ZERO(&fds); FD_ZERO(&fds);
FD_SET(x_fd, &fds); FD_SET(x_fd, &fds);
select(x_fd + 1, &fds, NULL, NULL, &tv); select(x_fd + 1, &fds, NULL, NULL, &tv);
} }

55
wmMatrix/xutils.h
View file

@ -1,51 +1,40 @@
#ifndef WMGENERAL_H_INCLUDED #ifndef WMGENERAL_H_INCLUDED
#define WMGENERAL_H_INCLUDED #define WMGENERAL_H_INCLUDED
/* /*
* Typedefs * Typedefs
*/ */
typedef struct { typedef struct {
Pixmap pixmap; Pixmap pixmap;
Pixmap mask; Pixmap mask;
XpmAttributes attributes; XpmAttributes attributes;
} XpmIcon; } XpmIcon;
/* /*
* Global variable * Global variable
*/ */
Display *display; Display *display;
Window Root; Window Root;
Window iconwin, win; Window iconwin, win;
int screen; int screen;
int DisplayDepth; int DisplayDepth;
/* /*
* Function Prototypes * Function Prototypes
*/ */
void AddMouseRegion(int, int, int, int, int); void AddMouseRegion(int, int, int, int, int);
int CheckMouseRegion(int, int); int CheckMouseRegion(int, int);
void openXwindow(int, char **, char **, char *, int, int); void openXwindow(int, char **, char **, char *, int, int);
void initXwindow(int, char **); void initXwindow(int, char **);
void RedrawWindow(void); void RedrawWindow(void);
void RedrawWindowXY(int, int); void RedrawWindowXY(int, int);
void copyXPMArea(int, int, int, int, int, int); void copyXPMArea(int, int, int, int, int, int);
void copyXBMArea(int, int, int, int, int, int); void copyXBMArea(int, int, int, int, int, int);
void setMaskXY(int, int); void setMaskXY(int, int);
unsigned long getColor(char *, float, int *, int *, int *); unsigned long getColor(char *, float, int *, int *, int *);
unsigned long getBlendedColor(char *, float, int, int, int); unsigned long getBlendedColor(char *, float, int, int, int);
void RedrawWindow(void); void RedrawWindow(void);
void uusleep( unsigned long ); void uusleep(unsigned long);
void short_uusleep( unsigned long ); void short_uusleep(unsigned long);
#endif #endif

80
wmMatrix/yarandom.c
View file

@ -42,15 +42,13 @@
Irix 6.2; Indy r5k; SGI cc version 6; gcc version 2.7.2.1. Irix 6.2; Indy r5k; SGI cc version 6; gcc version 2.7.2.1.
*/ */
#ifdef HAVE_UNISTD_H #ifdef HAVE_UNISTD_H
# include <unistd.h> /* for getpid() */ #include <unistd.h> /* for getpid() */
#endif #endif
#include <sys/time.h> /* for gettimeofday() */ #include <sys/time.h> /* for gettimeofday() */
#include "yarandom.h" #include "yarandom.h"
/* The following 'random' numbers are taken from CRC, 18th Edition, page 622. /* The following 'random' numbers are taken from CRC, 18th Edition, page 622.
Each array element was taken from the corresponding line in the table, Each array element was taken from the corresponding line in the table,
except that a[0] was from line 100. 8s and 9s in the table were simply except that a[0] was from line 100. 8s and 9s in the table were simply
@ -58,55 +56,53 @@
*/ */
#define VectorSize 55 #define VectorSize 55
static unsigned int a[VectorSize] = { static unsigned int a[VectorSize] = {
035340171546, 010401501101, 022364657325, 024130436022, 002167303062, /* 5 */ 035340171546, 010401501101, 022364657325, 024130436022, 002167303062, /* 5 */
037570375137, 037210607110, 016272055420, 023011770546, 017143426366, /* 10 */ 037570375137, 037210607110, 016272055420, 023011770546, 017143426366, /* 10 */
014753657433, 021657231332, 023553406142, 004236526362, 010365611275, /* 14 */ 014753657433, 021657231332, 023553406142, 004236526362, 010365611275, /* 14 */
007117336710, 011051276551, 002362132524, 001011540233, 012162531646, /* 20 */ 007117336710, 011051276551, 002362132524, 001011540233, 012162531646, /* 20 */
007056762337, 006631245521, 014164542224, 032633236305, 023342700176, /* 25 */ 007056762337, 006631245521, 014164542224, 032633236305, 023342700176, /* 25 */
002433062234, 015257225043, 026762051606, 000742573230, 005366042132, /* 30 */ 002433062234, 015257225043, 026762051606, 000742573230, 005366042132, /* 30 */
012126416411, 000520471171, 000725646277, 020116577576, 025765742604, /* 35 */ 012126416411, 000520471171, 000725646277, 020116577576, 025765742604, /* 35 */
007633473735, 015674255275, 017555634041, 006503154145, 021576344247, /* 40 */ 007633473735, 015674255275, 017555634041, 006503154145, 021576344247, /* 40 */
014577627653, 002707523333, 034146376720, 030060227734, 013765414060, /* 45 */ 014577627653, 002707523333, 034146376720, 030060227734, 013765414060, /* 45 */
036072251540, 007255221037, 024364674123, 006200353166, 010126373326, /* 50 */ 036072251540, 007255221037, 024364674123, 006200353166, 010126373326, /* 50 */
015664104320, 016401041535, 016215305520, 033115351014, 017411670323 /* 55 */ 015664104320, 016401041535, 016215305520, 033115351014, 017411670323 /* 55 */
}; };
static int i1, i2; static int i1, i2;
unsigned int unsigned int ya_random(void)
ya_random (void)
{ {
register int ret = a[i1] + a[i2]; register int ret = a[i1] + a[i2];
a[i1] = ret; a[i1] = ret;
if (++i1 >= VectorSize) i1 = 0; if (++i1 >= VectorSize)
if (++i2 >= VectorSize) i2 = 0; i1 = 0;
return ret; if (++i2 >= VectorSize)
i2 = 0;
return ret;
} }
void void ya_rand_init(unsigned int seed)
ya_rand_init(unsigned int seed)
{ {
int i; int i;
if (seed == 0) if (seed == 0) {
{ struct timeval tp;
struct timeval tp;
#ifdef GETTIMEOFDAY_TWO_ARGS #ifdef GETTIMEOFDAY_TWO_ARGS
struct timezone tzp; struct timezone tzp;
gettimeofday(&tp, &tzp); gettimeofday(&tp, &tzp);
#else #else
gettimeofday(&tp); gettimeofday(&tp);
#endif #endif
/* ignore overflow */ /* ignore overflow */
seed = (999*tp.tv_sec) + (1001*tp.tv_usec) + (1003 * getpid()); seed = (999 * tp.tv_sec) + (1001 * tp.tv_usec) + (1003 * getpid());
} }
a[0] += seed; a[0] += seed;
for (i = 1; i < VectorSize; i++) for (i = 1; i < VectorSize; i++) {
{ seed = a[i - 1] * 1001 + seed * 999;
seed = a[i-1]*1001 + seed*999; a[i] += seed;
a[i] += seed; }
}
i1 = a[0] % VectorSize; i1 = a[0] % VectorSize;
i2 = (i1 + 024) % VectorSize; i2 = (i1 + 024) % VectorSize;
} }

17
wmMatrix/yarandom.h
View file

@ -22,33 +22,32 @@
#undef RAND_MAX #undef RAND_MAX
#ifdef VMS #ifdef VMS
# include "vms-gtod.h" #include "vms-gtod.h"
#endif #endif
#define random() ya_random() #define random() ya_random()
#define srandom(i) ya_rand_init(0) #define srandom(i) ya_rand_init(0)
#define RAND_MAX 0x7FFFFFFF #define RAND_MAX 0x7FFFFFFF
extern unsigned int ya_random (void); extern unsigned int ya_random(void);
extern void ya_rand_init (unsigned int); extern void ya_rand_init(unsigned int);
#if defined (__GNUC__) && (__GNUC__ >= 2) #if defined (__GNUC__) && (__GNUC__ >= 2)
/* Implement frand using GCC's statement-expression extension. */ /* Implement frand using GCC's statement-expression extension. */
# define frand(f) \ #define frand(f) \
({ double tmp = (((double) random()) / \ ({ double tmp = (((double) random()) / \
(((double) ((unsigned int)~0)) / ((double) (f)))); \ (((double) ((unsigned int)~0)) / ((double) (f)))); \
tmp < 0 ? (-tmp) : tmp; }) tmp < 0 ? (-tmp) : tmp; })
#else /* not GCC2 - implement frand using a global variable.*/ #else /* not GCC2 - implement frand using a global variable. */
static double _frand_tmp_; static double _frand_tmp_;
# define frand(f) \ #define frand(f) \
(_frand_tmp_ = (((double) random()) / \ (_frand_tmp_ = (((double) random()) / \
(((double) ((unsigned int)~0)) / ((double) (f)))), \ (((double) ((unsigned int)~0)) / ((double) (f)))), \
_frand_tmp_ < 0 ? (-_frand_tmp_) : _frand_tmp_) _frand_tmp_ < 0 ? (-_frand_tmp_) : _frand_tmp_)
#endif /* not GCC2 */ #endif /* not GCC2 */
#endif /* __YARANDOM_H__ */ #endif /* __YARANDOM_H__ */