bool GuiCalibratorX11::on_timer_signal()
{
// Update clock
if(calibrator->get_use_timeout()) {
time_elapsed += time_step;
if (time_elapsed > calibrator->get_timeout()) {
exit(0);
}
XSetForeground(display, gc, pixel[BLACK]);
XSetLineAttributes(display, gc, clock_line_width,
LineSolid, CapButt, JoinMiter);
XDrawArc(display, win, gc, (display_width-clock_radius+clock_line_width)/2,
(display_height-clock_radius+clock_line_width)/2,
clock_radius-clock_line_width, clock_radius-clock_line_width,
90*64, ((double)time_elapsed/(double)calibrator->get_timeout()) * -360 * 64);
}
return true;
}
void drawWhiteRectangle(UpdateTask *pt) {
Display *display = XtDisplay(pt->displayInfo->drawingArea);
GC gc = pt->displayInfo->pixmapGC;
Drawable drawable = XtWindow(pt->displayInfo->drawingArea);
XSetForeground(display,gc,WhitePixel(display,DefaultScreen(display)));
XFillRectangle(display,drawable,gc,pt->rectangle.x+1,pt->rectangle.y+1,
pt->rectangle.width-2,pt->rectangle.height-2);
XSetForeground(display,gc,BlackPixel(display,DefaultScreen(display)));
XSetLineAttributes(display,gc,0,LineSolid,CapRound,JoinRound);
XDrawRectangle(display,drawable,gc,pt->rectangle.x,pt->rectangle.y,
pt->rectangle.width-1,pt->rectangle.height-1);
#if 0
XSetForeground(display,gc,BlackPixel(display,DefaultScreen(display)));
XFillRectangle(display,drawable,gc,pt->rectangle.x,pt->rectangle.y,
pt->rectangle.width,pt->rectangle.height);
XSetForeground(display,gc,WhitePixel(display,DefaultScreen(display)));
XFillRectangle(display,drawable,gc,pt->rectangle.x+1,pt->rectangle.y+1,
pt->rectangle.width-2,pt->rectangle.height-2);
#endif
}
/**
* Draw fast, XOR line with XDrawLine in front color buffer.
* WARNING: this isn't fully OpenGL conformant because different pixels
* will be hit versus using the other line functions.
* Don't use the code in X server GLcore module since we need a wrapper
* for the XSetLineAttributes() function call.
*/
static void
xor_line(struct gl_context *ctx, const SWvertex *vert0, const SWvertex *vert1)
{
XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
XMesaGC gc = xmesa->xm_buffer->gc;
GET_XRB(xrb);
unsigned long pixel = xmesa_color_to_pixel(ctx,
vert1->color[0], vert1->color[1],
vert1->color[2], vert1->color[3],
xmesa->pixelformat);
int x0 = (GLint) vert0->attrib[VARYING_SLOT_POS][0];
int y0 = YFLIP(xrb, (GLint) vert0->attrib[VARYING_SLOT_POS][1]);
int x1 = (GLint) vert1->attrib[VARYING_SLOT_POS][0];
int y1 = YFLIP(xrb, (GLint) vert1->attrib[VARYING_SLOT_POS][1]);
XMesaSetForeground(dpy, gc, pixel);
XMesaSetFunction(dpy, gc, GXxor);
XSetLineAttributes(dpy, gc, (int) ctx->Line.Width,
LineSolid, CapButt, JoinMiter);
XDrawLine(dpy, xrb->pixmap, gc, x0, y0, x1, y1);
XMesaSetFunction(dpy, gc, GXcopy); /* this gc is used elsewhere */
}
struct wm_window* create_parent_window(struct wm_window *child) {
GC gc;
XGCValues values;
struct wm_window *parent_win = (struct wm_window *)malloc(sizeof(struct wm_window));
XColor bg_color;
bg_color.red = 0 * 256;
bg_color.green = 100 * 256;
bg_color.blue = 150 * 256;
XAllocColor(wm.display, DefaultColormap(wm.display, wm.screen), &bg_color);
parent_win->win = XCreateSimpleWindow(wm.display, DefaultRootWindow(wm.display), 0, 0, 600, 600, 0, bg_color.pixel, bg_color.pixel);
wm_window_resize(&wm, child, 590, 570);
int w, h;
w = 100 + rand()%screen_width - (child->width + 20);
h = 100 + rand()%screen_height - (child->height + 20);
w = w >= 0 ? w : 0;
h = h >= 0 ? h : 0;
printf("::: %d %d\n", w, h);
wm_window_move(&wm, parent_win, w, h);
wm_window_show(&wm, parent_win);
gc = XCreateGC(wm.display, parent_win->win, None, &values);
XSetLineAttributes(wm.display, gc, 2, LineSolid, CapButt, JoinRound);
XDrawString(wm.display, parent_win->win, gc, 20, 20, child->title, strlen(child->title));
Pixmap exit_icon, mask;
XpmAttributes xpm_attr;
XpmCreatePixmapFromData(wm.display, parent_win->win, exit_icon_xpm, &exit_icon, &mask, &xpm_attr);
GC gc2;
XGCValues values2;
gc2 = XCreateGC(wm.display, parent_win->win, None, &values2);
XSetClipMask(wm.display, gc2, mask);
// XcopyArea() server-side should be faster than XPutImage() client-side
XSetClipOrigin(wm.display, gc2, 600-xpm_attr.width, 0);
XCopyArea(wm.display, exit_icon, parent_win->win, gc2, 0, 0, xpm_attr.width, xpm_attr.height, 600-xpm_attr.width, 0);
return parent_win;
}
void init_X(){
/* open connection with the server */
X.display = XOpenDisplay(NULL);
if(X.display == NULL) {
printf("cannot open display\n");
exit(EXIT_FAILURE);
}
X.screen = DefaultScreen(X.display);
/* set window size */
int width = point_num_x;
int height = point_num_y;
/* set window position */
int x = 0;
int y = 0;
/* border width in pixels */
int border_width = 0;
/* create window */
X.window = XCreateSimpleWindow(X.display, RootWindow(X.display, X.screen), x, y, width, height, border_width,
BlackPixel(X.display, X.screen), WhitePixel(X.display, X.screen));
/* create graph */
XGCValues values;
long valuemask = 0;
X.gc = XCreateGC(X.display, X.window, valuemask, &values);
XSetForeground(X.display, X.gc, BlackPixel (X.display, X.screen));
XSetBackground(X.display, X.gc, 0X0000FF00);
XSetLineAttributes(X.display, X.gc, 1, LineSolid, CapRound, JoinRound);
/* map(show) the window */
XMapWindow(X.display, X.window);
XSync(X.display, 0);
}
void PlotArea::plot_linetype(const char *buf)
{
int assignments = sscanf(buf, "L%4d", &line_type);
if (assignments != 1)
{
plot_unknown(buf);
return;
}
line_type = (line_type % 8) + 2;
width = widths[line_type];
if (dashes[line_type][0])
{
type = LineOnOffDash;
XSetDashes(dpy, gc, 0, dashes[line_type], strlen(dashes[line_type]));
}
else
{
type = LineSolid;
}
XSetForeground(dpy, gc, colors[line_type + 3]);
XSetLineAttributes(dpy, gc, width, type, CapButt, JoinBevel);
}
/************************************************************************
* *
* Draw a multi connected lines to form a polygon. *
* It is called when a polygon is completed. *
* */
void
Polygon::draw(void)
{
int i;
if ((pnt == NULL) || (pnt[0].x == G_INIT_POS))
return;
set_clip_region(FRAME_CLIP_TO_IMAGE);
if (visibility != VISIBLE_NEVER && visible != FALSE){
XPoint *point = new XPoint[npnts+1];
for (i=0; i<npnts; i++){
point[i].x = pnt[i].x;
point[i].y = pnt[i].y;
}
int npoints;
if (closed){
npoints = npnts + 1;
point[npnts].x = pnt[0].x;
point[npnts].y = pnt[0].y;
}else{
npoints = npnts;
}
G_Set_Color(gdev, color);
XSetLineAttributes(gdev->xdpy, gdev->xgc,
0, LineSolid, CapButt, JoinBevel);
XDrawLines(gdev->xdpy, gdev->xid, gdev->xgc, point, npoints,
CoordModeOrigin);
delete[] point;
}
roi_set_state(ROI_STATE_EXIST);
if (roi_state(ROI_STATE_MARK)){
mark();
}
set_clip_region(FRAME_NO_CLIP);
}
void
p_pen(p_win *w, int width, int type)
{
p_scr *s = w->s;
GC gc = s->gc;
int disjoint = (type & P_SQUARE);
int same_type = (s->gc_type == type);
if (width<2) width = 0;
else if (width>100) width = 100;
if (s->gc_width==width && same_type) return;
type ^= disjoint;
if (type>4 || type<0) type = 0;
XSetLineAttributes(s->xdpy->dpy, gc, width,
type? LineOnOffDash : LineSolid,
disjoint? CapProjecting : CapRound,
disjoint? JoinMiter : JoinRound);
if (!same_type) s->gc_type = (type | disjoint);
s->gc_width = width;
if (type) {
/* dash pattern depends on linestyle */
int n = x_ndash[type];
if (width<2) {
XSetDashes(s->xdpy->dpy, gc, 0, x_dash[type], n);
} else {
/* dash pattern must scale with line thickness */
int i;
char dash[6];
for (i=0 ; i<n ; i++)
dash[i] = x_dash[type][i]>1? width*x_dash[type][i] : 1;
XSetDashes(s->xdpy->dpy, gc, 0, dash, n);
}
}
}
GC
create_gc(Display* display, Window win, int reverse_video)
{
GC gc; /* handle of newly created GC. */
unsigned long valuemask = 0; /* which values in 'values' to */
/* check when creating the GC. */
XGCValues values; /* initial values for the GC. */
unsigned int line_width = 2; /* line width for the GC. */
int line_style = LineSolid; /* style for lines drawing and */
int cap_style = CapButt; /* style of the line's edje and */
int join_style = JoinBevel; /* joined lines. */
int screen_num = DefaultScreen(display);
gc = XCreateGC(display, win, valuemask, &values);
if (gc < 0) {
fprintf(stderr, "XCreateGC: \n");
}
/* allocate foreground and background colors for this GC. */
if (reverse_video) {
XSetForeground(display, gc, WhitePixel(display, screen_num));
XSetBackground(display, gc, BlackPixel(display, screen_num));
}
else {
XSetForeground(display, gc, BlackPixel(display, screen_num));
XSetBackground(display, gc, WhitePixel(display, screen_num));
}
/* define the style of lines that will be drawn using this GC. */
XSetLineAttributes(display, gc,
line_width, line_style, cap_style, join_style);
/* define the fill style for the GC. to be 'solid filling'. */
XSetFillStyle(display, gc, FillSolid);
return gc;
}
/*
* Vytvoøení grafického kontextu
*/
static void getGC(Window win, GC *gc, XFontStruct *font_info)
{
unsigned long valuemask = 0; /* Ignorovat XGCValues a pou¾ít default */
XGCValues values; /* Nastavení grafického kontextu */
/* Atributy pro kreslení èar (daly by se nastavit i pøi XCreateGC) */
unsigned int line_width = 6;
int line_style = LineOnOffDash;
int cap_style = CapRound;
int join_style = JoinRound;
int dash_offset = 0;
static char dash_list[] = {12, 24};
int list_length = 2;
/* Vytvoøit defaultní graphics context */
*gc = XCreateGC(display, win, valuemask, &values);
/* Nastavit font pro kreslení textu */
XSetFont(display, *gc, font_info->fid);
/* Nastavit foreground na èernou, proto¾e default background je bílý */
XSetForeground(display, *gc, BlackPixel(display, screen_num));
/* Nastavit parametry pro kreslení èar */
XSetLineAttributes(display, *gc, line_width, line_style, cap_style,
join_style);
XSetDashes(display, *gc, dash_offset, dash_list, list_length);
}
void creategui()
{
int x, y, w = width, h = height;
XSetWindowAttributes wa;
if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
fputs("no locale support\n", stderr);
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
initfont(font);
cursor = XCreateFontCursor(dpy, XC_left_ptr);
dc.norm[ColBG] = getcolor(normbgcolor);
dc.norm[ColFG] = getcolor(normfgcolor);
dc.sel[ColBG] = getcolor(selbgcolor);
dc.sel[ColFG] = getcolor(selfgcolor);
dc.drawable = XCreatePixmap(dpy, root, w, 2 * h, DefaultDepth(dpy, screen));
dc.gc = XCreateGC(dpy, root, 0, NULL);
XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
if (!dc.font.set)
XSetFont(dpy, dc.gc, dc.font.xfont->fid);
wa.cursor = cursor;
wa.background_pixel = dc.norm[ColBG];
XChangeWindowAttributes(dpy, root, CWBackPixel|CWCursor, &wa);
x = (DisplayWidth(dpy, screen) - w) / 2;
y = DisplayHeight(dpy, screen) / 2;
createinput(userprompt, x, y - h, w, h, innerpx, False);
createinput(passprompt, x, y, w, h, innerpx, True);
im = XOpenIM(dpy, NULL, NULL, NULL);
ic = XCreateIC(im, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, inputs->win, XNFocusWindow, inputs->win, NULL);
}
void MP_LineStyle (Scene& scene, short linestyle, short thickness)
{
char pattern[8];
unsigned thick;
// use same formula as in image.cpp
thick = 1 + (thickness-1)/2;
strcpy(pattern,
(linestyle == Dotted) ? "\2\1" :
(linestyle == Dashed) ? "\6\3" :
(linestyle == LongDashed) ? "\10\5" :
(linestyle == DotDashed) ? "\6\2\1\2" :
(linestyle == DotDotDashed) ? "\6\2\1\2\1\2" :
"\1\3");
if (linestyle != Solid)
XSetDashes(Mp.theDisplay,scene.mpwindow->DrawGC,0,pattern,strlen(pattern));
XSetLineAttributes(Mp.theDisplay,scene.mpwindow->DrawGC,
thick,
(linestyle != Solid) ? LineOnOffDash : LineSolid,
CapButt,
JoinBevel);
}
void paint_border(GUI* g,Window win, WIDGET* w)
{
struct border_data_t* data=w->widget_data;
if((w->status&STATUS_VISIBLE)==0){
XSetForeground(g->dsp,g->draw,g->bgColor);
XSetLineAttributes(g->dsp,g->draw,data->thickness,LineSolid,CapButt,JoinMiter);
XDrawRectangle(g->dsp,win,g->draw,w->x,w->y,w->width,w->height);
XSetLineAttributes(g->dsp,g->draw,1,LineSolid,CapButt,JoinMiter);
}
else{
if(data->color>-1){
XSetForeground(g->dsp,g->draw,data->color);
XSetLineAttributes(g->dsp,g->draw,data->thickness,LineSolid,CapButt,JoinMiter);
XDrawRectangle(g->dsp,win,g->draw,w->x,w->y,w->width,w->height);
XSetLineAttributes(g->dsp,g->draw,1,LineSolid,CapButt,JoinMiter);
}
else {
XSetForeground(g->dsp,g->draw,g->blackColor);
XSetLineAttributes(g->dsp,g->draw,data->thickness,LineSolid,CapButt,JoinMiter);
XDrawRectangle(g->dsp,win,g->draw,w->x,w->y,w->width,w->height);
XSetLineAttributes(g->dsp,g->draw,1,LineSolid,CapButt,JoinMiter);
}
}
}
static void LoopLasers(struct state *st, int xlim, int ylim)
{
int i, j, miny = ylim * 0.8;
int x, y;
for (i = 0; i < kMaxLasers; i++) {
Laser *m = &st->laser[i];
if (!m->alive)
continue;
if (m->oldx != -1) {
XSetLineAttributes(st->dpy, st->erase_gc, 2, 0,0,0);
XDrawLine(st->dpy, st->window, st->erase_gc,
m->oldx2, m->oldy2, m->oldx, m->oldy);
}
m->fposx += m->velx;
m->fposy += m->vely;
m->x = m->fposx;
m->y = m->fposy;
x = m->fposx + (-m->velx * m->lenMul);
y = m->fposy + (-m->vely * m->lenMul);
m->oldx = x;
m->oldy = y;
XSetLineAttributes(st->dpy, st->draw_gc, 2, 0,0,0);
XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
XDrawLine(st->dpy, st->window, st->draw_gc,
m->x, m->y, x, y);
m->oldx2 = m->x;
m->oldy2 = m->y;
m->oldx = x;
m->oldy = y;
if (m->y < m->endy) {
m->alive = 0;
}
/* check hitting explosions */
if (m->y < miny)
for (j=0;j<kMaxBooms;j++) {
Boom *b = &st->boom[j];
if (!b->alive)
continue;
else {
int dx = abs(m->x - b->x);
int dy = abs(m->y - b->y);
int r = b->rad + 2;
if (b->oflaser)
continue;
if ((dx < r) && (dy < r))
if (dx * dx + dy * dy < r * r) {
m->alive = 0;
/* one less enemy on this missile -- it probably didn't make it */
if (st->missile[m->target].alive)
st->missile[m->target].enemies--;
}
}
}
if (m->alive == 0) {
/* we just died */
XDrawLine(st->dpy, st->window, st->erase_gc,
m->x, m->y, x, y);
Explode(st, m->x, m->y, kBoomRad, m->color, 1);
}
}
}
static void LoopMissiles(struct state *st, int xlim, int ylim)
{
int i, j, max = 0;
for (i = 0; i < kMaxMissiles; i++) {
int old_x, old_y;
Missile *m = &st->missile[i];
if (!m->alive)
continue;
old_x = m->x;
old_y = m->y;
m->pos += kMissileSpeed;
m->x = m->startx + ((float) (m->endx - m->startx)) * m->pos;
m->y = m->starty + ((float) (m->endy - m->starty)) * m->pos;
/* erase old one */
XSetLineAttributes(st->dpy, st->draw_gc, 4, 0,0,0);
XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
XDrawLine(st->dpy, st->window, st->draw_gc,
old_x, old_y, m->x, m->y);
/* maybe split off a new missile? */
if (m->splits && (m->y > m->splits)) {
m->splits = 0;
launch(st, xlim, ylim, i);
}
if (m->y >= ylim) {
m->alive = 0;
if (st->city[m->dcity].alive) {
st->city[m->dcity].alive = 0;
Explode(st, m->x, m->y, kBoomRad * 2, m->color, 0);
}
}
/* check hitting explosions */
for (j=0;j<kMaxBooms;j++) {
Boom *b = &st->boom[j];
if (!b->alive)
continue;
else {
int dx = abs(m->x - b->x);
int dy = abs(m->y - b->y);
int r = b->rad + 2;
if ((dx < r) && (dy < r))
if (dx * dx + dy * dy < r * r) {
m->alive = 0;
max = b->max + st->bgrowth - kBoomRad;
AddScore(st, xlim, ylim, SCORE_MISSILE);
}
}
}
if (m->alive == 0) {
float my_pos;
/* we just died */
Explode(st, m->x, m->y, kBoomRad + max, m->color, 0);
XSetLineAttributes(st->dpy, st->erase_gc, 4, 0,0,0);
/* In a perfect world, we could simply erase a line from
(m->startx, m->starty) to (m->x, m->y). This is not a
perfect world. */
old_x = m->startx;
old_y = m->starty;
my_pos = kMissileSpeed;
while (my_pos <= m->pos) {
m->x = m->startx + ((float) (m->endx - m->startx)) * my_pos;
m->y = m->starty + ((float) (m->endy - m->starty)) * my_pos;
XDrawLine(st->dpy, st->window, st->erase_gc, old_x, old_y, m->x, m->y);
old_x = m->x;
old_y = m->y;
my_pos += kMissileSpeed;
}
}
}
}
void InitItemDraw(struct XObj *xobj)
{
unsigned long mask;
XSetWindowAttributes Attr;
int minHeight,minWidth;
int asc,desc,dir;
XCharStruct struc;
#ifdef I18N_MB
char **ml;
XFontStruct **fs_list;
#endif
/* Enregistrement des couleurs et de la police */
if (xobj->colorset >= 0) {
xobj->TabColor[fore] = Colorset[xobj->colorset].fg;
xobj->TabColor[back] = Colorset[xobj->colorset].bg;
xobj->TabColor[hili] = Colorset[xobj->colorset].hilite;
xobj->TabColor[shad] = Colorset[xobj->colorset].shadow;
} else {
xobj->TabColor[fore] = GetColor(xobj->forecolor);
xobj->TabColor[back] = GetColor(xobj->backcolor);
xobj->TabColor[hili] = GetColor(xobj->hilicolor);
xobj->TabColor[shad] = GetColor(xobj->shadcolor);
}
Attr.background_pixel = xobj->TabColor[back];
mask = CWBackPixel;
xobj->win = XCreateWindow(dpy, *xobj->ParentWin,
xobj->x, xobj->y, xobj->width, xobj->height, 0,
CopyFromParent, InputOutput, CopyFromParent,
mask, &Attr);
xobj->gc = fvwmlib_XCreateGC(dpy, xobj->win, 0, NULL);
XSetForeground(dpy, xobj->gc, xobj->TabColor[fore]);
#ifdef I18N_MB
if ((xobj->xfontset = GetFontSetOrFixed(dpy,xobj->font)) == NULL) {
fprintf(stderr, "FvwmScript: Couldn't load font. Exiting!\n");
exit(1);
}
XFontsOfFontSet(xobj->xfontset, &fs_list, &ml);
xobj->xfont = fs_list[0];
#else
if ((xobj->xfont = GetFontOrFixed(dpy, xobj->font)) == NULL) {
fprintf(stderr, "FvwmScript: Couldn't load font. Exiting!\n");
exit(1);
}
#endif
XSetFont(dpy, xobj->gc, xobj->xfont->fid);
XSetLineAttributes(dpy, xobj->gc, 1, LineSolid, CapRound, JoinMiter);
/* Redimensionnement du widget */
if (strlen(xobj->title) != 0)
XTextExtents(xobj->xfont, "lp", strlen("lp"), &dir, &asc, &desc, &struc);
else {
asc = 0;
desc = 0;
}
if (xobj->icon == NULL)
{
if (strlen(xobj->title) != 0)
{
/* title but no icon */
minHeight = asc+desc+2;
minWidth = XTextWidth(xobj->xfont, xobj->title, strlen(xobj->title))+2;
if (xobj->height < minHeight)
xobj->height = minHeight;
if (xobj->width < minWidth)
xobj->width = minWidth;
}
}
else if (strlen(xobj->title)==0)
{
/* icon but no title */
if (xobj->height<xobj->icon_h)
xobj->height = xobj->icon_h;
if (xobj->width<xobj->icon_w)
xobj->width = xobj->icon_w;
}
else
{
/* title and icon */
if (xobj->icon_w>XTextWidth(xobj->xfont, xobj->title, strlen(xobj->title))+2)
{
/* icon is wider than the title */
if (xobj->width<xobj->icon_w)
xobj->width = xobj->icon_w;
}
else
{
/* title is wider than icon */
if (xobj->width <
XTextWidth(xobj->xfont, xobj->title, strlen(xobj->title)) + 2)
xobj->width =
XTextWidth(xobj->xfont, xobj->title, strlen(xobj->title))+2;
}
xobj->height = xobj->icon_h+asc+desc+2;
}
XResizeWindow(dpy, xobj->win, xobj->width, xobj->height);
if (xobj->colorset >= 0)
SetWindowBackground(dpy, xobj->win, xobj->width, xobj->height,
&Colorset[xobj->colorset], Pdepth,
xobj->gc, True);
XSelectInput(dpy, xobj->win, ExposureMask);
/* x and y value of a clic */
xobj->value2 = -1;
xobj->value3 = -1;
}
Display * x11setup(Window *win, GC *gc, int width, int height)
{
/* --------------------------- X11 graphics setup ------------------------------ */
Display *display;
unsigned int win_x,win_y, /* window position */
border_width, /* border width in pixels */
display_width, display_height, /* size of screen */
screen; /* which screen */
char window_name[] = "N-Body Simulation", *display_name = NULL;
unsigned long valuemask = 0;
XGCValues values;
XSizeHints size_hints;
//Pixmap bitmap;
//XPoint points[800];
FILE *fopen ();//, *fp;
//char str[100];
XSetWindowAttributes attr[1];
if ( (display = XOpenDisplay (display_name)) == NULL ) { /* connect to Xserver */
fprintf (stderr, "Cannot connect to X server %s\n",XDisplayName (display_name) );
exit (-1);
}
screen = DefaultScreen (display); /* get screen size */
display_width = DisplayWidth (display, screen);
display_height = DisplayHeight (display, screen);
win_x = 0; win_y = 0; /* set window position */
border_width = 4; /* create opaque window */
*win = XCreateSimpleWindow (display, RootWindow (display, screen),
win_x, win_y, width, height, border_width,
WhitePixel (display, screen), BlackPixel (display, screen));
size_hints.flags = USPosition|USSize;
size_hints.x = win_x;
size_hints.y = win_y;
size_hints.width = width;
size_hints.height = height;
size_hints.min_width = 300;
size_hints.min_height = 300;
XSetNormalHints (display, *win, &size_hints);
XStoreName(display, *win, window_name);
*gc = XCreateGC (display, *win, valuemask, &values); /* create graphics context */
XSetBackground (display, *gc, BlackPixel (display, screen));
XSetForeground (display, *gc, WhitePixel (display, screen));
XSetLineAttributes (display, *gc, 1, LineSolid, CapRound, JoinRound);
attr[0].backing_store = Always;
attr[0].backing_planes = 1;
attr[0].backing_pixel = BlackPixel(display, screen);
XChangeWindowAttributes(display, *win, CWBackingStore | CWBackingPlanes | CWBackingPixel, attr);
XSelectInput(display, *win, KeyPressMask);
XMapWindow (display, *win);
XSync(display, 0);
/* --------------------------- End of X11 graphics setup ------------------------------ */
return display;
}
ENTRYPOINT void
init_flow (ModeInfo * mi)
{
flowstruct *sp;
char *name;
if (flows == NULL) {
if ((flows = (flowstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (flowstruct))) == NULL)
return;
}
sp = &flows[MI_SCREEN(mi)];
sp->count2 = 0;
sp->taillen = MI_SIZE(mi);
if (sp->taillen < -MINTRAIL) {
/* Change by sqrt so it seems more variable */
sp->taillen = NRAND((int)sqrt((double) (-sp->taillen - MINTRAIL + 1)));
sp->taillen = sp->taillen * sp->taillen + MINTRAIL;
} else if (sp->taillen < MINTRAIL) {
sp->taillen = MINTRAIL;
}
if(!rotatep && !ridep) rotatep = True; /* We need at least one viewpoint */
/* Start camera at Orbit or Bee */
if(rotatep) {
sp->chaseto = ORBIT;
} else {
sp->chaseto = BEE;
}
sp->chasetime = 1; /* Go directly to target */
sp->lyap = 0;
sp->yperiod = 0;
sp->step2 = INITIALSTEP;
/* Zero parameter set */
memset(sp->par2, 0, N_PARS * sizeof(dvector));
/* Set up standard examples */
switch (NRAND((periodicp) ? 5 : 3)) {
case 0:
/*
x' = a(y - x)
y' = x(b - z) - y
z' = xy - cz
*/
name = "Lorentz";
sp->par2[Y].x = 10 + balance_rand(5*0); /* a */
sp->par2[X].x = - sp->par2[Y].x; /* -a */
sp->par2[X].y = 28 + balance_rand(5*0); /* b */
sp->par2[XZ].y = -1;
sp->par2[Y].y = -1;
sp->par2[XY].z = 1;
sp->par2[Z].z = - 2 + balance_rand(1*0); /* -c */
break;
case 1:
/*
x' = -(y + az)
y' = x + by
z' = c + z(x - 5.7)
*/
name = "Rossler";
sp->par2[Y].x = -1;
sp->par2[Z].x = -2 + balance_rand(1); /* a */
sp->par2[X].y = 1;
sp->par2[Y].y = 0.2 + balance_rand(0.1); /* b */
sp->par2[C].z = 0.2 + balance_rand(0.1); /* c */
sp->par2[XZ].z = 1;
sp->par2[Z].z = -5.7;
break;
case 2:
/*
x' = -(y + az)
y' = x + by - cz^2
z' = 0.2 + z(x - 5.7)
*/
name = "RosslerCone";
sp->par2[Y].x = -1;
sp->par2[Z].x = -2; /* a */
sp->par2[X].y = 1;
sp->par2[Y].y = 0.2; /* b */
sp->par2[ZZ].y = -0.331 + balance_rand(0.01); /* c */
sp->par2[C].z = 0.2;
sp->par2[XZ].z = 1;
sp->par2[Z].z = -5.7;
break;
case 3:
/*
x' = -z + b sin(y)
y' = c
z' = 0.7x + az(0.1 - x^2)
*/
name = "Birkhoff";
sp->par2[Z].x = -1;
sp->par2[SINY].x = 0.35 + balance_rand(0.25); /* b */
sp->par2[C].y = 1.57; /* c */
sp->par2[X].z = 0.7;
sp->par2[Z].z = 1 + balance_rand(0.5); /* a/10 */
sp->par2[XXZ].z = -10 * sp->par2[Z].z; /* -a */
sp->yperiod = 2 * M_PI;
break;
default:
/*
x' = -ax - z/2 - z^3/8 + b sin(y)
y' = c
z' = 2x
*/
name = "Duffing";
sp->par2[X].x = -0.2 + balance_rand(0.1); /* a */
sp->par2[Z].x = -0.5;
sp->par2[ZZZ].x = -0.125;
sp->par2[SINY].x = 27.0 + balance_rand(3.0); /* b */
sp->par2[C].y = 1.33; /* c */
sp->par2[X].z = 2;
sp->yperiod = 2 * M_PI;
break;
}
sp->range.x = 5;
sp->range.z = 5;
if(sp->yperiod > 0) {
sp->ODE = Periodic;
/* periodic flows show either uniform distribution or a
snapshot on the 'time' axis */
sp->range.y = NRAND(2)? sp->yperiod : 0;
} else {
sp->range.y = 5;
sp->ODE = Cubic;
}
/* Run discoverer to set up bounding box, etc. Lyapunov will
probably be innaccurate, since we're only running it once, but
we're using known strange attractors so it should be ok. */
discover(mi);
if(MI_IS_VERBOSE(mi))
fprintf(stdout,
"flow: Lyapunov exponent: %g, step: %g, size: %g (%s)\n",
sp->lyap2, sp->step2, sp->size2, name);
/* Install new params */
sp->lyap = sp->lyap2;
sp->size = sp->size2;
sp->mid = sp->mid2;
sp->step = sp->step2;
memcpy(sp->par, sp->par2, sizeof(sp->par2));
sp->count2 = 0; /* Reset search */
free_flow(sp);
sp->beecount = MI_COUNT(mi);
if (sp->beecount < 0) { /* random variations */
sp->beecount = NRAND(-sp->beecount) + 1; /* Minimum 1 */
}
# ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
dbufp = False;
# endif
if(dbufp) { /* Set up double buffer */
if (sp->buffer != None)
XFreePixmap(MI_DISPLAY(mi), sp->buffer);
sp->buffer = XCreatePixmap(MI_DISPLAY(mi), MI_WINDOW(mi),
MI_WIDTH(mi), MI_HEIGHT(mi), MI_DEPTH(mi));
} else {
sp->buffer = MI_WINDOW(mi);
}
/* no "NoExpose" events from XCopyArea wanted */
XSetGraphicsExposures(MI_DISPLAY(mi), MI_GC(mi), False);
/* Make sure we're using 'thin' lines */
XSetLineAttributes(MI_DISPLAY(mi), MI_GC(mi), 0, LineSolid, CapNotLast,
JoinMiter);
/* Clear the background (may be slow depending on user prefs). */
MI_CLEARWINDOW(mi);
/* Allocate memory. */
if (sp->csegs == NULL) {
allocate(sp->csegs, XSegment,
(sp->beecount + BOX_L) * MI_NPIXELS(mi) * sp->taillen);
allocate(sp->cnsegs, int, MI_NPIXELS(mi));
allocate(sp->old_segs, XSegment, sp->beecount * sp->taillen);
allocate(sp->p, dvector, sp->beecount * sp->taillen);
}
void InitPopupMenu(struct XObj *xobj)
{
unsigned long mask;
XSetWindowAttributes Attr;
int i;
char *str;
/* Enregistrement des couleurs et de la police / set the colors and the font
*/
if (xobj->colorset >= 0) {
xobj->TabColor[fore] = Colorset[xobj->colorset].fg;
xobj->TabColor[back] = Colorset[xobj->colorset].bg;
xobj->TabColor[hili] = Colorset[xobj->colorset].hilite;
xobj->TabColor[shad] = Colorset[xobj->colorset].shadow;
} else {
xobj->TabColor[fore] = GetColor(xobj->forecolor);
xobj->TabColor[back] = GetColor(xobj->backcolor);
xobj->TabColor[hili] = GetColor(xobj->hilicolor);
xobj->TabColor[shad] = GetColor(xobj->shadcolor);
}
mask = 0;
Attr.background_pixel = xobj->TabColor[back];
mask |= CWBackPixel;
Attr.cursor = XCreateFontCursor(dpy, XC_hand2);
mask |= CWCursor; /* Curseur pour la fenetre / window cursor */
xobj->win = XCreateWindow(dpy, *xobj->ParentWin,
xobj->x, xobj->y, xobj->width, xobj->height, 0,
CopyFromParent, InputOutput, CopyFromParent,
mask, &Attr);
xobj->gc = fvwmlib_XCreateGC(dpy, xobj->win, 0, NULL);
XSetForeground(dpy, xobj->gc, xobj->TabColor[fore]);
if ((xobj->Ffont = FlocaleLoadFont(dpy, xobj->font, ScriptName)) == NULL)
{
fprintf(stderr, "%s: Couldn't load font. Exiting!\n", ScriptName);
exit(1);
}
if (xobj->Ffont->font != NULL)
XSetFont(dpy, xobj->gc, xobj->Ffont->font->fid);
XSetLineAttributes(dpy, xobj->gc, 1, LineSolid, CapRound, JoinMiter);
xobj->value3 = CountOption(xobj->title);
if (xobj->value > xobj->value3)
xobj->value = xobj->value3;
if (xobj->value < 1)
xobj->value = 1;
/* Redimensionnement du widget / Widget resizing */
xobj->height = xobj->Ffont->height +12;
xobj->width = 30;
for (i = 1; i <= xobj->value3; i++)
{
str = (char*)GetMenuTitle(xobj->title, i);
if (xobj->width < FlocaleTextWidth(xobj->Ffont, str, strlen(str))+34)
xobj->width = FlocaleTextWidth(xobj->Ffont, str, strlen(str))+34;
free(str);
}
XResizeWindow(dpy, xobj->win, xobj->width, xobj->height);
if (xobj->colorset >= 0)
SetWindowBackground(dpy, xobj->win, xobj->width, xobj->height,
&Colorset[xobj->colorset], Pdepth,
xobj->gc, True);
XSelectInput(dpy, xobj->win, ExposureMask);
}
int main(void)
{
Display *display;
Window window; //initialization for a window
int screen; //which screen
/* open connection with the server */
display = XOpenDisplay(NULL);
if(display == NULL) {
fprintf(stderr, "cannot open display\n");
return 0;
}
screen = DefaultScreen(display);
/* set window size */
int width = 400;
int height = 400;
/* set window position */
int x = 0;
int y = 0;
/* border width in pixels */
int border_width = 0;
/* create window */
window = XCreateSimpleWindow(display, RootWindow(display, screen), x, y, width, height, border_width,
BlackPixel(display, screen), WhitePixel(display, screen));
/* create graph */
GC gc;
XGCValues values;
long valuemask = 0;
gc = XCreateGC(display, window, valuemask, &values);
//XSetBackground (display, gc, WhitePixel (display, screen));
XSetForeground (display, gc, BlackPixel (display, screen));
XSetBackground(display, gc, 0X0000FF00);
XSetLineAttributes (display, gc, 1, LineSolid, CapRound, JoinRound);
/* map(show) the window */
XMapWindow(display, window);
XSync(display, 0);
int* repeatsBuffer;
repeatsBuffer = (int*)malloc(sizeof(int) * width * height);
const int threadNum = 50;
pthread_t threads[threadNum];
WorkPara* paras[threadNum];
WorkPara* para;
int numPerThread;
int i;
struct timespec timeStart, timeEnd;
clock_gettime(CLOCK_REALTIME, &timeStart);
numPerThread = width % threadNum == 0 ? width / threadNum : width / threadNum + 1;
for(i=0;i<threadNum;i++){
para = paras[i] = (WorkPara*)malloc(sizeof(WorkPara));
para -> repeatsBuffer = repeatsBuffer;
para -> width = width;
para -> height = height;
para -> start = numPerThread * i;
para -> end = para -> start + numPerThread;
if(para -> end > width){
para -> end = width;
}
para -> tid = i;
pthread_create(&threads[i], NULL, doWork, (void*)para);
}
for(i = 0; i < threadNum ; i++){
pthread_join(threads[i],NULL);
}
clock_gettime(CLOCK_REALTIME, &timeEnd);
printf("Time Usage: %lf s\n", (double)(timeEnd.tv_sec - timeStart.tv_sec) + (double)(timeEnd.tv_nsec - timeStart.tv_nsec)/1e9);
fflush(stdout);
for(i = 0; i < width * height; i++){
XSetForeground (display, gc, 1024 * 1024 * (repeatsBuffer[i] % 256));
//printf("%d\n",repeatsBuffer[i]);
XDrawPoint (display, window, gc, i/width, i%width);
}
XFlush(display);
for(i = 0; i < threadNum ; i++){
free(paras[i]);
}
free(repeatsBuffer);
sleep(5);
return 0;
}
int main(int argc, char **argv)
{
threads = atoi(argv[1]);
atof(minX, 2);
atof(maxX, 3);
atof(minY, 4);
atof(maxY, 5);
width = atoi(argv[6]);
height = atoi(argv[7]);
std::string in = argv[8];
if (in == "enable")
isEnable = true;
else
isEnable = false;
/********* MPI MISSION START *********/
int rank, size;
MPI_Init(&argc, &argv);
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
MPI_Comm_size (MPI_COMM_WORLD, &size);
MPI_Status status;
Display *display;
Window window; //initialization for a window
int screen; //which screen
/* set window position */
int x = 0;
int y = 0;
/* create graph */
GC gc;
XGCValues values;
long valuemask = 0;
/* border width in pixels */
int border_width = 0;
/* open connection with the server */
/* draw points */
int numPerTask = width / (size);
if (rank == size - 1)
numPerTask += width % (size);
if (isEnable && rank == 0) {
display = XOpenDisplay(NULL);
if(display == NULL) {
fprintf(stderr, "cannot open display\n");
return 0;
}
screen = DefaultScreen(display);
/* set window size */
/* create window */
window = XCreateSimpleWindow(display,
RootWindow(display, screen), x, y,
width, height, border_width,
BlackPixel(display, screen),
WhitePixel(display, screen));
gc = XCreateGC(display, window, valuemask, &values);
//XSetBackground (display, gc, WhitePixel (display, screen));
XSetForeground (display, gc, BlackPixel (display, screen));
XSetBackground(display, gc, 0X0000FF00);
XSetLineAttributes (display, gc, 1, LineSolid, CapRound, JoinRound);
/* map(show) the window */
XMapWindow(display, window);
XSync(display, 0);
if (isEnable)
XFlush(display);
}
Pixel *pixel = new Pixel[numPerTask * height];
int curIndex = 0;
int beginPos = rank != size - 1 ?
numPerTask * (rank) : (rank) * (numPerTask - (width % (size)));
printf("rank %d -> begin = %d, numTasks = %d\n", rank, beginPos, numPerTask);
int ansK = -1;
for(int i = beginPos, k = 0; k < numPerTask; i++, k++) {
ansK = ansK > i ? ansK : i;
for(int j=0; j<height; j++) {
// printf("rank %d : (%d, %d)\n", rank, i, j);
Compl z, c;
double temp, lengthsq;
int repeats;
z.real = 0.0;
z.imag = 0.0;
double scaleX = width / (maxX - minX);
double scaleY = height / (maxY - minY);
c.real = ((double)i + scaleX * minX) / scaleX;
/* Theorem : If c belongs to M(Mandelbrot set), then |c| <= 2 */
c.imag = ((double)j + scaleY * minY) / scaleY;
/* So needs to scale the window */
repeats = 0;
lengthsq = 0.0;
while(repeats < 10000 && lengthsq < 4.0) {
/* Theorem : If c belongs to M, then |Zn| <= 2. So Zn^2 <= 4 */
temp = z.real*z.real - z.imag*z.imag + c.real;
z.imag = 2*z.real*z.imag + c.imag;
z.real = temp;
lengthsq = z.real*z.real + z.imag*z.imag;
repeats++;
}
if (!isEnable) continue;
pixel[curIndex++] = Pixel(i, j, repeats);
}
}
printf("Rank[%d] ansK = %d\n", rank, ansK);
if (rank != 0) {
send(&curIndex, 1, MPI_INT, ROOT);
// printf("rank %d send curIndex %d ...\n", rank, curIndex);
// sleep(5);
send(pixel, curIndex * sizeof(Pixel), MPI_CHAR, ROOT);
// printf("rank %d send pixel...\n", rank);
}
else if (isEnable) {
for (int index = 0; index < curIndex; ++index) {
XSetForeground (display, gc,
1024 * 1024 * (pixel[index].repeats % 256));
XDrawPoint (display, window, gc, pixel[index].i, pixel[index].j);
}
std::vector <Pixel> drawGraph;
for (int threads = 1; threads < size; ++threads) {
int pixelNum;
recv(&pixelNum, sizeof(int), MPI_INT, threads);
// printf("recv pixelNum = %d\n", pixelNum);
Pixel *pixel = new Pixel[pixelNum];
recv(pixel, pixelNum * sizeof(Pixel), MPI_CHAR, threads);
for (int i = 0; i < pixelNum; ++i)
drawGraph.push_back(pixel[i]);
delete [] pixel;
}
int drawTimes = 2;
while (drawTimes--) {
for (int k = 0; k < drawGraph.size(); ++k) {
int i = drawGraph[k].i;
int j = drawGraph[k].j;
int repeats = drawGraph[k].repeats;
XSetForeground (display, gc,
1024 * 1024 * (repeats % 256));
XDrawPoint (display, window, gc, i, j);
}
}
}
delete [] pixel;
MPI_Finalize();
if (isEnable) sleep(5);
return 0;
}
void
draw_stress(void) {
int i, j, npoints, start, end;
/*float width = (float) (str_width) - 2. * (float) STR_HMARGIN;*/
/*float maxwidth = (float) MAXSTRVALUES;*/
float height = (float) (str_height) - 2. * (float) STR_VMARGIN;
float x, y;
static Boolean initd = False;
XPoint axes[3];
char str[32];
static int strwidth;
XPoint strPts[MAXSTRVALUES];
if (!initd) {
str_window = XtWindow(str_wksp);
make_str_pixmap();
sprintf(str, ".9999");
strwidth = XTextWidth(appdata.plotFont, str, strlen(str));
initd = True;
}
/*
* The starting point should be zero until npoints has
* been surpassed; after that, it should be nstrValues
* minus npoints. Define the indices for strPts.
*/
/* plotting one point per pixel ... */
npoints = MIN(str_width - 2*STR_HMARGIN, nstrValues);
start = MAX(0, nstrValues - npoints);
end = nstrValues;
for (i=start, j=0; i<end; i++, j++) {
x = (float) j ;
strPts[j].x = (int) (x + STR_HMARGIN);
y = (float) (1 - strValues[i]) * height;
strPts[j].y = (int) (y + STR_VMARGIN);
}
/* axes */
axes[0].x = STR_HMARGIN;
axes[0].y = STR_VMARGIN;
axes[1].x = STR_HMARGIN;
axes[1].y = str_height - STR_VMARGIN;
axes[2].x = str_width - STR_HMARGIN;
axes[2].y = str_height - STR_VMARGIN;
/* stress as a fraction */
sprintf(str, "%2.4f", strValues[nstrValues-1]);
XSetForeground(display, copy_GC, plotcolors.fg);
clear_str_pixmap();
XDrawLines(display, str_pixmap, copy_GC,
axes, 3, CoordModeOrigin);
if (nstrValues) {
XDrawString(display, str_pixmap, copy_GC,
str_width - 2*STR_HMARGIN - strwidth,
FONTHEIGHT(appdata.plotFont),
str,
strlen(str));
XSetLineAttributes(display, copy_GC, 2, LineSolid,
CapRound, JoinBevel);
XDrawLines(display, str_pixmap, copy_GC,
strPts, npoints, CoordModeOrigin);
XSetLineAttributes(display, copy_GC, 1, LineSolid,
CapRound, JoinBevel);
}
copy_str_pixmap();
}
int main (int argc, char **argv){
int i,j;
WMColor *color;
WMWindow * win;
RImage *image;
struct _pict pict;
Drawable de;
RColor one, two={0xaf, 0x0f,0xff,0x33};
one.red=247;
one.green=251;
one.blue=107;
one.alpha=0xff;
WMInitializeApplication("DrawWin", &argc, argv);
display = XOpenDisplay("");
screen = WMCreateScreen(display, DefaultScreen(display));
win = WMCreateWindow(screen, "");
WMResizeWidget(win, WINWIDTH, WINHEIGHT);
WMSetWindowCloseAction(win, closeAction, NULL);
WMSetWindowTitle(win,"Graphics");
color = WMCreateRGBColor(screen,124<<9,206<<8,162<<8, False);
WMSetWidgetBackgroundColor((WMWidget *)win, color);
/* end setup main window */
image=RCreateImage( 100,100,0.5);
RFillImage(image, &two);
RDrawLine(image, 50,10,90,90,&one);
RDrawLine(image, 10,90,50,10,&one);
RDrawLine(image, 10,90,90,90,&one);
g3=WMColorGC(screen->gray);
XSetLineAttributes(display,g3,3,LineSolid,CapButt,JoinMiter);
pict.segments[1].x1= pict.segments[0].x1=HOFF;
pict.segments[0].x2=HOFF;
pict.segments[0].y1=VOFF;
pict.segments[1].y2= pict.segments[0].y2=VOFF;
pict.segments[1].x2= HOFF+10;
pict.segments[1].y1=VOFF+10;
pict.seglen=2;
for (i=9;i>0;i--){
j=2*(10-i);
pict.segments[j+1].x1= pict.segments[j].x1=HOFF;
pict.segments[j+1].y2= pict.segments[j].y2=VOFF;
pict.segments[j].x2= i+pict.segments[j-1].x2;
pict.segments[j].y1=i+pict.segments[j-1].y1;
pict.segments[j+1].x2= i+pict.segments[j].x2;
pict.segments[j+1].y1=i+pict.segments[j].y1;
pict.seglen+=2;
};
WMRealizeWidget(win);
pict.dwin=W_VIEW_DRAWABLE(WMWidgetView(win));
pixmap=WMCreatePixmapFromRImage(screen, image,1);
WMCreateEventHandler(WMWidgetView(win), ExposureMask,drawProcedure,&pict);
WMMapWidget(win);
WMScreenMainLoop(screen);
}
int setEpaisseurCrayon(TC *p,int e)
{
XSetLineAttributes(p->display,p->gc,e,LineSolid,CapRound,JoinRound);
return 0;
}
static bool LogoCallBack(t_x11 *x11, XEvent *event, Window /*w*/, void *data)
{
/* Assume window is 100x110 */
static bool bFirst = true;
#define CSIZE 9
#define NSIZE 8
#define OSIZE 9
#define HSIZE 7
#define YOFFS 30
static t_circle c[] = {
{ 10, YOFFS+12, CSIZE, &LIGHTGREEN },
{ 20, YOFFS+22, CSIZE, &LIGHTGREEN },
{ 20, YOFFS+34, OSIZE, &LIGHTRED },
{ 30, YOFFS+12, NSIZE, &LIGHTCYAN },
{ 30, YOFFS+ 2, HSIZE, &WHITE },
{ 40, YOFFS+22, CSIZE, &LIGHTGREEN },
{ 40, YOFFS+34, CSIZE, &LIGHTGREEN },
{ 50, YOFFS+12, CSIZE, &LIGHTGREEN },
{ 50, YOFFS, OSIZE, &LIGHTRED },
{ 60, YOFFS+22, NSIZE, &LIGHTCYAN },
{ 60, YOFFS+32, HSIZE, &WHITE },
{ 70, YOFFS+12, CSIZE, &LIGHTGREEN },
{ 80, YOFFS+22, CSIZE, &LIGHTGREEN },
{ 80, YOFFS+34, OSIZE, &LIGHTRED },
{ 90, YOFFS+12, NSIZE, &LIGHTCYAN },
{ 90, YOFFS+ 2, HSIZE, &WHITE },
{100, YOFFS+22, CSIZE, &LIGHTGREEN }
};
static int lines[] = {
0, 1, 1, 2, 1, 3, 3, 4, 3, 5, 5, 6, 5, 7, 7, 8, 7, 9,
9, 10, 9, 11, 11, 12, 12, 13, 12, 14, 14, 15, 14, 16
};
#define COFFS 70
static t_mess Mess[] = {
{ "GROMACS", 0, 20, NULL },
{ NULL, 16, 9, NULL },
{ "Copyright (c) 1991-2013", COFFS+ 2, 9, NULL },
{ "D.v.d.Spoel, E.Lindahl, B.Hess", COFFS+11, 9, NULL },
{ "& Groningen University ", COFFS+20, 9, NULL },
{ "click to dismiss", COFFS+31, 8, NULL }
};
#define NMESS asize(Mess)
int i;
real wfac, hfac;
t_logo *logo;
t_windata *wd;
logo = (t_logo *)data;
wd = &(logo->wd);
if (bFirst)
{
wfac = wd->width/110.0;
hfac = wd->height/110.0;
for (i = 0; (i < asize(c)); i++)
{
c[i].x *= wfac;
c[i].y *= hfac;
}
Mess[1].text = GromacsVersion();
for (i = 0; (i < NMESS); i++)
{
Mess[i].y *= hfac;
Mess[i].h *= hfac;
Mess[i].fnt = (i == 0) ? logo->bigfont : (i == NMESS-1) ? x11->font :
logo->smallfont;
}
bFirst = false;
}
switch (event->type)
{
case Expose:
XSetForeground(x11->disp, x11->gc, WHITE);
XSetLineAttributes(x11->disp, x11->gc, 3, LineSolid, CapNotLast, JoinRound);
for (i = 0; (i < asize(lines)); i += 2)
{
XDrawLine(x11->disp, wd->self, x11->gc,
c[lines[i]].x, c[lines[i]].y, c[lines[i+1]].x, c[lines[i+1]].y);
}
XSetLineAttributes(x11->disp, x11->gc, 1, LineSolid, CapNotLast, JoinRound);
for (i = 0; (i < asize(c)); i++)
{
XSetForeground(x11->disp, x11->gc, *(c[i].col));
XFillCircle(x11->disp, wd->self, x11->gc, c[i].x, c[i].y, c[i].rad);
}
XSetForeground(x11->disp, x11->gc, BLACK);
XDrawRectangle(x11->disp, wd->self, x11->gc, 2, 2, wd->width-5, wd->height-5);
for (i = 0; (i < NMESS); i++)
{
SpecialTextInRect(x11, Mess[i].fnt, wd->self, Mess[i].text,
0, Mess[i].y, wd->width, Mess[i].h,
eXCenter, eYCenter);
}
XSetForeground(x11->disp, x11->gc, x11->fg);
break;
case ButtonPress:
hide_logo(x11, logo);
return logo->bQuitOnClick;
break;
default:
break;
}
return false;
}
void InitCheckBox(struct XObj *xobj)
{
unsigned long mask;
XSetWindowAttributes Attr;
int asc,desc,dir;
XCharStruct struc;
#ifdef I18N_MB
char **ml;
XFontStruct **fs_list;
#endif
/* Enregistrement des couleurs et de la police / fonts and colors */
if (xobj->colorset >= 0) {
xobj->TabColor[fore] = Colorset[xobj->colorset].fg;
xobj->TabColor[back] = Colorset[xobj->colorset].bg;
xobj->TabColor[hili] = Colorset[xobj->colorset].hilite;
xobj->TabColor[shad] = Colorset[xobj->colorset].shadow;
} else {
xobj->TabColor[fore] = GetColor(xobj->forecolor);
xobj->TabColor[back] = GetColor(xobj->backcolor);
xobj->TabColor[hili] = GetColor(xobj->hilicolor);
xobj->TabColor[shad] = GetColor(xobj->shadcolor);
}
mask = 0;
Attr.background_pixel = xobj->TabColor[back];
mask |= CWBackPixel;
Attr.cursor = XCreateFontCursor(dpy,XC_hand2);
mask |= CWCursor; /* Curseur pour la fenetre / Cursor for the window */
xobj->win = XCreateWindow(dpy, *xobj->ParentWin,
xobj->x, xobj->y, xobj->width, xobj->height,0,
CopyFromParent, InputOutput, CopyFromParent,
mask, &Attr);
xobj->gc = fvwmlib_XCreateGC(dpy,xobj->win,0,NULL);
XSetForeground(dpy, xobj->gc, xobj->TabColor[fore]);
#ifdef I18N_MB
if ((xobj->xfontset = GetFontSetOrFixed(dpy,xobj->font)) == NULL) {
fprintf(stderr, "FvwmScript: Couldn't load font. Exiting!\n");
exit(1);
}
XFontsOfFontSet(xobj->xfontset,&fs_list,&ml);
xobj->xfont = fs_list[0];
#else
if ((xobj->xfont = GetFontOrFixed(dpy,xobj->font)) == NULL) {
fprintf(stderr, "FvwmScript: Couldn't load font. Exiting!\n");
exit(1);
}
#endif
XSetFont(dpy, xobj->gc, xobj->xfont->fid);
XSetLineAttributes(dpy, xobj->gc, 1, LineSolid, CapRound, JoinMiter);
/* Redimensionnement du widget / resize the widget */
XTextExtents(xobj->xfont, "lp", strlen("lp"), &dir, &asc, &desc, &struc);
xobj->height = asc+desc+5;
xobj->width = XTextWidth(xobj->xfont, xobj->title, strlen(xobj->title)) + 30;
XResizeWindow(dpy, xobj->win, xobj->width, xobj->height);
if (xobj->colorset >= 0)
SetWindowBackground(dpy, xobj->win, xobj->width, xobj->height,
&Colorset[xobj->colorset], Pdepth,
xobj->gc, True);
XSelectInput(dpy, xobj->win, ExposureMask);
}
ENTRYPOINT void
draw_braid(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int num_points = 500;
float t_inc;
float theta, psi;
float t, r_diff;
int i, s;
float x_1, y_1, x_2, y_2, r1, r2;
float color, color_use = 0.0, color_inc;
braidtype *braid;
if (braids == NULL)
return;
braid = &braids[MI_SCREEN(mi)];
#ifdef STANDALONE
if (braid->eraser) {
braid->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), braid->eraser);
return;
}
#endif
MI_IS_DRAWN(mi) = True;
XSetLineAttributes(display, MI_GC(mi), braid->linewidth,
LineSolid,
(braid->linewidth <= 3 ? CapButt : CapRound),
JoinMiter);
theta = (2.0 * M_PI) / (float) (braid->braidlength);
t_inc = (2.0 * M_PI) / (float) num_points;
color_inc = (float) MI_NPIXELS(mi) * braid->color_direction /
(float) num_points;
braid->startcolor += SPINRATE * color_inc;
if (((int) braid->startcolor) >= MI_NPIXELS(mi))
braid->startcolor = 0.0;
r_diff = (braid->max_radius - braid->min_radius) / (float) (braid->nstrands);
color = braid->startcolor;
psi = 0.0;
for (i = 0; i < braid->braidlength; i++) {
psi += theta;
for (t = 0.0; t < theta; t += t_inc) {
#ifdef COLORROUND
color += color_inc;
if (((int) color) >= MI_NPIXELS(mi))
color = 0.0;
color_use = color;
#endif
for (s = 0; s < braid->nstrands; s++) {
if (ABS(braid->braidword[i]) == s)
continue;
if (ABS(braid->braidword[i]) - 1 == s) {
/* crosSINFg */
#ifdef COLORCOMP
if (MI_NPIXELS(mi) > 2) {
color_use = color + SPINRATE *
braid->components[applywordbackto(braid, s, i)] +
(psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi);
while (((int) color_use) >= MI_NPIXELS(mi))
color_use -= (float) MI_NPIXELS(mi);
while (((int) color_use) < 0)
color_use += (float) MI_NPIXELS(mi);
}
#endif
#ifdef COLORROUND
if (MI_NPIXELS(mi) > 2) {
color_use += SPINRATE * color_inc;
while (((int) color_use) >= MI_NPIXELS(mi))
color_use -= (float) MI_NPIXELS(mi);
}
#endif
r1 = braid->min_radius + r_diff * (float) (s);
r2 = braid->min_radius + r_diff * (float) (s + 1);
if (braid->braidword[i] > 0 ||
(FABSF(t - theta / 2.0) > theta / 7.0)) {
x_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r2 +
0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r1)) *
COSF(t + psi) + braid->center_x;
y_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r2 +
0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r1)) *
SINF(t + psi) + braid->center_y;
x_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r2 +
0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r1)) *
COSF(t + t_inc + psi) + braid->center_x;
y_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r2 +
0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r1)) *
SINF(t + t_inc + psi) + braid->center_y;
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use));
else
XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
XDrawLine(display, window, MI_GC(mi),
(int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2));
}
#ifdef COLORCOMP
if (MI_NPIXELS(mi) > 2) {
color_use = color + SPINRATE *
braid->components[applywordbackto(braid, s + 1, i)] +
(psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi);
while (((int) color_use) >= MI_NPIXELS(mi))
color_use -= (float) MI_NPIXELS(mi);
while (((int) color_use) < 0)
color_use += (float) MI_NPIXELS(mi);
}
#endif
if (braid->braidword[i] < 0 ||
(FABSF(t - theta / 2.0) > theta / 7.0)) {
x_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r1 +
0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r2)) *
COSF(t + psi) + braid->center_x;
y_1 = ((0.5 * (1.0 + SINF(t / theta * M_PI - M_PI_2)) * r1 +
0.5 * (1.0 + SINF((theta - t) / theta * M_PI - M_PI_2)) * r2)) *
SINF(t + psi) + braid->center_y;
x_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r1 +
0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r2)) *
COSF(t + t_inc + psi) + braid->center_x;
y_2 = ((0.5 * (1.0 + SINF((t + t_inc) / theta * M_PI - M_PI_2)) * r1 +
0.5 * (1.0 + SINF((theta - t - t_inc) / theta * M_PI - M_PI_2)) * r2)) *
SINF(t + t_inc + psi) + braid->center_y;
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use));
else
XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
XDrawLine(display, window, MI_GC(mi),
(int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2));
}
} else {
/* no crosSINFg */
#ifdef COLORCOMP
if (MI_NPIXELS(mi) > 2) {
color_use = color + SPINRATE *
braid->components[applywordbackto(braid, s, i)] +
(psi + t) / 2.0 / M_PI * (float) MI_NPIXELS(mi);
while (((int) color_use) >= MI_NPIXELS(mi))
color_use -= (float) MI_NPIXELS(mi);
while (((int) color_use) < 0)
color_use += (float) MI_NPIXELS(mi);
}
#endif
#ifdef COLORROUND
if (MI_NPIXELS(mi) > 2) {
color_use += SPINRATE * color_inc;
while (((int) color_use) >= MI_NPIXELS(mi))
color_use -= (float) MI_NPIXELS(mi);
}
#endif
r1 = braid->min_radius + r_diff * (float) (s);
x_1 = r1 * COSF(t + psi) + braid->center_x;
y_1 = r1 * SINF(t + psi) + braid->center_y;
x_2 = r1 * COSF(t + t_inc + psi) + braid->center_x;
y_2 = r1 * SINF(t + t_inc + psi) + braid->center_y;
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, MI_GC(mi), MI_PIXEL(mi, (int) color_use));
else
XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
XDrawLine(display, window, MI_GC(mi),
(int) (x_1), (int) (y_1), (int) (x_2), (int) (y_2));
}
}
}
}
XSetLineAttributes(display, MI_GC(mi), 1, LineSolid, CapNotLast, JoinRound);
if (++braid->age > MI_CYCLES(mi)) {
#ifdef STANDALONE
braid->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), braid->eraser);
#endif
init_braid(mi);
}
}
void INTERNAL_init_cursor(GC gc_pixmap)
{
unsigned long valuemask = 0;
XGCValues values;
Cursor cursor;
Pixmap hand, handmask;
Pixmap updown, updownmask;
unsigned long fg, bg;
unsigned int width, height;
unsigned int hot_x, hot_y, hot2_x, hot2_y;
int i;
Colormap cmap;
XColor black, white;
init_store_cursor();
for (i=0;i<G_MAXWINDOW;i++)
INTERNAL_reset_cursor(i);
gc_pix = gc_pixmap;
gc_crosshair= XCreateGC(INTERNAL_display,INTERNAL_rootwin,valuemask,&values);
valuemask = GCLineStyle | GCLineWidth | GCCapStyle | GCJoinStyle;
XGetGCValues(INTERNAL_display,gc_pix,valuemask,&values);
XSetLineAttributes(INTERNAL_display,
gc_pix,
0,
values.line_style,
values.cap_style,
values.join_style);
XSetLineAttributes(INTERNAL_display,
gc_crosshair,
0,
values.line_style,
values.cap_style,
values.join_style);
XSetFunction(INTERNAL_display, gc_crosshair, GXxor);
XSetForeground(INTERNAL_display, gc_crosshair,
WhitePixel(INTERNAL_display, INTERNAL_screen) ^
BlackPixel(INTERNAL_display, INTERNAL_screen));
cur_cross = XCreateFontCursor(INTERNAL_display, XC_crosshair);
cur_wait = XCreateFontCursor(INTERNAL_display, XC_watch);
XQueryBestCursor(INTERNAL_display, INTERNAL_rootwin, 32, 32, &width, &height);
fg = 1;
bg = 0;
if (width >= 32 && height >= 32) {
hand = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)hand32_bits, hand32_width, hand32_height, fg, bg, 1);
handmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)handm32_bits, handm32_width, handm32_height, fg, bg, 1);
hot_x = 8;
hot_y = 12;
updown = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updown32_bits, updown32_width, updown32_height, fg, bg, 1);
updownmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updownmask32_bits, updownmask32_width, updownmask32_height, fg, bg, 1);
hot2_x = 16;
hot2_y = 16;
}
else {
hand = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)hand_bits, hand_width, hand_height, fg, bg, 1);
handmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)handmask_bits, handmask_width, handmask_height, fg, bg, 1);
hot_x = 4;
hot_y = 6;
updown = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updown_bits, updown_width, updown_height, fg, bg, 1);
updownmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updownmask_bits, updownmask_width, updownmask_height, fg, bg, 1);
hot2_x = 8;
hot2_y = 8;
}
cmap = DefaultColormap(INTERNAL_display,INTERNAL_screen);
XParseColor(INTERNAL_display, cmap, "black", &black);
XAllocColor(INTERNAL_display, cmap, &black);
XParseColor(INTERNAL_display, cmap, "white", &white);
XAllocColor(INTERNAL_display, cmap, &white);
cur_hand = XCreatePixmapCursor(INTERNAL_display, hand, handmask,
&black, &white, hot_x, hot_y);
cur_updown = XCreatePixmapCursor(INTERNAL_display, updown, updownmask,
&black, &white, hot2_x, hot2_y);
XFreePixmap(INTERNAL_display, hand);
XFreePixmap(INTERNAL_display, handmask);
}
G_MODULE_EXPORT int
test_pixmap_main (int argc, char **argv)
{
GOptionContext *context;
Display *xdpy;
int screen;
ClutterActor *group = NULL, *label, *stage, *tex;
Pixmap pixmap;
const ClutterColor gry = { 0x99, 0x99, 0x99, 0xFF };
Window win_remote;
guint w, h, d;
GC gc;
ClutterTimeline *timeline;
ClutterAlpha *alpha;
ClutterBehaviour *depth_behavior;
int i;
int row_height;
#ifdef CLUTTER_WINDOWING_X11
clutter_set_windowing_backend (CLUTTER_WINDOWING_X11);
#endif
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
#ifdef CLUTTER_WINDOWING_X11
if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
g_error ("test-pixmap requires the X11 Clutter backend.");
#endif
xdpy = clutter_x11_get_default_display ();
XSynchronize (xdpy, True);
context = g_option_context_new (" - test-pixmap options");
g_option_context_add_main_entries (context, g_options, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
pixmap = create_pixmap (&w, &h, &d);
screen = DefaultScreen(xdpy);
win_remote = XCreateSimpleWindow (xdpy, DefaultRootWindow(xdpy),
0, 0, 200, 200,
0,
WhitePixel(xdpy, screen),
WhitePixel(xdpy, screen));
XMapWindow (xdpy, win_remote);
stage = clutter_stage_new ();
clutter_actor_set_position (stage, 0, 150);
clutter_actor_set_background_color (stage, &gry);
clutter_stage_set_title (CLUTTER_STAGE (stage), "X11 Texture from Pixmap");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
timeline = clutter_timeline_new (5000);
g_signal_connect (timeline,
"completed", G_CALLBACK (timeline_completed),
NULL);
alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR);
depth_behavior = clutter_behaviour_depth_new (alpha, -2500, 400);
if (!disable_x11)
{
group = clutter_group_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
label = clutter_text_new_with_text ("fixed",
"ClutterX11Texture (Window)");
clutter_container_add_actor (CLUTTER_CONTAINER (group), label);
tex = clutter_x11_texture_pixmap_new_with_window (win_remote);
clutter_container_add_actor (CLUTTER_CONTAINER (group), tex);
clutter_actor_set_position (tex, 0, 20);
clutter_x11_texture_pixmap_set_automatic (CLUTTER_X11_TEXTURE_PIXMAP (tex),
TRUE);
clutter_texture_set_filter_quality (CLUTTER_TEXTURE (tex),
CLUTTER_TEXTURE_QUALITY_HIGH);
clutter_actor_set_position (group, 0, 0);
if (!disable_animation)
clutter_behaviour_apply (depth_behavior, group);
}
if (group)
row_height = clutter_actor_get_height (group);
else
row_height = 0;
/* NB: We only draw on the window after being redirected, so we dont
* have to worry about handling expose events... */
gc = XCreateGC (xdpy, win_remote, 0, NULL);
XSetForeground (xdpy, gc, BlackPixel (xdpy, screen));
XSetLineAttributes(xdpy, gc, 5, LineSolid, CapButt, JoinMiter);
for (i = 0; i < 10; i++)
XDrawLine (xdpy, win_remote, gc, 0+i*20, 0, 10+i*20+i, 200);
group = clutter_group_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
label = clutter_text_new_with_text ("fixed", "ClutterX11Texture (Pixmap)");
clutter_container_add_actor (CLUTTER_CONTAINER (group), label);
tex = clutter_x11_texture_pixmap_new_with_pixmap (pixmap);
clutter_x11_texture_pixmap_set_automatic (CLUTTER_X11_TEXTURE_PIXMAP (tex),
TRUE);
clutter_container_add_actor (CLUTTER_CONTAINER (group), tex);
clutter_actor_set_position (tex, 0, 20);
clutter_texture_set_filter_quality (CLUTTER_TEXTURE (tex),
CLUTTER_TEXTURE_QUALITY_HIGH);
/* oddly, the actor's size is 0 until it is realized, even though
pixmap-height is set */
clutter_actor_set_position (group, 0, row_height);
if (!disable_animation)
clutter_behaviour_apply (depth_behavior, group);
g_signal_connect (stage, "key-release-event",
G_CALLBACK (stage_key_release_cb), (gpointer)pixmap);
g_signal_connect (stage, "button-press-event",
G_CALLBACK (stage_button_press_cb), (gpointer)pixmap);
clutter_actor_show (stage);
if (!disable_animation)
clutter_timeline_start (timeline);
clutter_threads_add_timeout (1000, draw_arc, GUINT_TO_POINTER (pixmap));
clutter_main ();
return EXIT_SUCCESS;
}
/* width, height give the size of the thing being drawn
* on in pixels
*
* x, y draw at x, y on this cairo surface.
* translate the plots, in pixels, which
* is where the origin is on the
* width by height surface
*
* the graph (gr) keep a shift and scale that map the plot
* data from qp_plot_begin_x() and qp_plot_nextx() and etc
* from an square area of in doubles x,y [0,0 to 1,1] to an
* area that is the size of the drawing_area in pixels like
* x,y [0,0 to 800,600]
*
* width, height is not necessarily the same size as the
* drawing_area widget, likely it is larger
* like 2000 by 3000
*/
static inline
void graph_draw(struct qp_graph *gr, cairo_t *cr,
int x, int y, int width, int height)
{
struct qp_plot *p;
/* These doubles will hold the net result of zoom and pixel scaling
* the zoom, gr->z, changes as the user zooms in and out and the
* pixel scaling changes with the drawing area widget size allocation */
double xscale, xshift, yscale, yshift;
xscale = gr->xscale*gr->z->xscale;
yscale = gr->yscale*gr->z->yscale;
xshift = gr->xscale*gr->z->xshift + gr->xshift + x;
yshift = gr->yscale*gr->z->yshift + gr->yshift + y;
if(gr->x11 && gr->background_color.a < 0.05)
{
/* For some reason when drawing with X11
* and having mostly-transparent background the
* drawing seems to fail to cover the old
* drawing. Painting the whole area to
* start with seems to fix it. */
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(cr, 1,1,1,1.0);
cairo_paint(cr);
}
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba(cr, gr->background_color.r,
gr->background_color.g, gr->background_color.b,
gr->background_color.a);
cairo_paint(cr);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
if(gr->qp->shape)
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
else
cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
draw_grid(gr, cr, xscale, xshift, yscale, yshift, width, height);
if(gr->show_grid && (gr->same_x_scale || gr->same_y_scale) &&
qp_sllist_length(gr->plots) > 0)
{
struct qp_plot *p;
p = (struct qp_plot *)qp_sllist_first(gr->plots);
/* We need to initialize the plot scaling for this
* graph grid drawing */
qp_plot_scale(p, xscale, xshift, yscale, yshift);
qp_graph_grid_draw(gr, p, cr, width, height);
}
if(gr->x11)
{
/* Get ready to draw with X11 API calls now */
cairo_surface_flush(cairo_get_target(cr));
gr->DrawLine = x11_DrawLine;
}
else
{
gr->DrawLine = cairo_DrawLine;
gr->cr = cr;
}
p = (struct qp_plot *) qp_sllist_begin(gr->plots);
while(p)
{
double x_val, y_val;
if(p->lines)
{
/* draw lines */
double minusLineWidthPlus1, widthPlus, heightPlus;
double prev_x, prev_y;
int new_line = 1;
minusLineWidthPlus1 = - p->line_width - 1;
widthPlus = width + p->line_width;
heightPlus = height + p->line_width;
if(gr->x11)
{
XSetLineAttributes(gr->x11->dsp, gr->x11->gc, INT(p->line_width),
LineSolid, CapRound, JoinRound);
XSetForeground(gr->x11->dsp, gr->x11->gc, p->l.x);
}
else
{
cairo_set_source_rgba(cr, p->l.c.r, p->l.c.g, p->l.c.b, p->l.c.a);
cairo_set_line_width(cr, p->line_width);
}
if(qp_plot_begin(p, xscale, xshift, yscale, yshift,
INT(minusLineWidthPlus1), INT(minusLineWidthPlus1),
INT(widthPlus), INT(heightPlus),
&prev_x, &prev_y))
{
/* We start with a good point in prev_x, prev_y */
while((!is_good_double(prev_x) || !is_good_double(prev_y)) &&
qp_plot_next(p, &prev_x, &prev_y));
while(qp_plot_next(p, &x_val, &y_val))
{
CullDrawLine(gr, &new_line,
minusLineWidthPlus1, widthPlus, heightPlus,
prev_x, prev_y, x_val, y_val);
if(p->gaps)
{
prev_x = x_val;
prev_y = y_val;
}
else /* no gaps */
{
/* do not lift up the pen if no gaps */
if(is_good_double(x_val) && is_good_double(y_val))
{
/* This may be any number of points from before
* if there where an NAN or something. */
prev_x = x_val;
prev_y = y_val;
}
if(new_line)
new_line = 0;
}
}
if(!gr->x11)
cairo_stroke(cr);
}
}
if(p->points)
{
double point_w, point_w2;
int ipoint_w;
double point_min, point_xmax, point_ymax;
point_w2 = (point_w = p->point_size)/2;
point_min = - point_w2 - 2;
point_xmax = width + point_w2 + 1;
point_ymax = height + point_w2 + 1;
ipoint_w = INT(point_w);
if(gr->x11)
XSetForeground(gr->x11->dsp, gr->x11->gc, p->p.x);
else
cairo_set_source_rgba(cr, p->p.c.r, p->p.c.g, p->p.c.b, p->p.c.a);
/* Putting the point width offset (point_w2) into
* the plot data reader object is faster than adding
* the point width offset in the tight loop in the
* cairo_rectangle() call where we would add it
* every loop interation. */
if(qp_plot_begin(p, xscale, xshift - point_w2,
yscale, yshift - point_w2,
INT(point_min), INT(point_min),
INT(point_xmax), INT(point_ymax),
&x_val, &y_val))
{
int prev_x = INT_MAX, prev_y = INT_MAX;
do
{
//DEBUG("%g %g\n", x_val, y_val);
if(is_good_double(x_val) && is_good_double(y_val) &&
/* point culling is easy */
point_min < x_val && point_min < y_val &&
x_val < point_xmax && y_val < point_ymax)
{
int x, y;
x = INT(x_val);
y = INT(y_val);
/* speed up point drawing by not drawing points
* that are on top of adjacent points more than once.
* This can be the biggest time saver when there are
* over 100,000 points. Note this assumes that
* points that as close in x,y space are adjacent
* in the series (channel). This will slow down
* plotting of small files, but not enough that
* we can measure. Tests show that cairo rectangle
* drawing is much slower than line drawing. Cairo
* does not appear to be optimised for small rectangle
* drawing. Single pixel drawing in cairo uses
* 1x1 rectangles, which are no faster to draw.
* We convert the doubles to ints in the call to
* cairo_rectangle() just because it speeds up
* drawing. */
if(prev_x != x || prev_y != y)
{
if(gr->x11)
XFillRectangle(gr->x11->dsp, gr->x11->pixmap,
gr->x11->gc, x, y, ipoint_w, ipoint_w);
else
cairo_rectangle(cr, x, y, point_w, point_w);
}
prev_x = x;
prev_y = y;
}
} while(qp_plot_next(p, &x_val, &y_val));
if(!gr->x11)
cairo_fill(cr);
}
}
/* The mouse pointer value picker needs this to be reset from the
* - point_w2 offset above. Needed for all plots when
* using the value picker GUI */
qp_plot_scale(p, xscale, xshift, yscale, yshift);
p = (struct qp_plot *) qp_sllist_next(gr->plots);
}
}