int main(int argc, char *argv[]) { XEvent e; Atom type; XClassHint *h; XSetWindowAttributes wa; unsigned int desktop; struct pollfd pfd[1]; int nfds; char *fontstr = FONT; int running = 1; d = XOpenDisplay(NULL); if (d == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); } s = DefaultScreen(d); wa.override_redirect = 1; wa.background_pixmap = ParentRelative; wa.event_mask = ExposureMask | ButtonReleaseMask | ButtonPressMask; w = XCreateWindow(d, RootWindow(d, s), 0, BARPOS, BARWIDTH, BARHEIGHT, 0, DefaultDepth(d, s), CopyFromParent, DefaultVisual(d, s), CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa); h = XAllocClassHint(); h->res_name = "status"; h->res_class = "status"; XSetClassHint(d, w, h); XFree(h); XStoreName(d, w, "status"); type = XInternAtom(d, "_NET_WM_WINDOW_TYPE_DOCK", False); XChangeProperty(d, w, XInternAtom(d, "_NET_WM_WINDOW_TYPE", False), XInternAtom(d, "ATOM", False), 32, PropModeReplace, (unsigned char *)&type, 1); type = XInternAtom(d, "_NET_WM_STATE_ABOVE", False); XChangeProperty(d, w, XInternAtom(d, "_NET_WM_STATE", False), XInternAtom(d, "ATOM", False), 32, PropModeReplace, (unsigned char *)&type, 1); type = XInternAtom(d, "_NET_WM_STATE_STICKY", False); XChangeProperty(d, w, XInternAtom(d, "_NET_WM_STATE", False), XInternAtom(d, "ATOM", False), 32, PropModeAppend, (unsigned char *)&type, 1); desktop = 0xffffffff; XChangeProperty(d, w, XInternAtom(d, "_NET_WM_DESKTOP", False), XInternAtom(d, "CARDINAL", False), 32, PropModeReplace, (unsigned char *)&desktop, 1); xftd = XftDrawCreate(d, w, DefaultVisual(d, s), DefaultColormap(d, s)); XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "white", &white); XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "black", &black); XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "red", &red); XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "green", &green); xftfont = XftFontOpenXlfd(d, s, fontstr); if (!xftfont) xftfont = XftFontOpenName(d, s, fontstr); if (!xftfont) exit(1); XSelectInput(d, w, ExposureMask | ButtonPressMask | ButtonReleaseMask | Button1MotionMask); XSelectInput(d, RootWindow(d, s), PropertyChangeMask); XMapWindow(d, w); XFlush(d); pfd[0].fd = ConnectionNumber(d); pfd[0].events = POLLIN; while (running) { nfds = poll(pfd, 1, 1000); if (nfds == -1 || (pfd[0].revents & (POLLERR|POLLHUP|POLLNVAL))) break; if (nfds == 0) { redraw(); XFlush(d); continue; } while (XPending(d)) { XNextEvent(d, &e); if (e.type == PropertyNotify && e.xproperty.window == RootWindow(d, s) && e.xproperty.atom == XInternAtom(d, "_NET_CURRENT_DESKTOP", True)) { redraw(); } if (e.type == Expose) { XftDrawRect(xftd, &black, 0, 0, BARWIDTH, BARHEIGHT); redraw(); } if (e.type == ButtonPress) { /*running = 0; break;*/ redraw(); } } } XftColorFree(d, DefaultVisual(d, s), DefaultColormap(d, s), &white); XftColorFree(d, DefaultVisual(d, s), DefaultColormap(d, s), &black); XftFontClose(d, xftfont); XftDrawDestroy(xftd); XDestroyWindow(d, w); XCloseDisplay(d); return 0; }
XMenu * XMenuCreate(Display *display, Window parent, register char const *def_env) /* ID of previously opened display */ /* Window ID of the menu's parent window. */ /* X Defaults program environment name. */ { register char *def_val; /* X Default value temp variable. */ register XMenu *menu; /* Pointer to the new menu. */ XMStyle menu_style; /* Menu display style. */ XMMode menu_mode; /* Menu display mode. */ XMPane *pane; /* Pane list header. */ XAssocTable *assoc_tab; /* XAssocTable pointer. */ int freeze; /* Freeze server mode. */ int reverse; /* Reverse video mode. */ XMStyle p_style; /* Pane display style. */ char const *p_fnt_name; /* Flag font name. */ XFontStruct *p_fnt_info; /* Flag font structure */ int p_fnt_pad; /* Flag font padding in pixels. */ double p_spread; /* Pane spread in flag height fractions. */ int p_fnt_height; /* Pane character height. */ int p_bdr_width; /* Pane border width. */ int flag_height; /* Flag window height. */ int p_height; /* Pane window height. */ int p_x_off; /* Pane X offset. */ int p_y_off; /* Pane Y offset. */ GC pane_GC; /* Pane graphics context. */ XMStyle s_style; /* Selection display style. */ char const *s_fnt_name; /* Selection font name. */ XFontStruct *s_fnt_info; /* Selection font structure. */ int s_fnt_pad; /* Selection font padding in pixels. */ int s_fnt_height; /* Selection font character height */ double s_spread; /* Select spread in line height fractions. */ int s_bdr_width; /* Highlight border width. */ int s_height; /* Selection window height. */ int s_x_off; /* Selection window X offset. */ int s_y_off; /* Selection window Y offset. */ GC normal_select_GC; /* GC used for normal video selection. */ GC inverse_select_GC; /* GC used for inverse video selection. */ GC inact_GC; /* GC for inactive pane header and */ /* selections. */ XColor color_def; /* Temp color definition holder. */ XColor p_bdr_color; /* Color of border. */ XColor s_bdr_color; /* Color of highlight. */ XColor p_frg_color; /* Color of pane foreground color. */ XColor s_frg_color; /* Color of selection foreground. */ XColor bkgnd_color; /* Color of background.. */ XColor mouse_color; /* Color of mouse cursor. */ Cursor mouse_cursor; /* Mouse cursor. */ Pixmap inact_bitmap; /* Menu inactive pixmap. */ int inact_pnum; /* Inactive background pattern number. */ Pixmap cursor; /* Cursor pixmap holder. */ Pixmap cursor_mask; /* Cursor mask pixmap holder. */ Pixmap stipple_pixmap; /* Stipple mask for half-tone text. */ unsigned long valuemask; XGCValues *values; Window root = RootWindow (display, DefaultScreen (display)); /* * Calloc the XMenu structure and the initial pane. */ menu = (XMenu *)calloc(1, sizeof(XMenu)); if (menu == NULL) { _XMErrorCode = XME_CALLOC; return(NULL); } pane = (XMPane *)calloc(1, sizeof(XMPane)); if (pane == NULL) { _XMErrorCode = XME_CALLOC; return(NULL); } /* * Create the XAssocTable */ assoc_tab = (XAssocTable *)XCreateAssocTable(XASSOC_TABLE_SIZE); if(assoc_tab == NULL) { _XMErrorCode= XME_CREATE_ASSOC; return(NULL); } /* * Set up the default environment name. */ if (def_env == NULL || *def_env == '\0') def_env = "XMenu"; /* * Set up internal fail-safe defaults. */ freeze = DEF_FREEZE; reverse = DEF_REVERSE; menu_style = DEF_MENU_STYLE; menu_mode = DEF_MENU_MODE; inact_pnum = DEF_INACT_PNUM; p_style = DEF_P_STYLE; p_spread = DEF_P_SPREAD; p_fnt_name = DEF_P_FNT_NAME; p_bdr_width = DEF_P_BDR_WIDTH; s_style = DEF_S_STYLE; s_spread = DEF_S_SPREAD; s_fnt_name = DEF_S_FNT_NAME; s_bdr_width = DEF_S_BDR_WIDTH; /* * Get default values from X. */ def_val = x_get_resource_string ("menuFreeze", "MenuFreeze"); if (def_val != NULL) { if (strcmp(def_val, "on") == 0) freeze = 1; else if (strcmp(def_val, "off") == 0) freeze = 0; } def_val = x_get_resource_string ("menuReverseVideo", "MenuReverseVideo"); if (def_val != NULL) { if (strcmp(def_val, "on") == 0) reverse = 1; else if (strcmp(def_val, "off") == 0) reverse = 0; } def_val = x_get_resource_string ("menuStyle", "MenuStyle"); if (def_val != NULL) { if (strcmp(def_val, "right_hand") == 0) menu_style = RIGHT; else if (strcmp(def_val, "left_hand") == 0) menu_style = LEFT; else if (strcmp(def_val, "center") == 0) menu_style = CENTER; } def_val = x_get_resource_string ("menuMode", "MenuMode"); if (def_val != NULL) { if (strcmp(def_val, "box") == 0) menu_mode = BOX; else if (strcmp(def_val, "invert") == 0) menu_mode = INVERT; } def_val = x_get_resource_string ("menuMouse", "MenuMouse"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &mouse_color, &color_def) ); else if (reverse && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &mouse_color, &color_def) ); else if (XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &mouse_color, &color_def) ); else {} def_val = x_get_resource_string ("menuBackground", "MenuBackground"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &bkgnd_color, &color_def) ); else if (reverse && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &bkgnd_color, &color_def) ); else if (XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &bkgnd_color, &color_def) ); else {} def_val = x_get_resource_string ("menuInactivePattern", "MenuInactivePattern"); if (def_val != NULL) { if (strcmp(def_val, "dimple1") == 0) inact_pnum = 0; else if (strcmp(def_val, "dimple3") == 0) inact_pnum = 1; else if (strcmp(def_val, "gray1") == 0) inact_pnum = 2; else if (strcmp(def_val, "gray3") == 0) inact_pnum = 3; else if (strcmp(def_val, "cross_weave") == 0) inact_pnum = 4; } def_val = x_get_resource_string ("paneStyle", "PaneStyle"); if (def_val != NULL) { if (strcmp(def_val, "flush_left") == 0) p_style = LEFT; else if (strcmp(def_val, "flush_right") == 0) p_style = RIGHT; else if (strcmp(def_val, "center") == 0) p_style = CENTER; } def_val = x_get_resource_string ("paneFont", "PaneFont"); if (def_val != NULL) p_fnt_name = def_val; def_val = x_get_resource_string ("paneForeground", "PaneForeground"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 ) XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &p_frg_color, &color_def); else if (reverse) XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &p_frg_color, &color_def); else XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &p_frg_color, &color_def); def_val = x_get_resource_string ("paneBorder", "PaneBorder"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &p_bdr_color, &color_def) ); else if (reverse && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &p_bdr_color, &color_def) ); else XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &p_bdr_color, &color_def); def_val = x_get_resource_string ("paneBorderWidth", "PaneBorderWidth"); if (def_val != NULL) p_bdr_width = atoi(def_val); def_val = x_get_resource_string ("paneSpread", "PaneSpread"); if (def_val != NULL) p_spread = atof(def_val); def_val = x_get_resource_string ("selectionStyle", "SelectionStyle"); if (def_val != NULL) { if (strcmp(def_val, "flush_left") == 0) s_style = LEFT; else if (strcmp(def_val, "flush_right") == 0) s_style = RIGHT; else if (strcmp(def_val, "center") == 0) s_style = CENTER; } def_val = x_get_resource_string ("selectionFont", "SelectionFont"); if (def_val != NULL) s_fnt_name = def_val; def_val = x_get_resource_string ("selectionForeground", "SelectionForeground"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &s_frg_color, &color_def) ); else if (reverse && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &s_frg_color, &color_def) ) ; else if (XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &s_frg_color, &color_def) ) ; else {} def_val = x_get_resource_string ("selectionBorder", "SelectionBorder"); if ( def_val != NULL && DisplayCells(display, DefaultScreen(display)) > 2 && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), def_val, &s_bdr_color, &color_def) ) ; else if (reverse && XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "white", &s_bdr_color, &color_def) ) ; else if (XAllocDisplayColor(display, DefaultColormap(display, DefaultScreen(display)), "black", &s_bdr_color, &color_def) ) ; else {} def_val = x_get_resource_string ("selectionBorderWidth", "SelectionBorderWidth"); if (def_val != NULL) s_bdr_width = atoi(def_val); def_val = x_get_resource_string ("selectionSpread", "SelectionSpread"); if (def_val != NULL) s_spread = atof(def_val); /* * Create and store the inactive pattern pixmap. */ { char *data = NULL; int width, height; switch (inact_pnum) { case 0: data = (char *)dimple1_bits; width = dimple1_width; height = dimple1_height; break; case 1: data = (char *)dimple3_bits; width = dimple3_width; height = dimple3_height; break; case 2: data = (char *)gray1_bits; width = gray1_width; height = gray1_height; break; case 3: data = (char *)gray3_bits; width = gray3_width; height = gray3_height; break; case 4: data = (char *)cross_weave_bits; width = cross_weave_width; height = cross_weave_height; break; } if (! data) { _XMErrorCode = XME_STORE_BITMAP; return(NULL); } inact_bitmap = XCreatePixmapFromBitmapData (display, root, data, width, height, p_frg_color.pixel, bkgnd_color.pixel, DisplayPlanes (display, DefaultScreen (display))); } /* * Load the mouse cursor. */ switch (menu_style) { case LEFT: cursor = XCreateBitmapFromData(display, root, left_ptr_bits, left_ptr_width, left_ptr_height); cursor_mask = XCreateBitmapFromData(display, root, left_ptrmsk_bits, left_ptrmsk_width, left_ptrmsk_height); mouse_cursor = XCreatePixmapCursor( display, cursor, cursor_mask, &mouse_color, &bkgnd_color, left_ptr_x_hot, left_ptr_y_hot ); XFreePixmap(display, cursor); XFreePixmap(display, cursor_mask); break; case RIGHT: cursor = XCreateBitmapFromData(display, root, right_ptr_bits, right_ptr_width, right_ptr_height); cursor_mask = XCreateBitmapFromData(display, root, right_ptrmsk_bits, right_ptrmsk_width, right_ptrmsk_height); mouse_cursor = XCreatePixmapCursor( display, cursor, cursor_mask, &mouse_color, &bkgnd_color, right_ptr_x_hot, right_ptr_y_hot ); XFreePixmap(display, cursor); XFreePixmap(display, cursor_mask); break; case CENTER: cursor = XCreateBitmapFromData(display, root, cntr_ptr_bits, cntr_ptr_width, cntr_ptr_height); cursor_mask = XCreateBitmapFromData(display, root, cntr_ptrmsk_bits, cntr_ptrmsk_width, cntr_ptrmsk_height); mouse_cursor = XCreatePixmapCursor( display, cursor, cursor_mask, &mouse_color, &bkgnd_color, cntr_ptr_x_hot, cntr_ptr_y_hot ); XFreePixmap(display, cursor); XFreePixmap(display, cursor_mask); break; default: /* Error! Invalid style parameter. */ _XMErrorCode = XME_STYLE_PARAM; return(NULL); } if (mouse_cursor == _X_FAILURE) { _XMErrorCode = XME_CREATE_CURSOR; return(NULL); } /* * Open the pane and selection fonts. */ p_fnt_info = XLoadQueryFont(display, p_fnt_name); if (p_fnt_info == NULL) { _XMErrorCode = XME_OPEN_FONT; return(NULL); } s_fnt_info = XLoadQueryFont(display, s_fnt_name); if (s_fnt_info == NULL) { _XMErrorCode = XME_OPEN_FONT; return(NULL); } /* * Calculate the fixed padding value in pixels for each font. */ p_fnt_height = p_fnt_info->max_bounds.ascent + p_fnt_info->max_bounds.descent; s_fnt_height = s_fnt_info->max_bounds.ascent + s_fnt_info->max_bounds.descent; p_fnt_pad = s_spread * p_fnt_height; s_fnt_pad = s_spread * s_fnt_height; /* * Calculate fixed height and offset requirements. */ flag_height = p_fnt_height + (p_fnt_pad << 1); p_height = 0; p_y_off = flag_height + p_bdr_width; p_x_off = p_y_off * p_spread; s_height = s_fnt_height + (s_fnt_pad << 1) + (s_bdr_width << 1); s_y_off = s_height; s_x_off = p_x_off; /* * Set up the pane list header. */ pane->next = pane; pane->prev = pane; pane->type = PL_HEADER; pane->serial = -1; /* * Initialize the internal pane and selection creation queues. */ _XMWinQueInit(); /* * Create pane, active, and inactive GC's. */ values = (XGCValues *)malloc(sizeof(XGCValues)); valuemask = (GCForeground | GCBackground | GCFont | GCLineWidth); /* * First, pane. */ values->foreground = p_frg_color.pixel; values->background = bkgnd_color.pixel; values->font = p_fnt_info->fid; values->line_width = p_bdr_width; pane_GC = XCreateGC( display, root, valuemask, values); /* * Then normal video selection. */ values->foreground = s_frg_color.pixel; values->background = bkgnd_color.pixel; values->font = s_fnt_info->fid; values->line_width = s_bdr_width; normal_select_GC = XCreateGC(display, root, valuemask, values); /* * Inverse video selection. */ values->foreground = bkgnd_color.pixel; values->background = s_frg_color.pixel; values->font = s_fnt_info->fid; values->line_width = s_bdr_width; inverse_select_GC = XCreateGC(display, root, valuemask, values); stipple_pixmap = XCreateBitmapFromData(display, root, stipple_bits, stipple_width, stipple_height); /* * Finally, inactive pane header and selections */ valuemask |= (GCFillStyle | GCStipple); values->foreground = s_frg_color.pixel; values->background = bkgnd_color.pixel; values->font = s_fnt_info->fid; values->line_width = s_bdr_width; values->fill_style = FillStippled; values->stipple = stipple_pixmap; inact_GC = XCreateGC(display, root, valuemask, values); valuemask |= (GCGraphicsExposures); values->graphics_exposures = False; /* * Construct the XMenu object. */ /* -------------------- Menu data -------------------- */ menu->menu_style = menu_style; menu->menu_mode = menu_mode; menu->freeze = freeze; menu->aeq = 0; menu->recompute = 1; menu->parent = parent; menu->height = 0; menu->width = 0; menu->mouse_cursor = mouse_cursor; menu->assoc_tab = assoc_tab; menu->p_list = pane; /* -------------------- Pane window data -------------------- */ menu->p_style = p_style; menu->p_events = DEF_P_EVENTS; menu->p_fnt_info = p_fnt_info; menu->p_fnt_pad = p_fnt_pad; menu->p_spread = p_spread; menu->p_bdr_width = p_bdr_width; menu->flag_height = flag_height; menu->p_width = 0; menu->p_height = p_height; menu->p_x_off = p_x_off; menu->p_y_off = p_y_off; menu->p_count = 0; menu->pane_GC = pane_GC; menu->x_pos = 0; menu->y_pos = 0; /* -------------------- Selection window data -------------------- */ menu->s_style = s_style; menu->s_events = DEF_S_EVENTS; menu->s_fnt_info = s_fnt_info; menu->s_fnt_pad = s_fnt_pad; menu->s_spread = s_spread; menu->s_bdr_width = s_bdr_width; /* unnecessary */ menu->s_width = 0; menu->s_height = s_height; menu->s_x_off = s_x_off; menu->s_y_off = s_y_off; menu->s_count = 0; menu->normal_select_GC = normal_select_GC; menu->inverse_select_GC = inverse_select_GC; menu->inact_GC = inact_GC; /* -------------------- Color data -------------------- */ menu->p_bdr_color = p_bdr_color.pixel; menu->s_bdr_color = s_bdr_color.pixel; menu->p_frg_color = p_frg_color.pixel; menu->s_frg_color = s_frg_color.pixel; menu->bkgnd_color = bkgnd_color.pixel; /* -------------------- Pixmap data -------------------- */ menu->p_bdr_pixmap = None; menu->s_bdr_pixmap = None; menu->p_frg_pixmap = None; menu->s_frg_pixmap = None; menu->bkgnd_pixmap = None; menu->inact_pixmap = inact_bitmap; /* * Return the completed XMenu. */ _XMErrorCode = XME_NO_ERROR; return(menu); }
static void _find_color(Widget w, XColor *target, char *dontuse) { Colormap cm; XColor cell_def[256]; double cur_dist; int cur_red_dist_index=0; int cur_green_dist_index=0; int cur_blue_dist_index=0; double cur_red_dist; double cur_green_dist; double cur_blue_dist; double dist; double red_dist; double green_dist; double blue_dist; int i; XColor tmp = {0,0,0,0,0,0}; int screen; int ncells; Display *d = XtDisplay(w); XWindowAttributes win_att; int depth; Pixel pix; unsigned long red_mask=0; unsigned long green_mask=0; unsigned long blue_mask=0; unsigned long red_mult=0; unsigned long green_mult=0; unsigned long blue_mult=0; screen = XScreenNumberOfScreen(XtScreen(w)); XtVaGetValues(w, XmNdepth, &depth, NULL); if(depth == 8) ncells = 255; else if(depth == 12) ncells = 16; else ncells = 256; if(XtIsRealized(w)) { XGetWindowAttributes(d, XtWindow(w), &win_att); if(win_att.colormap != DefaultColormap(XtDisplay(w), screen)) { cm = win_att.colormap; red_mask = win_att.visual->red_mask; green_mask = win_att.visual->green_mask; blue_mask = win_att.visual->blue_mask; red_mult = red_mask & (~red_mask+1); green_mult = green_mask & (~green_mask+1); blue_mult = blue_mask & (~blue_mask+1); } else { cm = DefaultColormap(XtDisplay(w), screen); } } else { cm = DefaultColormap(XtDisplay(w), screen); } for (i = 0; i < ncells; i++) { switch(depth) { case 8: cell_def[i].pixel = i; break; case 12: pix = i; cell_def[i].pixel = (pix * red_mult) + (pix * green_mult) + (pix * blue_mult); break; default: pix = i; cell_def[i].pixel = (pix * red_mult) | (pix * green_mult) | (pix * blue_mult); break; } cell_def[i].flags = DoRed | DoGreen | DoBlue; } XQueryColors(d, cm, cell_def, ncells); cur_dist = sqrt((double)((double)65535*(double)65535*(double)65535)); cur_red_dist = cur_green_dist = cur_blue_dist = 65535.0*65535.0; for (i = 0; i < ncells; i++) { red_dist = (double)(target->red - cell_def[i].red) * (double)(target->red - cell_def[i].red); green_dist = (double)(target->green - cell_def[i].green) * (double)(target->green - cell_def[i].green); blue_dist = (double)(target->blue - cell_def[i].blue) * (double)(target->blue - cell_def[i].blue); switch(depth) { Boolean ok2use; case 8: dist = sqrt(red_dist + green_dist + blue_dist); if (!dontuse) ok2use = True; else ok2use = (dontuse[cell_def[i].pixel] == 0); if ((dist < cur_dist) && (ok2use)) { cur_dist = dist; tmp.red = cell_def[i].red; tmp.green = cell_def[i].green; tmp.blue = cell_def[i].blue; tmp.pixel = cell_def[i].pixel; } break; default: if(red_dist < cur_red_dist) { cur_red_dist = red_dist; cur_red_dist_index = i; } if(green_dist < cur_green_dist) { cur_green_dist = green_dist; cur_green_dist_index = i; } if(blue_dist < cur_blue_dist) { cur_blue_dist = blue_dist; cur_blue_dist_index = i; } break; } } switch(depth) { case 8: target->red = tmp.red; target->green = tmp.green; target->blue = tmp.blue; target->pixel = tmp.pixel; target->flags = tmp.flags; target->pad = tmp.pad; break; default: pix = (cell_def[cur_red_dist_index].pixel & red_mask) | (cell_def[cur_green_dist_index].pixel & green_mask) | (cell_def[cur_blue_dist_index].pixel & blue_mask); target->pixel = pix; target->red = cell_def[cur_red_dist_index].red; target->green = cell_def[cur_green_dist_index].green; target->blue = cell_def[cur_blue_dist_index].blue; break; } }
static Status lookup(Display *dpy, int screen, VisualID visualid, Atom property, XStandardColormap *cnew, Bool replace) /* * dpy - specifies display connection * screen - specifies screen number * visualid - specifies visualid for std map * property - specifies colormap property name * cnew - specifies a standard colormap * replace - specifies whether to replace */ { register int i; int count; XStandardColormap *stdcmaps, *s; Window win = RootWindow(dpy, screen); /* The property does not already exist */ if (! XGetRGBColormaps(dpy, win, &stdcmaps, &count, property)) { if (cnew) XSetRGBColormaps(dpy, win, cnew, 1, property); return 0; } /* The property exists and is not describing the RGB_DEFAULT_MAP */ if (property != XA_RGB_DEFAULT_MAP) { if (replace) { XmuDeleteStandardColormap(dpy, screen, property); if (cnew) XSetRGBColormaps(dpy, win, cnew, 1, property); } XFree((char *)stdcmaps); return 1; } /* The property exists and is RGB_DEFAULT_MAP */ for (i=0, s=stdcmaps; (i < count) && (s->visualid != visualid); i++, s++) ; /* No RGB_DEFAULT_MAP property matches the given visualid */ if (i == count) { if (cnew) { XStandardColormap *m, *maps; s = (XStandardColormap *) malloc((unsigned) ((count+1) * sizeof (XStandardColormap))); for (i = 0, m = s, maps = stdcmaps; i < count; i++, m++, maps++) { m->colormap = maps->colormap; m->red_max = maps->red_max; m->red_mult = maps->red_mult; m->green_max = maps->green_max; m->green_mult = maps->green_mult; m->blue_max = maps->blue_max; m->blue_mult = maps->blue_mult; m->base_pixel = maps->base_pixel; m->visualid = maps->visualid; m->killid = maps->killid; } m->colormap = cnew->colormap; m->red_max = cnew->red_max; m->red_mult = cnew->red_mult; m->green_max = cnew->green_max; m->green_mult = cnew->green_mult; m->blue_max = cnew->blue_max; m->blue_mult = cnew->blue_mult; m->base_pixel = cnew->base_pixel; m->visualid = cnew->visualid; m->killid = cnew->killid; XSetRGBColormaps(dpy, win, s, ++count, property); free((char *) s); } XFree((char *) stdcmaps); return 0; } /* Found an RGB_DEFAULT_MAP property with a matching visualid */ if (replace) { /* Free old resources first - we may need them, particularly in * the default colormap of the screen. However, because of this, * it is possible that we will destroy the old resource and fail * to create a new one if XmuStandardColormap() fails. */ if (count == 1) { XmuDeleteStandardColormap(dpy, screen, property); if (cnew) XSetRGBColormaps(dpy, win, cnew, 1, property); } else { XStandardColormap *map; /* s still points to the matching standard colormap */ if (s->killid == ReleaseByFreeingColormap) { if ((s->colormap != None) && (s->colormap != DefaultColormap(dpy, screen))) XFreeColormap(dpy, s->colormap); } else if (s->killid != None) XKillClient(dpy, s->killid); map = (cnew) ? cnew : stdcmaps + --count; s->colormap = map->colormap; s->red_max = map->red_max; s->red_mult = map->red_mult; s->green_max = map->green_max; s->green_mult = map->green_mult; s->blue_max = map->blue_max; s->blue_mult = map->blue_mult; s->visualid = map->visualid; s->killid = map->killid; XSetRGBColormaps(dpy, win, stdcmaps, count, property); } } XFree((char *) stdcmaps); return 1; }
int XAbstractGui::SetColors(Display *dpy) { int screen; XcmsColor xcolor; XcmsColor exact; int i, scale; int rw_color; /* is it a read/write color ?*/ int visualClass; unsigned long pixels[1 << COLOR_PLANES]; screen = DefaultScreen(dpy); visual = GetBestVisual(dpy, &visualClass, &depth); if (!visual) { fprintf(stderr, "Unable to find an appropriate visual\n"); return 0; } rw_color = (visualClass == DirectColor || visualClass == PseudoColor || visualClass == GrayScale); cmap = DefaultColormap(dpy, screen); if (rw_color) { /* on visuals with read/write color cells first allocate them */ if (!XAllocColorCells(dpy, cmap, False, nullptr, 0, pixels, 1 << COLOR_PLANES)) { /* try again with a own colormap */ cmap = XCreateColormap(dpy, RootWindow(dpy, screen), visual, AllocNone); own_cmap = 1; if (!XAllocColorCells(dpy, cmap, False, nullptr, 0, pixels, 1 << COLOR_PLANES)) { fprintf(stderr, "Unable to allocate %d colors\n", 1 << COLOR_PLANES); return 0; /* failed even with own colormap */ } } } if (!XcmsLookupColor(dpy, cmap, color.c_str(), &xcolor, &exact, XcmsRGBiFormat)) { exact.spec.RGBi.blue = 1.0; exact.spec.RGBi.red = 1.0; exact.spec.RGBi.green = 1.0; } xcolor.format = XcmsRGBiFormat; for (i = 0; i < (1 << COLOR_PLANES); i++) { if (withColorScale) { // DEPENDANCIES: // the color plane masks used here depend on // the same masks used in CopyToZPixmap scale = i & 0x20 ? 2 : 0; scale |= i & 0x04 ? 1 : 0; xcolor.spec.RGBi.green = 1.0 * scale / 3; scale = i & 0x10 ? 2 : 0; scale |= i & 0x02 ? 1 : 0; xcolor.spec.RGBi.red = 1.0 * scale / 3; scale = i & 0x08 ? 2 : 0; scale |= i & 0x01 ? 1 : 0; xcolor.spec.RGBi.blue = 1.0 * scale / 3; } else { xcolor.spec.RGBi.blue = exact.spec.RGBi.blue * i / (1 << COLOR_PLANES); xcolor.spec.RGBi.red = exact.spec.RGBi.red * i / (1 << COLOR_PLANES); xcolor.spec.RGBi.green = exact.spec.RGBi.green * i / (1 << COLOR_PLANES); } if (rw_color) { xcolor.pixel = pixels[i]; if (XcmsStoreColor(dpy, cmap, &xcolor) == XcmsFailure) { fprintf(stderr, "Error storing a color\n"); return 0; } } else { if (XcmsAllocColor(dpy, cmap, &xcolor, XcmsRGBiFormat) == XcmsFailure) { fprintf(stderr, "Error allocating a color\n"); return 0; } } pens[i] = xcolor.pixel; } //gcVal.plane_mask = 0xFFFFFFFF; return 1; }
void Tk_DrawChars( Display *display, /* Display on which to draw. */ Drawable drawable, /* Window or pixmap in which to draw. */ GC gc, /* Graphics context for drawing characters. */ Tk_Font tkfont, /* Font in which characters will be drawn; * must be the same as font used in GC. */ CONST char *source, /* UTF-8 string to be displayed. Need not be * '\0' terminated. All Tk meta-characters * (tabs, control characters, and newlines) * should be stripped out of the string that * is passed to this function. If they are not * stripped out, they will be displayed as * regular printing characters. */ int numBytes, /* Number of bytes in string. */ int x, int y) /* Coordinates at which to place origin of * string when drawing. */ { const int maxCoord = 0x7FFF;/* Xft coordinates are 16 bit values */ UnixFtFont *fontPtr = (UnixFtFont *) tkfont; XGCValues values; XColor xcolor; int clen, nspec; XftGlyphFontSpec specs[NUM_SPEC]; XGlyphInfo metrics; if (fontPtr->ftDraw == 0) { #if DEBUG_FONTSEL printf("Switch to drawable 0x%x\n", drawable); #endif /* DEBUG_FONTSEL */ fontPtr->ftDraw = XftDrawCreate(display, drawable, DefaultVisual(display, fontPtr->screen), DefaultColormap(display, fontPtr->screen)); } else { Tk_ErrorHandler handler = Tk_CreateErrorHandler(display, -1, -1, -1, NULL, (ClientData) NULL); XftDrawChange(fontPtr->ftDraw, drawable); Tk_DeleteErrorHandler(handler); } XGetGCValues(display, gc, GCForeground, &values); if (values.foreground != fontPtr->color.pixel) { xcolor.pixel = values.foreground; XQueryColor(display, DefaultColormap(display, fontPtr->screen), &xcolor); fontPtr->color.color.red = xcolor.red; fontPtr->color.color.green = xcolor.green; fontPtr->color.color.blue = xcolor.blue; fontPtr->color.color.alpha = 0xffff; fontPtr->color.pixel = values.foreground; } nspec = 0; while (numBytes > 0 && x <= maxCoord && y <= maxCoord) { XftFont *ftFont; FcChar32 c; clen = FcUtf8ToUcs4((FcChar8 *) source, &c, numBytes); if (clen <= 0) { /* * This should not happen, but it can. */ return; } source += clen; numBytes -= clen; ftFont = GetFont(fontPtr, c); if (ftFont) { specs[nspec].font = ftFont; specs[nspec].glyph = XftCharIndex(fontPtr->display, ftFont, c); specs[nspec].x = x; specs[nspec].y = y; XftGlyphExtents(fontPtr->display, ftFont, &specs[nspec].glyph, 1, &metrics); x += metrics.xOff; y += metrics.yOff; nspec++; if (nspec == NUM_SPEC) { XftDrawGlyphFontSpec(fontPtr->ftDraw, &fontPtr->color, specs, nspec); nspec = 0; } } } if (nspec) { XftDrawGlyphFontSpec(fontPtr->ftDraw, &fontPtr->color, specs, nspec); } }
void initializeWindowSystem(void) { char *display_name = NULL; XColor fg, bg; #if 0 XColor rgbdef; #endif Colormap cmap; Pixmap mousebits, mousemask; /* fprintf(stderr,"initx:initializeWindowSystem:entered\n");*/ /* Try to open the display */ /* fprintf(stderr,"initx:initializeWindowSystem:XOpenDisplay\n");*/ if ((gXDisplay = XOpenDisplay(display_name)) == NULL) { fprintf(stderr, "(HyperDoc) Cannot connect to the X11 server!\n"); exit(-1); } /* Get the screen */ /* fprintf(stderr,"initx:initializeWindowSystem:DefaultScreen\n");*/ gXScreenNumber = scrn = DefaultScreen(gXDisplay); /* fprintf(stderr,"initx:initializeWindowSystem:XGContextFromGC\n");*/ server_font =XGContextFromGC(DefaultGC(gXDisplay, gXScreenNumber)); /* Get the cursors we need. */ /* fprintf(stderr,"initx:initializeWindowSystem:DefaultColormap\n");*/ cmap = DefaultColormap(gXDisplay, gXScreenNumber); /* fprintf(stderr,"initx:initializeWindowSystem:WhitePixel\n");*/ fg.pixel = WhitePixel(gXDisplay,gXScreenNumber); /* fprintf(stderr,"initx:initializeWindowSystem:XQueryColor\n");*/ XQueryColor(gXDisplay, cmap, &fg ); /* fprintf(stderr,"initx:initializeWindowSystem:BlackPixel\n");*/ bg.pixel = BlackPixel(gXDisplay,gXScreenNumber); /* fprintf(stderr,"initx:initializeWindowSystem:XQueryColor2\n");*/ XQueryColor(gXDisplay, cmap, &bg ); #if 0 XAllocNamedColor(gXDisplay, cmap, "Black", &fg, &rgbdef); XAllocNamedColor(gXDisplay, cmap, "White", &bg, &rgbdef); #endif #ifdef USE_BORING_OLD_CURSORS gActiveCursor = XCreateFontCursor(gXDisplay, XC_circle); gNormalCursor = XCreateFontCursor(gXDisplay, XC_dot); #else /* fprintf(stderr,"initx:initializeWindowSystem:XCreateBitmapFromData 1\n");*/ mousebits = XCreateBitmapFromData(gXDisplay, RootWindow(gXDisplay, gXScreenNumber), mouseBitmap_bits, mouseBitmap_width,mouseBitmap_height); /* fprintf(stderr,"initx:initializeWindowSystem:XCreateBitmapFromData 2\n");*/ mousemask = XCreateBitmapFromData(gXDisplay, RootWindow(gXDisplay, gXScreenNumber), mouseMask_bits, mouseMask_width,mouseMask_height); /* fprintf(stderr,"initx:initializeWindowSystem:XCreateBitmapFromData 2\n");*/ gActiveCursor = XCreatePixmapCursor(gXDisplay, mousebits, mousemask, &fg, &bg, mouseBitmap_x_hot,mouseBitmap_y_hot); /* fprintf(stderr,"initx:initializeWindowSystem:XCreateFontCursor\n");*/ gNormalCursor = XCreateFontCursor(gXDisplay, XC_left_ptr); #endif /* fprintf(stderr,"initx:initializeWindowSystem:XCreateFontCursor 2\n");*/ gBusyCursor = XCreateFontCursor(gXDisplay, XC_watch); /* Now initialize all the colors and fonts */ /* fprintf(stderr,"initx:initializeWindowSystem:ingItColors_and_fonts\n");*/ ingItColors_and_fonts(); /* fprintf(stderr,"initx:initializeWindowSystem:init_text\n");*/ init_text(); /* fprintf(stderr,"initx:initializeWindowSystem:exited\n");*/ }
int main() { #ifdef TEST_FOR_X Display *display; Window window; GC gc; XGCValues gcValues; Colormap colormap; Pixmap src_pixmap; unsigned long fgColor, bgColor; int screenNum; XPoint points[NUM_POINTS]; #else GR_WINDOW_ID window; GR_WINDOW_ID src_pixmap; unsigned char* src_pixmap_buf[320*240*2]; GR_GC_ID gc; GR_POINT points[NUM_POINTS]; #endif int c, c1, count=4500; int x, y, x1, y1, x2, y2; #ifdef TEST_FOR_X if(!(display=XOpenDisplay(""))) { printf("Cannot connect to X.\n"); } screenNum = DefaultScreen(display); colormap = DefaultColormap(display, screenNum); bgColor = BlackPixel(display, screenNum); fgColor = WhitePixel(display, screenNum); window = XCreateSimpleWindow(display, RootWindow(display, screenNum), 0, 0 , 639, 479, 0, fgColor, bgColor); src_pixmap = XCreatePixmap(display, window, 320, 240, 16); XMapRaised(display, window); gcValues.background = bgColor; gcValues.foreground = fgColor; gcValues.line_width = 1; gcValues.line_style = LineSolid; gcValues.fill_style = FillSolid; gcValues.fill_rule = WindingRule; gcValues.arc_mode = ArcPieSlice; gc = XCreateGC(display, window, GCForeground | GCBackground | GCLineWidth | GCLineStyle | GCFillStyle, &gcValues); #else GrOpen(); window = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, 639, 479, 0, BLACK, BLUE); src_pixmap = GrNewPixmap(640, 480, src_pixmap_buf); GrMapWindow(window); gc = GrNewGC(); GrSetGCForeground(gc, WHITE); GrSetGCBackground(gc, BLACK); GrSetGCMode(gc, GR_MODE_COPY); #endif // Horizontal Line //////////////////////////////////////////////// printf("Horizontal Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*20; c++) { y1=random()%480; #ifdef TEST_FOR_X XDrawLine(display, window, gc, 0, y1, 639, y1); XFlush(display); #else GrLine(window, gc, 0, y1, 639, y1); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Vertical Line ///////////////////////////////////////////////// printf("Vertical Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*19; c++) { x1=random()%640; #ifdef TEST_FOR_X XDrawLine(display, window, gc, x1, 0, x1, 479); XFlush(display); #else GrLine(window, gc, x1, 0, x1, 479); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // General Line ///////////////////////////////////////////////// printf("General Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*22; c++) { x1 = random()%640; x2 = random()%640; y1 = random()%480; y2 = random()%480; #ifdef TEST_FOR_X XDrawLine(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrLine(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Point ////////////////////////////////////////////////// printf("XPoint\n"); start_timer(); for(c=0; c<count*25; c++) { x1 = random()%640; y1 = random()%480; #ifdef TEST_FOR_X XDrawPoint(display, window, gc, x1, y1); XFlush(display); #else GrPoint(window, gc, x1, y1); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Rectangle ////////////////////////////////////////////////// printf("XRectangle\n"); start_timer(); for(c=0; c<count*20; c++) { x1=random()%639; y1=random()%479; x2=random()%(639-x1)+1; y2=random()%(479-y1)+1; #ifdef TEST_FOR_X XDrawRectangle(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrRect(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // FillRectangle ////////////////////////////////////////////////// printf("XFillRectangle\n"); start_timer(); for(c=0; c<count*18; c++) { x1=random()%639; y1=random()%479; x2=random()%(639-x1)+1; y2=random()%(479-y1)+1; #ifdef TEST_FOR_X XFillRectangle(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrFillRect(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // FillPolygon ////////////////////////////////////////////////// printf("XFillPolygon\n"); start_timer(); for(c=0; c<count; c++) { for(c1=0; c1<NUM_POINTS; c1++) { points[c1].x = random()%640; points[c1].y = random()%480; } #ifdef TEST_FOR_X XFillPolygon(display, window, gc, points, NUM_POINTS, 0, 0); XFlush(display); #else GrFillPoly(window, gc, NUM_POINTS, points); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // CopyArea ///////////////////////////////////////////////// printf("XCopyArea\n"); start_timer(); for(c=0; c<count*5; c++) { x1=random()%320; y1=random()%240; x2=random()%319+1; y2=random()%239+1; #ifdef TEST_FOR_X XCopyArea(display, src_pixmap, window, gc, 0, 0, x2, y2, x1, y1); XFlush(display); #else GrCopyArea(window, gc, x1, y1, x2 ,y2, src_pixmap, 0, 0, 0); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XDestroyWindow(display, window); #else GrClose(); #endif }
GuiCalibratorX11::GuiCalibratorX11(Calibrator* calibrator0) : calibrator(calibrator0), time_elapsed(0) { display = XOpenDisplay(NULL); if (display == NULL) { throw std::runtime_error("Unable to connect to X server"); } screen_num = DefaultScreen(display); // Load font and get font information structure font_info = XLoadQueryFont(display, "9x15"); if (font_info == NULL) { // fall back to native font font_info = XLoadQueryFont(display, "fixed"); if (font_info == NULL) { XCloseDisplay(display); throw std::runtime_error("Unable to open neither '9x15' nor 'fixed' font"); } } #ifdef HAVE_X11_XRANDR // get screensize from xrandr int nsizes; XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes); if (nsizes != 0) { set_display_size(randrsize->width, randrsize->height); } else { set_display_size(DisplayWidth(display, screen_num), DisplayHeight(display, screen_num)); } # else set_display_size(DisplayWidth(display, screen_num), DisplayHeight(display, screen_num)); #endif // Register events on the window XSetWindowAttributes attributes; attributes.override_redirect = True; attributes.event_mask = ExposureMask | KeyPressMask | ButtonPressMask; win = XCreateWindow(display, RootWindow(display, screen_num), 0, 0, display_width, display_height, 0, CopyFromParent, InputOutput, CopyFromParent, CWOverrideRedirect | CWEventMask, &attributes); XMapWindow(display, win); // Listen to events XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime); calib_input = calibrator->register_events(); if (!calib_input) { XGrabPointer(display, win, False, ButtonPressMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); } Colormap colormap = DefaultColormap(display, screen_num); XColor color; for (int i = 0; i != nr_colors; i++) { XParseColor(display, colormap, colors[i], &color); XAllocColor(display, colormap, &color); pixel[i] = color.pixel; } XSetWindowBackground(display, win, pixel[GRAY]); XClearWindow(display, win); gc = XCreateGC(display, win, 0, NULL); XSetFont(display, gc, font_info->fid); // Setup timer for animation signal(SIGALRM, sigalarm_handler); struct itimerval timer; timer.it_value.tv_sec = time_step/1000; timer.it_value.tv_usec = (time_step % 1000) * 1000; timer.it_interval = timer.it_value; setitimer(ITIMER_REAL, &timer, NULL); }
int main (int argc, char **argv) { Cursor cursor; Display *display; Window root, blub, *blubs = NULL; unsigned clients; unsigned long pixel; char *cname; XColor color; int cnt; Atom prop; Pixmap save_pixmap = (Pixmap)None; display = XOpenDisplay(NULL); if(!display) return 1; cname = argc == 2 ? argv[1] : "black"; screen = DefaultScreen(display); root = RootWindow(display, screen); pixel = BlackPixel(display, screen); if(XParseColor(display, DefaultColormap(display, screen), cname, &color)) { if(XAllocColor(display, DefaultColormap(display, screen), &color)) { pixel = color.pixel; } } XSetWindowBackground(display, root, pixel); XClearWindow(display, root); cursor = CreateCursorFromName(display,"watch"); if (cursor) { XDefineCursor (display, root, cursor); XFreeCursor (display, cursor); } if (fork() == 0) { Window win; XEvent xev; close(0); close(1); close(2); chdir("/"); display = XOpenDisplay(NULL); // open a client... if (display) { win = XCreateSimpleWindow ( display, root, 0, 0, 1, 1, 0, 0, pixel ); XSync(display, False); } // wait within event loop... for(;;) XNextEvent(display, &xev); } // wait until the child has opened a client cnt = 100; do { if (!XQueryTree (display, root, &blub, &blub, &blubs, &clients)) { XCloseDisplay(display); return 0; } usleep(50000); } while(clients < 1 && cnt--); save_pixmap = XCreatePixmap (display, root, 1, 1, 1); prop = XInternAtom (display, "_XSETROOT_ID", False); XChangeProperty ( display, root, prop, XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &save_pixmap, 1 ); XSetCloseDownMode (display, RetainPermanent); // enable accessX // XAccess (display,NULL); XCloseDisplay(display); RunWindowManager(); return 0; }
int Init_X (int swidth, int sheight) { XGCValues vals; Colormap TheColormap; XColor TheColor; int i; TheWidth = swidth ; TheHeight = sheight ; TheDisplay = XOpenDisplay("\0"); TheRootWindow = DefaultRootWindow(TheDisplay); TheScreenNumber = DefaultScreen(TheDisplay); TheDepth = DefaultDepth(TheDisplay, TheScreenNumber); if (TheDepth != 24) { printf("24 bit color not supported.\n") ; printf("Color function not likely to work.\n") ; } TheWindow = XCreateSimpleWindow(TheDisplay, TheRootWindow, 0, 0, TheWidth, TheHeight, 0, 0, 0); if (!TheWindow) return 0 ; ThePixmap = XCreatePixmap(TheDisplay, TheRootWindow, TheWidth, TheHeight, TheDepth); if (!ThePixmap) return 0 ; TheDrawable = ThePixmap; XMapWindow(TheDisplay, TheWindow); XSelectInput(TheDisplay, TheWindow, ExposureMask | StructureNotifyMask | PointerMotionMask | ButtonPressMask | KeyPressMask ); /* TheWindowContext = XCreateGC(TheDisplay, TheWindow, 0, 0); // this is a bad idea ... see test t02.c for an example // of what can happen to the behavior of the event handler, // int Handle_Events_X(int *px, int *py) // if you do this, you'll get runaway calls to Handle_Events // with the default condition being met and this produces // a great deal of tearing in the animation of t02.c */ /* also a bad idea...same behavior as above vals.graphics_exposures = 1; // True */ // so this is what you want : vals.graphics_exposures = 0; // False TheWindowContext = XCreateGC(TheDisplay, TheWindow, GCGraphicsExposures, &vals); if (!TheWindowContext) return 0; ThePixmapContext = XCreateGC(TheDisplay, ThePixmap, 0, 0); if (!ThePixmapContext) return 0; TheColormap = DefaultColormap(TheDisplay, TheScreenNumber); for(i = 0; i < 256; i++) { TheColor.green = TheColor.blue = TheColor.red = (i << 8) | i; TheColor.flags = DoRed | DoGreen | DoBlue; XAllocColor(TheDisplay, TheColormap, &TheColor); Grays[i] = TheColor.pixel; } TheFontInfo = XLoadQueryFont(TheDisplay, TheFont) ; XSetFont(TheDisplay, TheWindowContext, TheFontInfo->fid) ; // XClearWindow(TheDisplay, TheWindow); // XClearArea(TheDisplay, TheWindow, 0,0,0,0,False); // same as above XClearArea(TheDisplay, TheWindow, 0,0,0,0,True); // Does the boolean matter here? // most people expect a white piece of paper // with a black pencil Set_Color_Rgb_X (255,255,255) ; // white Clear_Buffer_X() ; // otherwise you can inherit garbage // from the parent window // Set_Color_Rgb_X (255,0,255) ; // purple // Fill_Rectangle_X(10,10,50,80) ; // above was just a test Copy_Buffer_X() ; XFlush(TheDisplay); // XSync(TheDisplay, False) ; // seems unnecessary Set_Color_Rgb_X (0,0,0) ; // black pencil return 1 ; }
XImage * read_ppm_file(Display *disp, Colormap cmap, int depth, IOSTREAM *fd) { XImage *img; long here = Stell(fd); int c; int fmt, encoding; int width, height, bytes_per_line, scale=0; char *data; int allocdepth; int pad = XBitmapPad(disp); Visual *v = DefaultVisual(disp, DefaultScreen(disp)); ncolours = nmapped = nfailed = 0; /* statistics */ assert(pad%8 == 0); if ( (c=Sgetc(fd)) != 'P' ) { Sungetc(c, fd); return NULL; } if ( !cmap ) cmap = DefaultColormap(disp, DefaultScreen(disp)); c = Sgetc(fd); if ( c < '1' || c > '9' ) goto errout; c -= '0'; fmt = ((c - 1) % 3) + 1; encoding = c - fmt; width = getNum(fd); height = getNum(fd); if ( fmt == PNM_PBM ) { depth = 1; } else { scale = getNum(fd); if ( !depth ) depth = DefaultDepth(disp, DefaultScreen(disp)); } if ( width < 0 || height < 0 || scale < 0 ) goto errout; allocdepth = (depth >= 24 ? 32 : depth); bytes_per_line = roundup((width*allocdepth+7)/8, pad/8); data = (char *)pceMalloc(height * bytes_per_line); img = XCreateImage(disp, v, depth, fmt == PNM_PBM ? XYBitmap : ZPixmap, 0, data, width, height, pad, bytes_per_line); if ( !img ) { perror("XCreateImage"); pceFree(data); goto errout; } img->bits_per_pixel = depth; switch(encoding) { int x, y; case PNM_ASCII: { switch(fmt) { case PNM_PBM: for(y=0; y<height; y++) { for(x=0; x<width; x++) { int value = getNum(fd); if ( value < 0 || value > 1 ) goto errout; XPutPixel(img, x, y, value); } } break; case PNM_PGM: { Table t = newTable(64); for(y=0; y<height; y++) { for(x=0; x<width; x++) { int g = getNum(fd); unsigned long pixel; if ( g < 0 || g > scale ) goto errout; if ( scale != 255 ) g = rescale(g, scale, 255); pixel = colourPixel(disp, depth, cmap, t, g, g, g); XPutPixel(img, x, y, pixel); } } freeTable(t); break; } case PNM_PPM: { Table t = newTable(64); for(y=0; y<height; y++) { for(x=0; x<width; x++) { int r = getNum(fd); int g = getNum(fd); int b = getNum(fd); unsigned long pixel; if ( r < 0 || r > scale || g < 0 || g > scale || b < 0 || b > scale ) goto errout; if ( scale != 255 ) { r = rescale(r, scale, 255); g = rescale(g, scale, 255); b = rescale(b, scale, 255); } pixel = colourPixel(disp, depth, cmap, t, r, g, b); XPutPixel(img, x, y, pixel); } } freeTable(t); break; } break; } break; } case PNM_RAWBITS: { switch(fmt) { case PNM_PBM: { int byte = 0; int bit = 0; for(y=0; y<height; y++) { for(x=0; x<width; x++) { if ( !bit ) { byte = Sgetc(fd); bit = 8; } bit--; XPutPixel(img, x, y, (byte & (1<<bit)) ? 1 : 0); } bit = 0; /* scanlines are byte-aligned */ } break; } case PNM_PGM: { Table t = newTable(64); for(y=0; y<height; y++) { for(x=0; x<width; x++) { int g; unsigned long pixel; if ( Sfeof(fd) || (g=Sgetc(fd)) > scale ) goto errout; if ( scale != 255 ) g = rescale(g, scale, 255); pixel = colourPixel(disp, depth, cmap, t, g, g, g); XPutPixel(img, x, y, pixel); } } freeTable(t); break; } case PNM_PPM: { Table t = newTable(64); for(y=0; y<height; y++) { for(x=0; x<width; x++) { int r, g, b; unsigned long pixel; if ( Sfeof(fd) || (r=Sgetc(fd)) > scale || (g=Sgetc(fd)) > scale || (b=Sgetc(fd)) > scale ) goto errout; if ( scale != 255 ) { r = rescale(r, scale, 255); g = rescale(g, scale, 255); b = rescale(b, scale, 255); } pixel = colourPixel(disp, depth, cmap, t, r, g, b); XPutPixel(img, x, y, pixel); } } freeTable(t); break; } break; } break; } case PNM_RUNLEN: { int rlen = 0; unsigned long cpixel = NOPIXEL; switch(fmt) { case PNM_PGM: { Table t = newTable(64); DEBUG(NAME_pnm, Cprintf("Reading runlength encoded graymap\n")); for(y=0; y<height; y++) { for(x=0; x<width; x++) { if ( rlen-- > 0 ) { XPutPixel(img, x, y, cpixel); } else { int g; if ( (g=Sgetc(fd)) > scale || (rlen = Sgetc(fd)) == EOF ) goto errout; rlen &= 0xff; if ( scale != 255 ) g = rescale(g, scale, 255); cpixel = colourPixel(disp, depth, cmap, t, g, g, g); XPutPixel(img, x, y, cpixel); rlen--; } } } freeTable(t); break; } case PNM_PPM: { Table t = newTable(64); for(y=0; y<height; y++) { for(x=0; x<width; x++) { if ( rlen-- > 0 ) { XPutPixel(img, x, y, cpixel); } else { int r, g, b; if ( (r=Sgetc(fd)) > scale || (g=Sgetc(fd)) > scale || (b=Sgetc(fd)) > scale || (rlen = Sgetc(fd)) == EOF ) goto errout; rlen &= 0xff; if ( scale != 255 ) { r = rescale(r, scale, 255); g = rescale(g, scale, 255); b = rescale(b, scale, 255); } cpixel = colourPixel(disp, depth, cmap, t, r, g, b); XPutPixel(img, x, y, cpixel); rlen--; } } } freeTable(t); break; } } } } DEBUG(NAME_ppm, Cprintf("PNM: Converted %dx%dx%d image, %d colours (%d mapped, %d failed)\n", width, height, depth, ncolours, nmapped, nfailed)); return img; errout: DEBUG(NAME_ppm, Cprintf("PNM: Format error, index = %d\n", Stell(fd))); Sseek(fd, here, SEEK_SET); return NULL; }
stk_widget *stk_progress_bar_new(stk_widget *parent_win, int x, int y, uint w, uint h, char *label) { stk_widget *new_pb = (stk_widget*) malloc(sizeof(stk_widget)); stk_progress_bar *pb = (stk_progress_bar*) malloc(sizeof(stk_progress_bar)); int screen; XGCValues gcval; long fg, bg; memset(new_pb, 0, sizeof(stk_widget)); new_pb->dsp = display; new_pb->fontname = "7x13"; screen = DefaultScreen(new_pb->dsp); fg = BlackPixel(new_pb->dsp, screen); bg = WhitePixel(new_pb->dsp, screen); gcval.foreground = fg; gcval.background = bg; new_pb->gc2 = XCreateGC(new_pb->dsp, parent_win->win, GCForeground | GCBackground, &gcval); if(new_pb->dsp) { new_pb->win = XCreateSimpleWindow(new_pb->dsp, parent_win->win, x, y, w, h, 1, fg, bg); new_pb->gc = XCreateGC(new_pb->dsp, new_pb->win, 0, 0); new_pb->font_info = XLoadQueryFont(new_pb->dsp, new_pb->fontname); if(new_pb->fontname != NULL) XSetFont(display, new_pb->gc2, new_pb->font_info->fid); else perror("XLoadQueryFont"); new_pb->mask = ExposureMask | EnterWindowMask | LeaveWindowMask | ButtonPressMask | ButtonReleaseMask; XSelectInput(new_pb->dsp, new_pb->win, new_pb->mask); if(DisplayPlanes(new_pb->dsp, screen) != 1) { pb->cmap = DefaultColormap(new_pb->dsp, screen); if(XAllocNamedColor(new_pb->dsp, pb->cmap, "red", &pb->color, &pb->colorrgb)) XSetForeground(new_pb->dsp, new_pb->gc, pb->color.pixel); } XMapWindow(new_pb->dsp, new_pb->win); memset(pb, 0, sizeof(stk_progress_bar)); new_pb->x = x; new_pb->y = y; new_pb->w = w; new_pb->h = h; new_pb->handler = &stk_progress_bar_handle; pb->pct = 0; new_pb->ext_struct = (void*)pb; if(label) strcpy(pb->label, label); else new_pb->label = NULL; stk_widget_insert((void*)new_pb); return new_pb; } else return NULL; }
/* PROGRAM EXECUTION BEGINS HERE */ int main(int argc, char** argv) { /** Declare variables **/ /* People */ int total_number_of_people = 50; int total_num_initially_infected = 1; int total_num_infected = 1; int our_number_of_people = 50; int our_person1 = 0; int our_current_infected_person = 0; int our_num_initially_infected = 1; int our_num_infected = 0; int our_current_location_x = 0; int our_current_location_y = 0; int our_num_susceptible = 0; int our_num_immune = 0; int our_num_dead = 0; int my_current_person_id = 0; int my_num_infected_nearby = 0; int my_person2 = 0; /* Environment */ int environment_width = 30; int environment_height = 30; /* Disease */ int infection_radius = 3; int duration_of_disease = 50; int contagiousness_factor = 30; int deadliness_factor = 30; #ifdef SHOW_RESULTS double our_num_infections = 0.0; double our_num_infection_attempts = 0.0; double our_num_deaths = 0.0; double our_num_recovery_attempts = 0.0; #endif /* Time */ int total_number_of_days = 250; int our_current_day = 0; int microseconds_per_day = 100000; /* Movement */ int my_x_move_direction = 0; int my_y_move_direction = 0; /* Distributed Memory Information */ int total_number_of_processes = 1; int our_rank = 0; //#ifdef MPI // int current_rank = 0; // int current_displ = 0; //#endif /* getopt */ int c = 0; /* Integer arrays, a.k.a. integer pointers */ int *x_locations; int *y_locations; int *our_x_locations; int *our_y_locations; int *our_infected_x_locations; int *our_infected_y_locations; int *their_infected_x_locations; int *their_infected_y_locations; int *our_num_days_infected; int *recvcounts; int *displs; /* Character arrays, a.k.a. character pointers */ char *states; char *our_states; #ifdef TEXT_DISPLAY /* Array of character arrays, a.k.a. array of character pointers, for text * display */ char **environment; #endif #ifdef X_DISPLAY /* Declare X-related variables */ Display *display; Window window; int screen; Atom delete_window; GC gc; XColor infected_color; XColor immune_color; XColor susceptible_color; XColor dead_color; Colormap colormap; char red[] = "#FF0000"; char green[] = "#00FF00"; char black[] = "#000000"; char white[] = "#FFFFFF"; #endif //#ifdef MPI /* Each process initializes the distributed memory environment */ //MPI_Init(&argc, &argv); //#endif /* ALG I: Each process determines its rank and the total number of processes */ //#ifdef MPI // MPI_Comm_rank(MPI_COMM_WORLD, &our_rank); // MPI_Comm_size(MPI_COMM_WORLD, &total_number_of_processes); //#else our_rank = 0; total_number_of_processes = 1; //#endif /* ALG II: Each process is given the parameters of the simulation */ /* Get command line options -- this follows the idiom presented in the * getopt man page (enter 'man 3 getopt' on the shell for more) */ while((c = getopt(argc, argv, "n:i:w:h:t:T:c:d:D:m:")) != -1) { switch(c) { case 'n': total_number_of_people = atoi(optarg); break; case 'i': total_num_initially_infected = atoi(optarg); break; case 'w': environment_width = atoi(optarg); break; case 'h': environment_height = atoi(optarg); break; case 't': total_number_of_days = atoi(optarg); break; case 'T': duration_of_disease = atoi(optarg); break; case 'c': contagiousness_factor = atoi(optarg); break; case 'd': infection_radius = atoi(optarg); break; case 'D': deadliness_factor = atoi(optarg); break; case 'm': microseconds_per_day = atoi(optarg); break; /* If the user entered "-?" or an unrecognized option, we need * to print a usage message before exiting. */ case '?': default: fprintf(stderr, "Usage: "); //#ifdef MPI // fprintf(stderr, "mpirun -np total_number_of_processes "); //#endif fprintf(stderr, "%s [-n total_number_of_people][-i total_num_initially_infected][-w environment_width][-h environment_height][-t total_number_of_days][-T duration_of_disease][-c contagiousness_factor][-d infection_radius][-D deadliness_factor][-m microseconds_per_day]\n", argv[0]); exit(-1); } } argc -= optind; argv += optind; /* ALG III: Each process makes sure that the total number of initially * infected people is less than the total number of people */ if(total_num_initially_infected > total_number_of_people) { fprintf(stderr, "ERROR: initial number of infected (%d) must be less than total number of people (%d)\n", total_num_initially_infected, total_number_of_people); exit(-1); } /* ALG IV: Each process determines the number of people for which it is * responsible */ our_number_of_people = total_number_of_people / total_number_of_processes; /* ALG V: The last process is responsible for the remainder */ if(our_rank == total_number_of_processes - 1) { our_number_of_people += total_number_of_people % total_number_of_processes; } /* ALG VI: Each process determines the number of initially infected people * for which it is responsible */ our_num_initially_infected = total_num_initially_infected / total_number_of_processes; /* ALG VII: The last process is responsible for the remainder */ if(our_rank == total_number_of_processes - 1) { our_num_initially_infected += total_num_initially_infected % total_number_of_processes; } /* Allocate the arrays */ x_locations = (int*)malloc(total_number_of_people * sizeof(int)); y_locations = (int*)malloc(total_number_of_people * sizeof(int)); our_x_locations = (int*)malloc(our_number_of_people * sizeof(int)); our_y_locations = (int*)malloc(our_number_of_people * sizeof(int)); our_infected_x_locations = (int*)malloc(our_number_of_people * sizeof(int)); our_infected_y_locations = (int*)malloc(our_number_of_people * sizeof(int)); their_infected_x_locations = (int*)malloc(total_number_of_people * sizeof(int)); their_infected_y_locations = (int*)malloc(total_number_of_people * sizeof(int)); our_num_days_infected = (int*)malloc(our_number_of_people * sizeof(int)); recvcounts = (int*)malloc(total_number_of_processes * sizeof(int)); displs = (int*)malloc(total_number_of_processes * sizeof(int)); states = (char*)malloc(total_number_of_people * sizeof(char)); our_states = (char*)malloc(our_number_of_people * sizeof(char)); #ifdef TEXT_DISPLAY environment = (char**)malloc(environment_width * environment_height * sizeof(char*)); for(our_current_location_x = 0; our_current_location_x <= environment_width - 1; our_current_location_x++) { environment[our_current_location_x] = (char*)malloc(environment_height * sizeof(char)); } #endif /* ALG VIII: Each process seeds the random number generator based on the * current time */ srandom(time(NULL)); /* ALG IX: Each process spawns threads to set the states of the initially * infected people and set the count of its infected people */ #pragma omp parallel for private(my_current_person_id) \ reduction(+:our_num_infected) for(my_current_person_id = 0; my_current_person_id <= our_num_initially_infected - 1; my_current_person_id++) { our_states[my_current_person_id] = INFECTED; our_num_infected++; } /* ALG X: Each process spawns threads to set the states of the rest of its * people and set the count of its susceptible people */ #pragma omp parallel for private(my_current_person_id) \ reduction(+:our_num_susceptible) for(my_current_person_id = our_num_initially_infected; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { our_states[my_current_person_id] = SUSCEPTIBLE; our_num_susceptible++; } /* ALG XI: Each process spawns threads to set random x and y locations for * each of its people */ #pragma omp parallel for private(my_current_person_id) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { our_x_locations[my_current_person_id] = random() % environment_width; our_y_locations[my_current_person_id] = random() % environment_height; } /* ALG XII: Each process spawns threads to initialize the number of days * infected of each of its people to 0 */ #pragma omp parallel for private(my_current_person_id) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { our_num_days_infected[my_current_person_id] = 0; } /* ALG XIII: Rank 0 initializes the graphics display */ #ifdef X_DISPLAY if(our_rank == 0) { /* Initialize the X Windows Environment * This all comes from * http://en.wikibooks.org/wiki/X_Window_Programming/XLib * http://tronche.com/gui/x/xlib-tutorial * http://user.xmission.com/~georgeps/documentation/tutorials/ * Xlib_Beginner.html */ /* Open a connection to the X server */ display = XOpenDisplay(NULL); if(display == NULL) { fprintf(stderr, "Error: could not open X display\n"); } screen = DefaultScreen(display); window = XCreateSimpleWindow(display, RootWindow(display, screen), 0, 0, environment_width * PIXEL_WIDTH_PER_PERSON, environment_height * PIXEL_HEIGHT_PER_PERSON, 1, BlackPixel(display, screen), WhitePixel(display, screen)); delete_window = XInternAtom(display, "WM_DELETE_WINDOW", 0); XSetWMProtocols(display, window, &delete_window, 1); XSelectInput(display, window, ExposureMask | KeyPressMask); XMapWindow(display, window); colormap = DefaultColormap(display, 0); gc = XCreateGC(display, window, 0, 0); XParseColor(display, colormap, red, &infected_color); XParseColor(display, colormap, green, &immune_color); XParseColor(display, colormap, white, &dead_color); XParseColor(display, colormap, black, &susceptible_color); XAllocColor(display, colormap, &infected_color); XAllocColor(display, colormap, &immune_color); XAllocColor(display, colormap, &susceptible_color); XAllocColor(display, colormap, &dead_color); } #endif /* ALG XIV: Each process starts a loop to run the simulation for the * specified number of days */ for(our_current_day = 0; our_current_day <= total_number_of_days - 1; our_current_day++) { /* ALG XIV.A: Each process determines its infected x locations and * infected y locations */ our_current_infected_person = 0; for(our_person1 = 0; our_person1 <= our_number_of_people - 1; our_person1++) { if(our_states[our_person1] == INFECTED) { our_infected_x_locations[our_current_infected_person] = our_x_locations[our_person1]; our_infected_y_locations[our_current_infected_person] = our_y_locations[our_person1]; our_current_infected_person++; } } //#ifdef MPI /* ALG XIV.B: Each process sends its count of infected people to all the * other processes and receives their counts */ // MPI_Allgather(&our_num_infected, 1, MPI_INT, recvcounts, 1, // MPI_INT, MPI_COMM_WORLD); // total_num_infected = 0; // for(current_rank = 0; current_rank <= total_number_of_processes - 1; // current_rank++) // { // total_num_infected += recvcounts[current_rank]; // } /* Set up the displacements in the receive buffer (see the man page for * MPI_Allgatherv) */ // current_displ = 0; // for(current_rank = 0; current_rank <= total_number_of_processes - 1; // current_rank++) // { // displs[current_rank] = current_displ; // current_displ += recvcounts[current_rank]; // } /* ALG XIV.C: Each process sends the x locations of its infected people * to all the other processes and receives the x locations of their * infected people */ // MPI_Allgatherv(our_infected_x_locations, our_num_infected, MPI_INT, // their_infected_x_locations, recvcounts, displs, // MPI_INT, MPI_COMM_WORLD); /* ALG XIV.D: Each process sends the y locations of its infected people * to all the other processes and receives the y locations of their * infected people */ // MPI_Allgatherv(our_infected_y_locations, our_num_infected, MPI_INT, // their_infected_y_locations, recvcounts, displs, // MPI_INT, MPI_COMM_WORLD); //#else total_num_infected = our_num_infected; for(my_current_person_id = 0; my_current_person_id <= total_num_infected - 1; my_current_person_id++) { their_infected_x_locations[my_current_person_id] = our_infected_x_locations[my_current_person_id]; their_infected_y_locations[my_current_person_id] = our_infected_y_locations[my_current_person_id]; } //#endif #if defined(X_DISPLAY) || defined(TEXT_DISPLAY) /* ALG XIV.E: If display is enabled, Rank 0 gathers the states, x * locations, and y locations of the people for which each process is * responsible */ //#ifdef MPI /* Set up the receive counts and displacements in the receive buffer * (see the man page for MPI_Gatherv) */ // current_displ = 0; // for(current_rank = 0; current_rank <= total_number_of_processes - 1; // current_rank++) // { // displs[current_rank] = current_displ; // recvcounts[current_rank] = total_number_of_people // / total_number_of_processes; // if(current_rank == total_number_of_processes - 1) // { // recvcounts[current_rank] += total_number_of_people // % total_number_of_processes; // } // current_displ += recvcounts[current_rank]; // } // MPI_Gatherv(our_states, our_number_of_people, MPI_CHAR, states, // recvcounts, displs, MPI_CHAR, 0, MPI_COMM_WORLD); // MPI_Gatherv(our_x_locations, our_number_of_people, MPI_INT, x_locations, // recvcounts, displs, MPI_INT, 0, MPI_COMM_WORLD); // MPI_Gatherv(our_y_locations, our_number_of_people, MPI_INT, y_locations, // recvcounts, displs, MPI_INT, 0, MPI_COMM_WORLD); //#else #pragma omp parallel for private(my_current_person_id) for(my_current_person_id = 0; my_current_person_id <= total_number_of_people - 1; my_current_person_id++) { states[my_current_person_id] = our_states[my_current_person_id]; x_locations[my_current_person_id] = our_x_locations[my_current_person_id]; y_locations[my_current_person_id] = our_y_locations[my_current_person_id]; } //#endif #endif /* ALG XIV.F: If display is enabled, Rank 0 displays a graphic of the * current day */ #ifdef X_DISPLAY if(our_rank == 0) { XClearWindow(display, window); for(my_current_person_id = 0; my_current_person_id <= total_number_of_people - 1; my_current_person_id++) { if(states[my_current_person_id] == INFECTED) { XSetForeground(display, gc, infected_color.pixel); } else if(states[my_current_person_id] == IMMUNE) { XSetForeground(display, gc, immune_color.pixel); } else if(states[my_current_person_id] == SUSCEPTIBLE) { XSetForeground(display, gc, susceptible_color.pixel); } else if(states[my_current_person_id] == DEAD) { XSetForeground(display, gc, dead_color.pixel); } else { fprintf(stderr, "ERROR: person %d has state '%c'\n", my_current_person_id, states[my_current_person_id]); exit(-1); } XFillRectangle(display, window, gc, x_locations[my_current_person_id] * PIXEL_WIDTH_PER_PERSON, y_locations[my_current_person_id] * PIXEL_HEIGHT_PER_PERSON, PIXEL_WIDTH_PER_PERSON, PIXEL_HEIGHT_PER_PERSON); } XFlush(display); } #endif #ifdef TEXT_DISPLAY if(our_rank == 0) { for(our_current_location_y = 0; our_current_location_y <= environment_height - 1; our_current_location_y++) { for(our_current_location_x = 0; our_current_location_x <= environment_width - 1; our_current_location_x++) { environment[our_current_location_x][our_current_location_y] = ' '; } } for(my_current_person_id = 0; my_current_person_id <= total_number_of_people - 1; my_current_person_id++) { environment[x_locations[my_current_person_id]] [y_locations[my_current_person_id]] = states[my_current_person_id]; } printf("----------------------\n"); for(our_current_location_y = 0; our_current_location_y <= environment_height - 1; our_current_location_y++) { for(our_current_location_x = 0; our_current_location_x <= environment_width - 1; our_current_location_x++) { printf("%c", environment[our_current_location_x] [our_current_location_y]); } printf("\n"); } } #endif #if defined(X_DISPLAY) || defined(TEXT_DISPLAY) /* Wait between frames of animation */ usleep(microseconds_per_day); #endif /* ALG XIV.G: For each of the process’s people, each process spawns * threads to do the following */ #pragma omp parallel for private(my_current_person_id, my_x_move_direction, \ my_y_move_direction) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { /* ALG XIV.G.1: If the person is not dead, then */ if(our_states[my_current_person_id] != DEAD) { /* ALG XIV.G.1.a: The thread randomly picks whether the person * moves left or right or does not move in the x dimension */ my_x_move_direction = (random() % 3) - 1; /* ALG XIV.G.1.b: The thread randomly picks whether the person * moves up or down or does not move in the y dimension */ my_y_move_direction = (random() % 3) - 1; /* ALG XIV.G.1.c: If the person will remain in the bounds of the * environment after moving, then */ if((our_x_locations[my_current_person_id] + my_x_move_direction >= 0) && (our_x_locations[my_current_person_id] + my_x_move_direction < environment_width) && (our_y_locations[my_current_person_id] + my_y_move_direction >= 0) && (our_y_locations[my_current_person_id] + my_y_move_direction < environment_height)) { /* ALG XIV.G.i: The thread moves the person */ our_x_locations[my_current_person_id] += my_x_move_direction; our_y_locations[my_current_person_id] += my_y_move_direction; } } } /* ALG XIV.H: For each of the process’s people, each process spawns * threads to do the following */ #pragma omp parallel for private(my_current_person_id, my_num_infected_nearby, \ my_person2) reduction(+:our_num_infection_attempts) \ reduction(+:our_num_infected) reduction(+:our_num_susceptible) \ reduction(+:our_num_infections) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { /* ALG XIV.H.1: If the person is susceptible, then */ if(our_states[my_current_person_id] == SUSCEPTIBLE) { /* ALG XIV.H.1.a: For each of the infected people (received * earlier from all processes) or until the number of infected * people nearby is 1, the thread does the following */ my_num_infected_nearby = 0; for(my_person2 = 0; my_person2 <= total_num_infected - 1 && my_num_infected_nearby < 1; my_person2++) { /* ALG XIV.H.1.a.i: If person 1 is within the infection * radius, then */ if((our_x_locations[my_current_person_id] > their_infected_x_locations[my_person2] - infection_radius) && (our_x_locations[my_current_person_id] < their_infected_x_locations[my_person2] + infection_radius) && (our_y_locations[my_current_person_id] > their_infected_y_locations[my_person2] - infection_radius) && (our_y_locations[my_current_person_id] < their_infected_y_locations[my_person2] + infection_radius)) { /* ALG XIV.H.1.a.i.1: The thread increments the number * of infected people nearby */ my_num_infected_nearby++; } } #ifdef SHOW_RESULTS if(my_num_infected_nearby >= 1) our_num_infection_attempts++; #endif /* ALG XIV.H.1.b: If there is at least one infected person * nearby, and a random number less than 100 is less than or * equal to the contagiousness factor, then */ if(my_num_infected_nearby >= 1 && (random() % 100) <= contagiousness_factor) { /* ALG XIV.H.1.b.i: The thread changes person1’s state to * infected */ our_states[my_current_person_id] = INFECTED; /* ALG XIV.H.1.b.ii: The thread updates the counters */ our_num_infected++; our_num_susceptible--; #ifdef SHOW_RESULTS our_num_infections++; #endif } } } /* ALG XIV.I: For each of the process’s people, each process spawns * threads to do the following */ #pragma omp parallel for private(my_current_person_id) \ reduction(+:our_num_recovery_attempts) reduction(+:our_num_dead) \ reduction(+:our_num_infected) reduction(+:our_num_deaths) \ reduction(+:our_num_immune) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { /* ALG XIV.I.1: If the person is infected and has been for the full * duration of the disease, then */ if(our_states[my_current_person_id] == INFECTED && our_num_days_infected[my_current_person_id] == duration_of_disease) { #ifdef SHOW_RESULTS our_num_recovery_attempts++; #endif /* ALG XIV.I.a: If a random number less than 100 is less than * the deadliness factor, then */ if((random() % 100) < deadliness_factor) { /* ALG XIV.I.a.i: The thread changes the person’s state to * dead */ our_states[my_current_person_id] = DEAD; /* ALG XIV.I.a.ii: The thread updates the counters */ our_num_dead++; our_num_infected--; #ifdef SHOW_RESULTS our_num_deaths++; #endif } /* ALG XIV.I.b: Otherwise, */ else { /* ALG XIV.I.b.i: The thread changes the person’s state to * immune */ our_states[my_current_person_id] = IMMUNE; /* ALG XIV.I.b.ii: The thread updates the counters */ our_num_immune++; our_num_infected--; } } } /* ALG XIV.J: For each of the process’s people, each process spawns * threads to do the following */ #pragma omp parallel for private(my_current_person_id) for(my_current_person_id = 0; my_current_person_id <= our_number_of_people - 1; my_current_person_id++) { /* ALG XIV.J.1: If the person is infected, then */ if(our_states[my_current_person_id] == INFECTED) { /* ALG XIV.J.1.a: Increment the number of days the person has * been infected */ our_num_days_infected[my_current_person_id]++; } } } /* ALG XV: If X display is enabled, then Rank 0 destroys the X Window and * closes the display */ #ifdef X_DISPLAY if(our_rank == 0) { XDestroyWindow(display, window); XCloseDisplay(display); } #endif #ifdef SHOW_RESULTS printf("Final counts: %d susceptible, %d infected, %d immune, \ %d dead\nActual contagiousness: %f\nActual deadliness: \ %f\n", our_num_susceptible, our_num_infected, our_num_immune, our_num_dead, 100.0 * (our_num_infections / (our_num_infection_attempts == 0 ? 1 : our_num_infection_attempts)), 100.0 * (our_num_deaths / (our_num_recovery_attempts == 0 ? 1 : our_num_recovery_attempts))); #endif /* Deallocate the arrays -- we have finished using the memory, so now we * "free" it back to the heap */ #ifdef TEXT_DISPLAY for(our_current_location_x = environment_width - 1; our_current_location_x >= 0; our_current_location_x--) { free(environment[our_current_location_x]); } free(environment); #endif free(our_states); free(states); free(displs); free(recvcounts); free(our_num_days_infected); free(their_infected_y_locations); free(their_infected_x_locations); free(our_infected_y_locations); free(our_infected_x_locations); free(our_y_locations); free(our_x_locations); free(y_locations); free(x_locations); //#ifdef MPI /* MPI execution is finished; no MPI calls are allowed after this */ // MPI_Finalize(); //#endif /* The program has finished executing successfully */ return 0; }
/* *********************************************************************** * Allocates colors and fill a pixel value array. Color values are * truncated with RED_MASK, GREEN_MASK and BLUE_MASK * * from,to are the primary colors to use * maxcols is the number of colors * colors is the array of pixel values * light,dark are the colors for the relief * dr,dg,db are the increment values for the colors * alloc_relief if colors for relief should be allocated * incr - 0 if gradient is light to dark, 1 if dark to light *********************************************************************** */ int MakeColors(Display *dpy, Drawable d, int from[3], int to[3], int maxcols, unsigned long *colors, unsigned long *dark, unsigned long *light, int dr, int dg, int db, int alloc_relief, int incr) { float rv, gv, bv; float sr,sg,sb; int red, green, blue; XColor color; int i; sr = (float)dr / (float)maxcols; sg = (float)dg / (float)maxcols; sb = (float)db / (float)maxcols; rv = (float)from[0]; gv = (float)from[1]; bv = (float)from[2]; /* kludge to frce color allocation in the first iteration on any case */ color.red = (from[0] == 0) ? 0xffff : 0; color.green = 0; color.blue = 0; for(i = 0; i < maxcols; i++) { /* color allocation saver */ red = ((short)rv) & RED_MASK; green = ((short)gv) & GREEN_MASK; blue = ((short)bv) & BLUE_MASK; if (color.red != red || color.green != green || color.blue != blue) { color.red = red; color.green = green; color.blue = blue; if (XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color)==0) { return 0; } } colors[i] = color.pixel; rv += sr; gv += sg; bv += sb; if ((rv > 65535.0) || (rv < 0.0)) rv -= sr; if ((gv > 65535.0) || (gv < 0.0)) gv -= sg; if ((bv > 65535.0) || (bv < 0.0)) bv -= sb; } /* allocate 2 colors for the bevel */ if (alloc_relief) { if (incr) { rv = (float)from[0] * 0.8; gv = (float)from[1] * 0.8; bv = (float)from[2] * 0.8; } else { rv = (float)to[0] * 0.8; gv = (float)to[1] * 0.8; bv = (float)to[2] * 0.8; } color.red = (unsigned short)(rv<0?0:rv); color.green = (unsigned short)(gv<0?0:gv); color.blue = (unsigned short)(bv<0?0:bv); if (XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),&color)) *dark = color.pixel; else *dark = colors[incr ? 0 : maxcols-1]; if (incr) { float avg; avg = (float)(to[0]+to[1]+to[2])/3; rv = avg + (float)(to[0]/2); gv = avg + (float)(to[1]/2); bv = avg + (float)(to[2]/2); } else { float avg; avg = (float)(from[0]+from[1]+from[2])/3; rv = avg + (float)(from[0]/2); gv = avg + (float)(from[1]/2); bv = avg + (float)(from[2]/2); } color.red = (unsigned short)(rv>65535.0 ? 65535.0:rv); color.green = (unsigned short)(gv>65535.0 ? 65535.0:gv); color.blue = (unsigned short)(bv>65535.0 ? 65535.0:bv); if (XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color)) *light = color.pixel; else *light = colors[incr ? maxcols-1 : 0]; } else { *light = colors[incr ? maxcols-1 : 0]; *dark = colors[incr ? 0 : maxcols-1]; } return 1; }
Pixmap Tk_GetPixmap( Display *display, Drawable d, int width, int height, int depth) { TkWinDrawable *newTwdPtr, *twdPtr; int planes; Screen *screen; display->request++; newTwdPtr = ckalloc(sizeof(TkWinDrawable)); newTwdPtr->type = TWD_BITMAP; newTwdPtr->bitmap.depth = depth; twdPtr = (TkWinDrawable *) d; if (twdPtr->type != TWD_BITMAP) { if (twdPtr->window.winPtr == NULL) { newTwdPtr->bitmap.colormap = DefaultColormap(display, DefaultScreen(display)); } else { newTwdPtr->bitmap.colormap = twdPtr->window.winPtr->atts.colormap; } } else { newTwdPtr->bitmap.colormap = twdPtr->bitmap.colormap; } screen = &display->screens[0]; planes = 1; if (depth == screen->root_depth) { planes = PTR2INT(screen->ext_data); depth /= planes; } newTwdPtr->bitmap.handle = CreateBitmap(width, height, (DWORD) planes, (DWORD) depth, NULL); /* * CreateBitmap tries to use memory on the graphics card. If it fails, * call CreateDIBSection which uses real memory; slower, but at least * still works. [Bug 2080533] */ if (newTwdPtr->bitmap.handle == NULL) { static int repeatError = 0; void *bits = NULL; BITMAPINFO bitmapInfo; HDC dc; memset(&bitmapInfo, 0, sizeof(bitmapInfo)); bitmapInfo.bmiHeader.biSize = sizeof(bitmapInfo.bmiHeader); bitmapInfo.bmiHeader.biWidth = width; bitmapInfo.bmiHeader.biHeight = height; bitmapInfo.bmiHeader.biPlanes = planes; bitmapInfo.bmiHeader.biBitCount = depth; bitmapInfo.bmiHeader.biCompression = BI_RGB; bitmapInfo.bmiHeader.biSizeImage = 0; dc = GetDC(NULL); newTwdPtr->bitmap.handle = CreateDIBSection(dc, &bitmapInfo, DIB_RGB_COLORS, &bits, 0, 0); ReleaseDC(NULL, dc); /* * Oh no! Things are still going wrong. Pop up a warning message here * (because things will probably crash soon) which will encourage * people to report this as a bug... */ if (newTwdPtr->bitmap.handle == NULL && !repeatError) { LPVOID lpMsgBuf; repeatError = 1; if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &lpMsgBuf, 0, NULL)) { MessageBoxA(NULL, (LPCSTR) lpMsgBuf, "Tk_GetPixmap: Error from CreateDIBSection", MB_OK | MB_ICONINFORMATION); LocalFree(lpMsgBuf); } } } if (newTwdPtr->bitmap.handle == NULL) { ckfree(newTwdPtr); return None; } return (Pixmap) newTwdPtr; }
int InitX() { XColor xColor; Colormap colormap; dpy = XOpenDisplay(NULL); if(dpy == NULL) { fprintf(stderr, "ERROR: Unable to open X display\n"); return 1; } clrBlack = BlackPixel(dpy, DefaultScreen(dpy)); clrWhite = WhitePixel(dpy, DefaultScreen(dpy)); colormap = DefaultColormap(dpy, DefaultScreen(dpy)); XParseColor(dpy, colormap, "red", &xColor); XAllocColor(dpy, colormap, &xColor); clrRed = xColor.pixel; XParseColor(dpy, colormap, "blue", &xColor); XAllocColor(dpy, colormap, &xColor); clrBlue = xColor.pixel; XParseColor(dpy, colormap, "orange", &xColor); XAllocColor(dpy, colormap, &xColor); clrOrange = xColor.pixel; wmDeleteMessage = XInternAtom(dpy, "WM_DELETE_WINDOW", False); // Create the window win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 400, 300, 8, clrBlack, clrWhite); XSetWMProtocols(dpy, win, &wmDeleteMessage, 1); XSelectInput(dpy, win, StructureNotifyMask | ExposureMask | KeyPressMask); XGCValues values; XFontStruct *font; font = XLoadQueryFont(dpy, "fixed"); if(!font) { fprintf(stderr, "No fixed font?\n"); return 2; } values.line_width = 1; values.line_style = LineSolid; values.font = font->fid; gc = XCreateGC(dpy, win, GCLineWidth|GCLineStyle|GCFont, &values); XStoreName(dpy, win, "xtemp"); // Map the window (that is, make it appear on the screen) XMapWindow(dpy, win); // Tell the GC we draw using black on white XSetForeground(dpy, gc, clrBlack); XSetBackground(dpy, gc, clrWhite); // Wait for the MapNotify event for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; } return 0; }
Colormap InitColorTableFixed(Colormap cmap) { int n_colors = xwa.visual->map_entries; int r, g, b, y, i; switch (xwa.visual->class) { case StaticGray: case GrayScale: /* determine how many levels of gray we can actually get */ y = try_get_grays(cmap, n_colors); if (y > 2 && y < n_colors) y = try_get_grays(cmap, y); if (y < 2) G_fatal_error(_("Unable to get sufficient gray shades.")); NCOLORS = y; for (i = 0; i < 256; i++) Gray[i] = i * y / 256; break; case StaticColor: case PseudoColor: /* determine how many levels of r, g, and b are possible */ get_max_levels(n_colors, &r, &g, &b); /* now see how many we can actually get */ while (!try_get_colors(cmap, r, g, b)) if (!get_fewer_levels(&r, &g, &b)) G_fatal_error(_("Unable to get sufficient colors.")); NCOLORS = r * g * b; for (i = 0; i < 256; i++) { Red[i] = (i * r / 256) * g * b; Grn[i] = (i * g / 256) * b; Blu[i] = (i * b / 256); } break; case DirectColor: G_warning(_("Using private colormap for DirectColor visual.")); /* free any previously-allocated Colormap */ if (cmap != DefaultColormap(dpy, scrn)) XFreeColormap(dpy, cmap); /* get shift factors for R,G,B masks */ NCOLORS = get_rgb_shifts(); /* create colormap (emulates TrueColor visual) */ cmap = ramp_colormap(); break; case TrueColor: /* get shift factors for R,G,B masks */ NCOLORS = get_rgb_shifts(); break; default: G_fatal_error(_("Unknown visual class [%d]."), xwa.visual->class); break; } return cmap; }
void setup_gui_colors() { XColor kolor,unused; int *depths, num_depths; display = XtDisplay(shell); window = XtWindow(shell); if((depths = XListDepths(display, XScreenNumberOfScreen(XtScreen(shell)), &num_depths))==NULL) { printf("XListDepths() failed.\n"); exit(0); } cmap = DefaultColormap(display, 0); XAllocNamedColor(display,cmap,"black",&kolor,&unused); black_color = kolor.pixel; XAllocNamedColor(display,cmap,"white",&kolor,&unused); white_color = kolor.pixel; XAllocNamedColor(display,cmap,"lawngreen",&kolor,&unused); green_color = kolor.pixel; XAllocNamedColor(display,cmap,"red",&kolor,&unused); red_color = kolor.pixel; XAllocNamedColor(display,cmap,"blue",&kolor,&unused); blue_color = kolor.pixel; XAllocNamedColor(display,cmap,"grey",&kolor,&unused); grey_color = kolor.pixel; XAllocNamedColor(display,cmap,"yellow",&kolor,&unused); yellow_color = kolor.pixel; XAllocNamedColor(display,cmap,"orange",&kolor,&unused); orange_color = kolor.pixel; XAllocNamedColor(display,cmap,"magenta",&kolor,&unused); magenta_color = kolor.pixel; XAllocNamedColor(display,cmap,"cyan",&kolor,&unused); cyan_color = kolor.pixel; XAllocNamedColor(display,cmap,"brown",&kolor,&unused); brown_color = kolor.pixel; XAllocNamedColor(display,cmap,"light grey",&kolor,&unused); light_grey_color = kolor.pixel; XAllocNamedColor(display,cmap,"snow",&kolor,&unused); snow_color = kolor.pixel; XAllocNamedColor(display,cmap,"indian red",&kolor,&unused); indian_red_color = kolor.pixel; XAllocNamedColor(display,cmap,"ghost white",&kolor,&unused); ghost_white_color = kolor.pixel; gcv.foreground = white_color; gcv.background = black_color; gcv.graphics_exposures = FALSE; gc = XCreateGC(display, window, GCBackground|GCForeground|GCGraphicsExposures, &gcv); }
XSilChessWindow::XSilChessWindow(XtAppContext app, Widget toplevel, Visual * vsl, int vsldepth, Colormap cmap) { char tmp[512]; Arg al[10]; int i; XmString xms; // Initialize member variables App=app; TopLevel=toplevel; Disp=XtDisplay(TopLevel); Vsl=vsl; VslDepth=vsldepth; CMap=cmap; DlgVsl=DefaultVisual(Disp,XScreenNumberOfScreen(XtScreen(TopLevel))); DlgVslDepth=DefaultDepth(Disp,XScreenNumberOfScreen(XtScreen(TopLevel))); DlgCMap=DefaultColormap(Disp,XScreenNumberOfScreen(XtScreen(TopLevel))); PixelSize=(VslDepth<=8 ? 1 : (VslDepth<=16 ? 2 : 4)); RedMask=Vsl->red_mask; GreenMask=Vsl->green_mask; BlueMask=Vsl->blue_mask; SelX=SelY-1; IsSearching=false; AbortSearching=false; NeedPainting=false; IsPainting=false; HintWanted=false; HintValid=false; // Create main window MainWin=XtVaCreateManagedWidget( "mainWin",xmMainWindowWidgetClass,TopLevel, (char*)NULL ); // Create main menu bar MainMenu=XmCreateMenuBar(MainWin,(char*)"mainMenu",NULL,0); XtManageChild(MainMenu); // Create menu item: file XtSetArg(al[0],XmNvisual,Vsl); XtSetArg(al[1],XmNdepth,VslDepth); XtSetArg(al[2],XmNcolormap,CMap); FileMenu=XmCreatePulldownMenu(MainMenu,(char*)"fileMenu",al,3); BFile=XtVaCreateManagedWidget( "file",xmCascadeButtonWidgetClass,MainMenu, XmNsubMenuId,FileMenu, (char*)NULL ); // Create menu item: file/load BFileLoad=XtVaCreateManagedWidget( "load",xmPushButtonWidgetClass,FileMenu, (char*)NULL ); XtAddCallback(BFileLoad,XmNactivateCallback,HandleCallback,this); // Create menu item: file/save BFileSave=XtVaCreateManagedWidget( "save",xmPushButtonWidgetClass,FileMenu, (char*)NULL ); XtAddCallback(BFileSave,XmNactivateCallback,HandleCallback,this); // Create menu item: file/exit XtVaCreateManagedWidget( "separator",xmSeparatorWidgetClass,FileMenu, (char*)NULL ); BFileExit=XtVaCreateManagedWidget( "exit",xmPushButtonWidgetClass,FileMenu, (char*)NULL ); XtAddCallback(BFileExit,XmNactivateCallback,HandleCallback,this); // Create menu item: game XtSetArg(al[0],XmNvisual,Vsl); XtSetArg(al[1],XmNdepth,VslDepth); XtSetArg(al[2],XmNcolormap,CMap); GameMenu=XmCreatePulldownMenu(MainMenu,(char*)"gameMenu",al,3); BGame=XtVaCreateManagedWidget( "game",xmCascadeButtonWidgetClass,MainMenu, XmNsubMenuId,GameMenu, (char*)NULL ); // Create menu item: game/new BGameNew=XtVaCreateManagedWidget( "new",xmPushButtonWidgetClass,GameMenu, (char*)NULL ); XtAddCallback(BGameNew,XmNactivateCallback,HandleCallback,this); // Create menu item: game/flip BGameFlip=XtVaCreateManagedWidget( "flip",xmPushButtonWidgetClass,GameMenu, (char*)NULL ); XtAddCallback(BGameFlip,XmNactivateCallback,HandleCallback,this); // Create menu item: game/undo BGameUndo=XtVaCreateManagedWidget( "undo",xmPushButtonWidgetClass,GameMenu, (char*)NULL ); XtAddCallback(BGameUndo,XmNactivateCallback,HandleCallback,this); // Create menu item: game/list BGameList=XtVaCreateManagedWidget( "list",xmPushButtonWidgetClass,GameMenu, (char*)NULL ); XtAddCallback(BGameList,XmNactivateCallback,HandleCallback,this); // Create menu item: computer XtSetArg(al[0],XmNvisual,Vsl); XtSetArg(al[1],XmNdepth,VslDepth); XtSetArg(al[2],XmNcolormap,CMap); CompMenu=XmCreatePulldownMenu(MainMenu,(char*)"compMenu",al,3); BComp=XtVaCreateManagedWidget( "comp",xmCascadeButtonWidgetClass,MainMenu, XmNsubMenuId,CompMenu, (char*)NULL ); // Create menu item: computer/hint BCompHint=XtVaCreateManagedWidget( "hint",xmPushButtonWidgetClass,CompMenu, (char*)NULL ); XtAddCallback(BCompHint,XmNactivateCallback,HandleCallback,this); // Create menu item: computer/depth XtSetArg(al[0],XmNvisual,Vsl); XtSetArg(al[1],XmNdepth,VslDepth); XtSetArg(al[2],XmNcolormap,CMap); XtSetArg(al[3],XmNradioBehavior,True); DepthMenu=XmCreatePulldownMenu(CompMenu,(char*)"depthMenu",al,4); BCompDepth=XtVaCreateManagedWidget( "depth",xmCascadeButtonWidgetClass,CompMenu, XmNsubMenuId,DepthMenu, (char*)NULL ); // Create menu items: computer/depth/1... for (i=0; i<=SilChessMachine::MAX_SEARCH_DEPTH; i++) { sprintf(tmp,"%d",i); BDepth[i]=XtVaCreateManagedWidget( tmp,xmToggleButtonWidgetClass,DepthMenu, (char*)NULL ); XtAddCallback(BDepth[i],XmNvalueChangedCallback,HandleCallback,this); } // Create menu item: help XtSetArg(al[0],XmNvisual,Vsl); XtSetArg(al[1],XmNdepth,VslDepth); XtSetArg(al[2],XmNcolormap,CMap); HelpMenu=XmCreatePulldownMenu(MainMenu,(char*)"helpMenu",al,3); BHelp=XtVaCreateManagedWidget( "help",xmCascadeButtonWidgetClass,MainMenu, XmNsubMenuId,HelpMenu, (char*)NULL ); XtVaSetValues(MainMenu,XmNmenuHelpWidget,BHelp,(char*)NULL); // Create menu item: help/about BHelpAbout=XtVaCreateManagedWidget( "about",xmPushButtonWidgetClass,HelpMenu, (char*)NULL ); XtAddCallback(BHelpAbout,XmNactivateCallback,HandleCallback,this); // Create a parent for status bar and view MainForm=XtVaCreateManagedWidget( "mainForm",xmFormWidgetClass,MainWin, (char*)NULL ); // Create status line StatusFrame=XtVaCreateManagedWidget( "statusFrame",xmFrameWidgetClass,MainForm, XmNleftAttachment,XmATTACH_FORM, XmNrightAttachment,XmATTACH_FORM, XmNtopAttachment,XmATTACH_FORM, (char*)NULL ); StatusLabel=XtVaCreateManagedWidget( "statusLabel",xmLabelWidgetClass,StatusFrame, XmNalignment, XmALIGNMENT_BEGINNING, (char*)NULL ); // Create the chess board view ViewFrame=XtVaCreateManagedWidget( "viewFrame",xmFrameWidgetClass,MainForm, XmNtopAttachment,XmATTACH_WIDGET, XmNtopWidget,StatusFrame, XmNleftAttachment,XmATTACH_FORM, XmNrightAttachment,XmATTACH_FORM, XmNbottomAttachment,XmATTACH_FORM, (char*)NULL ); ViewArea=XtVaCreateManagedWidget( "viewArea",xmDrawingAreaWidgetClass,ViewFrame, XmNtopAttachment,XmATTACH_FORM, XmNleftAttachment,XmATTACH_FORM, XmNrightAttachment,XmATTACH_FORM, XmNbottomAttachment,XmATTACH_FORM, (char*)NULL ); XtAddCallback(ViewArea,XmNexposeCallback,HandleCallback,this); XtAddCallback(ViewArea,XmNresizeCallback,HandleCallback,this); XtAddEventHandler( ViewArea,ButtonPressMask|ButtonMotionMask|ButtonReleaseMask| StructureNotifyMask,False,HandleEvent,this ); XtVaGetValues(ViewArea,XmNwidth,&ViewWidth,(char*)NULL); XtVaGetValues(ViewArea,XmNheight,&ViewHeight,(char*)NULL); ViewWin=0; ViewGC=NULL; // Create dialog: load game XtSetArg(al[0],XmNvisual,DlgVsl); XtSetArg(al[1],XmNdepth,DlgVslDepth); XtSetArg(al[2],XmNcolormap,DlgCMap); XtSetArg(al[3],XmNautoUnmanage,True); LoadDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"loadDialog",al,4); XtAddCallback(LoadDialog,XmNokCallback,HandleCallback,this); XtUnmanageChild(XmFileSelectionBoxGetChild(LoadDialog,XmDIALOG_HELP_BUTTON)); // Create dialog: save game XtSetArg(al[0],XmNvisual,DlgVsl); XtSetArg(al[1],XmNdepth,DlgVslDepth); XtSetArg(al[2],XmNcolormap,DlgCMap); XtSetArg(al[3],XmNautoUnmanage, True); SaveDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"saveDialog",al,4); XtAddCallback(SaveDialog,XmNokCallback,HandleCallback,this); XtUnmanageChild(XmFileSelectionBoxGetChild(SaveDialog,XmDIALOG_HELP_BUTTON)); // Create dialog: file exists, overwrite? XtSetArg(al[0],XmNvisual,DlgVsl); XtSetArg(al[1],XmNdepth,DlgVslDepth); XtSetArg(al[2],XmNcolormap,DlgCMap); XtSetArg(al[3],XmNautoUnmanage, True); OverwriteDialog=XmCreateWarningDialog(TopLevel,(char*)"overwriteDialog",al,4); XtUnmanageChild(XmMessageBoxGetChild(OverwriteDialog,XmDIALOG_HELP_BUTTON)); XtAddCallback(OverwriteDialog,XmNokCallback,HandleCallback,this); // Create dialog: error message XtSetArg(al[0],XmNvisual,DlgVsl); XtSetArg(al[1],XmNdepth,DlgVslDepth); XtSetArg(al[2],XmNcolormap,DlgCMap); XtSetArg(al[3],XmNautoUnmanage, True); ErrorBox=XmCreateWarningDialog(TopLevel,(char*)"errorBox",al,4); XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_CANCEL_BUTTON)); XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_HELP_BUTTON)); // Create dialog: list of moves ListDialogPopup=XtVaCreateWidget( "listDialog_popup",xmDialogShellWidgetClass,TopLevel, XmNvisual,DlgVsl, XmNdepth,DlgVslDepth, XmNcolormap,DlgCMap, (char*)NULL ); ListDialog=XtVaCreateWidget( "listDialog",xmFormWidgetClass,ListDialogPopup, (char*)NULL ); LDClose=XtVaCreateManagedWidget( "close",xmPushButtonWidgetClass,ListDialog, XmNleftAttachment,XmATTACH_FORM, XmNrightAttachment,XmATTACH_FORM, XmNbottomAttachment,XmATTACH_FORM, (char*)NULL ); XtAddCallback(LDClose,XmNactivateCallback,HandleCallback,this); LDScroll=XtVaCreateManagedWidget( "scroll",xmScrolledWindowWidgetClass,ListDialog, XmNscrollingPolicy,XmAUTOMATIC, XmNscrollBarDisplayPolicy,XmAS_NEEDED, XmNleftAttachment,XmATTACH_FORM, XmNrightAttachment,XmATTACH_FORM, XmNtopAttachment,XmATTACH_FORM, XmNbottomAttachment,XmATTACH_WIDGET, XmNbottomWidget,LDClose, (char*)NULL ); LDList=XtVaCreateManagedWidget( "list",xmLabelGadgetClass,LDScroll, XmNalignment,XmALIGNMENT_BEGINNING, (char*)NULL ); // Create dialog: about xms=XmStringCreateLtoR((char*)AboutText,XmFONTLIST_DEFAULT_TAG); XtSetArg(al[0],XmNvisual,DlgVsl); XtSetArg(al[1],XmNdepth,DlgVslDepth); XtSetArg(al[2],XmNcolormap,DlgCMap); XtSetArg(al[3],XmNautoUnmanage,True); XtSetArg(al[4],XmNmessageString,xms); XtSetArg(al[5],XmNmessageAlignment,XmALIGNMENT_CENTER); AboutDialog=XmCreateMessageDialog(TopLevel,(char*)"aboutDialog",al,6); XmStringFree(xms); XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_CANCEL_BUTTON)); XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_HELP_BUTTON)); // Set main window areas XmMainWindowSetAreas(MainWin,MainMenu,NULL,NULL,NULL,MainForm); // Create chess machine Machine = new SilChessMachine(); // Setup ray tracer RT.SetViewSize(ViewWidth,ViewHeight); RT.SetWorld(Machine); // Update all UpdateStatusBar(); UpdateMovesList(); UpdateView(); UpdateDepthMenu(); }
static void ingItColors_and_fonts(void) { char property[256]; char *prop = &property[0]; char *str_type[50]; XrmValue value; Colormap cmap; int ts; /** get the color map for the display **/ /* fprintf(stderr,"initx:ingItColors_and_fonts:entered\n");*/ /* fprintf(stderr,"initx:ingItColors_and_fonts:DefaultColorMap\n");*/ cmap = DefaultColormap(gXDisplay, gXScreenNumber); /* fprintf(stderr,"initx:ingItColors_and_fonts:init_group_stack\n");*/ init_group_stack(); /** then start getting the fonts **/ /* fprintf(stderr,"initx:ingItColors_and_fonts:mergeDatabases\n");*/ mergeDatabases(); /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.RmFont", "Axiom.hyperdoc.Font", str_type, &value) == True) (void) strncpy(prop, value.addr, (int) value.size); else (void) strcpy(prop, RmFontDefault); /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 1\n");*/ load_font(&gRmFont, prop); /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 2\n");*/ load_font(&gInputFont, prop); /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource 2\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.TtFont", "Axiom.hyperdoc.Font", str_type, &value) == True) (void) strncpy(prop, value.addr, (int) value.size); else (void) strcpy(prop, TtFontDefault); /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 3\n");*/ load_font(&gTtFont, prop); /* fprintf(stderr,"initx:ingItColors_and_fonts:is_it_850\n");*/ gTtFontIs850=is_it_850(gTtFont); /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource 5\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.ActiveFont", "Axiom.hyperdoc.Font", str_type, &value) == True) (void) strncpy(prop, value.addr, (int) value.size); else (void) strcpy(prop, ActiveFontDefault); /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 4\n");*/ load_font(&gActiveFont, prop); /* maintain backwards compatibility */ /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource 6\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.AxiomFont", "Axiom.hyperdoc.Font", str_type, &value) == True) (void) strncpy(prop, value.addr, (int) value.size); else { if (XrmGetResource(rDB, "Axiom.hyperdoc.SpadFont", "Axiom.hyperdoc.Font", str_type, &value) == True) { (void) strncpy(prop, value.addr, (int) value.size); } else { (void) strcpy(prop, fricas_font_default); } } /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 5\n");*/ load_font(&fricas_font, prop); /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource 7\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.EmphasizeFont", "Axiom.hyperdoc.Font", str_type, &value) == True) { (void) strncpy(prop, value.addr, (int) value.size); } else { (void) strcpy(prop, EmphasizeFontDefault); } /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 6\n");*/ load_font(&gEmFont, prop); /* fprintf(stderr,"initx:ingItColors_and_fonts:XrmGetResource 8\n");*/ if (XrmGetResource(rDB, "Axiom.hyperdoc.BoldFont", "Axiom.hyperdoc.Font", str_type, &value) == True) { (void) strncpy(prop, value.addr, (int) value.size); } else { (void) strcpy(prop, BoldFontDefault); } /* fprintf(stderr,"initx:ingItColors_and_fonts:load_font 7\n");*/ load_font(&gBfFont, prop); /* * If we are on a monochrome screen, then we ignore user preferences, and * set the foreground and background as I wish */ /* fprintf(stderr,"initx:ingItColors_and_fonts:DisplayPlanes\n");*/ if (DisplayPlanes(gXDisplay, gXScreenNumber) == 1) { gActiveColor = fricas_color = gControlBackgroundColor = gInputBackgroundColor = gBfColor = gEmColor = gRmColor = gSlColor = gTtColor = BlackPixel(gXDisplay, gXScreenNumber); gBackgroundColor = gInputForegroundColor = gControlForegroundColor = WhitePixel(gXDisplay, gXScreenNumber); } else { /* * If I have gotten here, then we must be on a color screen, so see * what the user likes, and set it up */ /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 1\n");*/ gRmColor = get_color("RmColor", "Foreground", BlackPixel(gXDisplay, gXScreenNumber), &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 2\n");*/ gBackgroundColor = get_color("Background", "Background", WhitePixel(gXDisplay, gXScreenNumber), &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 3\n");*/ gActiveColor = get_color("ActiveColor", "Foreground", BlackPixel(gXDisplay, gXScreenNumber), &cmap); /* * for next two, I want name arg = class arg, ie do not want * Background and Foreground. */ /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 4\n");*/ gControlBackgroundColor = get_color("ControlBackground", "ControlBackground", WhitePixel(gXDisplay, gXScreenNumber), &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 5\n");*/ gControlForegroundColor = get_color("ControlForeground", "ControlForeground", BlackPixel(gXDisplay, gXScreenNumber), &cmap); /* maintain backwards compatibility */ /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 6\n");*/ fricas_color = get_color("AxiomColor", "Foreground", 0, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 7\n");*/ if (fricas_color == 0) fricas_color = get_color("SpadColor", "Foreground", BlackPixel(gXDisplay, gXScreenNumber), &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 8\n");*/ gInputBackgroundColor = get_color("InputBackground", "Foreground", gRmColor, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 9\n");*/ gInputForegroundColor = get_color("InputForeground", "Background", gBackgroundColor, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 10\n");*/ gEmColor = get_color("EmphasizeColor", "Foreground", gRmColor, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 11\n");*/ gTtColor = get_color("TtColor", "Foreground", gRmColor, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 12\n");*/ gSlColor = get_color("EmphasizeColor", "Foreground", gRmColor, &cmap); /* fprintf(stderr,"initx:ingItColors_and_fonts:get_color 13\n");*/ gBfColor = get_color("BoldColor", "Foreground", gRmColor, &cmap); } /* fprintf(stderr,"initx:ingItColors_and_fonts:makeColors\n");*/ makeColors(gXDisplay, gXScreenNumber, &cmap, &spadColors, &ts); /* * Now set the current color and font, so I never have to do it again */ gTopOfGroupStack->cur_color = gRmColor; gTopOfGroupStack->cur_font = gRmFont; /* fprintf(stderr,"initx:ingItColors_and_fonts:exited\n");*/ }
static Lock * lockscreen(Display *dpy, int screen) { char curs[] = {0, 0, 0, 0, 0, 0, 0, 0}; unsigned int len; Lock *lock; XColor color; XSetWindowAttributes wa; Cursor invisible; int hue1, hue2; if(dpy == NULL || screen < 0) return NULL; lock = malloc(sizeof(Lock)); if(lock == NULL) return NULL; lock->screen = screen; lock->root = RootWindow(dpy, lock->screen); /* init */ wa.override_redirect = 1; lock->win = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen), 0, DefaultDepth(dpy, lock->screen), CopyFromParent, DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa); /* locked color */ hue1 = rand() % 360; gen_random_pastel(&color, hue1); XAllocColor(dpy, DefaultColormap(dpy, lock->screen), &color); lock->colors[0] = color.pixel; XSetWindowBackground(dpy, lock->win, lock->colors[0]); /* trying to unlock color */ hue2 = hue1 + 180; if (hue2 >= 360) { hue2 -= 360; } gen_random_pastel(&color, hue2); XAllocColor(dpy, DefaultColormap(dpy, lock->screen), &color); lock->colors[1] = color.pixel; lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8); invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &color, &color, 0, 0); XDefineCursor(dpy, lock->win, invisible); XMapRaised(dpy, lock->win); for(len = 1000; len; len--) { if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess) break; usleep(1000); } if(running && (len > 0)) { for(len = 1000; len; len--) { if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) break; usleep(1000); } } running &= (len > 0); if(!running) { unlockscreen(dpy, lock); lock = NULL; } else XSelectInput(dpy, lock->root, SubstructureNotifyMask); return lock; }
Status XmuLookupStandardColormap(Display *dpy, int screen, VisualID visualid, unsigned int depth, Atom property, Bool replace, Bool retain) /* * dpy - specifies X server connection * screen - specifies screen of display * visualid - specifies the visual type * depth - specifies the visual type * property - a standard colormap property * replace - specifies whether to replace * retain - specifies whether to retain */ { Display *odpy; /* original display connection */ XStandardColormap *colormap; XVisualInfo vinfo_template, *vinfo; /* visual */ long vinfo_mask; unsigned long r_max, g_max, b_max; /* allocation */ int count; Colormap cmap; /* colormap ID */ Status status = 0; /* Match the requested visual */ vinfo_template.visualid = visualid; vinfo_template.screen = screen; vinfo_template.depth = depth; vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask; if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &count)) == NULL) return 0; /* Monochrome visuals have no standard maps */ if (vinfo->colormap_size <= 2) { XFree((char *) vinfo); return 0; } /* If the requested property already exists on this screen, and, * if the replace flag has not been set to true, return success. * lookup() will remove a pre-existing map if replace is true. */ if (lookup(dpy, screen, visualid, property, (XStandardColormap *) NULL, replace) && !replace) { XFree((char *) vinfo); return 1; } /* Determine the best allocation for this property under the requested * visualid and depth, and determine whether or not to use the default * colormap of the screen. */ if (!XmuGetColormapAllocation(vinfo, property, &r_max, &g_max, &b_max)) { XFree((char *) vinfo); return 0; } cmap = (property == XA_RGB_DEFAULT_MAP && visualid == XVisualIDFromVisual(DefaultVisual(dpy, screen))) ? DefaultColormap(dpy, screen) : None; /* If retaining resources, open a new connection to the same server */ if (retain) { odpy = dpy; if ((dpy = XOpenDisplay(XDisplayString(odpy))) == NULL) { XFree((char *) vinfo); return 0; } } /* Create the standard colormap */ colormap = XmuStandardColormap(dpy, screen, visualid, depth, property, cmap, r_max, g_max, b_max); /* Set the standard colormap property */ if (colormap) { XGrabServer(dpy); if (lookup(dpy, screen, visualid, property, colormap, replace) && !replace) { /* Someone has defined the property since we last looked. * Since we will not replace it, release our own resources. * If this is the default map, our allocations will be freed * when this connection closes. */ if (colormap->killid == ReleaseByFreeingColormap) XFreeColormap(dpy, colormap->colormap); } else if (retain) { XSetCloseDownMode(dpy, RetainPermanent); } XUngrabServer(dpy); XFree((char *) colormap); status = 1; } if (retain) XCloseDisplay(dpy); XFree((char *) vinfo); return status; }
/* * Set the cursor image to be used for the current window */ void FGAPIENTRY glutSetCursor( int cursorID ) { freeglut_assert_ready; /* XXX WHY do we need the timer active for this? */ freeglut_assert_window; #if TARGET_HOST_UNIX_X11 /* * Open issues: * (a) Partial error checking. Is that a problem? * Is fgGetCursorError() correct? Should we abort on errors? * Should there be a freeglut-wide X error handler? Should * we use the X error-handler mechanism? * (b) FULL_CROSSHAIR demotes to plain CROSSHAIR. Old GLUT allows * for this, but if there is a system that easily supports a full- * window (or full-screen) crosshair, we might consider it. * (c) Out-of-range cursor-types generate warnings. Should we abort? */ { Cursor cursor = None; Pixmap no_cursor = None ; /* Used for GLUT_CURSOR_NONE */ int error = 0; #define MAP_CURSOR(a,b) \ case a: \ cursor = XCreateFontCursor( fgDisplay.Display, b ); \ break; if( GLUT_CURSOR_FULL_CROSSHAIR == cursorID ) cursorID = GLUT_CURSOR_CROSSHAIR; switch( cursorID ) { MAP_CURSOR( GLUT_CURSOR_RIGHT_ARROW, XC_right_ptr); MAP_CURSOR( GLUT_CURSOR_LEFT_ARROW, XC_left_ptr); MAP_CURSOR( GLUT_CURSOR_INFO, XC_hand1); MAP_CURSOR( GLUT_CURSOR_DESTROY, XC_pirate); MAP_CURSOR( GLUT_CURSOR_HELP, XC_question_arrow); MAP_CURSOR( GLUT_CURSOR_CYCLE, XC_exchange); MAP_CURSOR( GLUT_CURSOR_SPRAY, XC_spraycan); MAP_CURSOR( GLUT_CURSOR_WAIT, XC_watch); MAP_CURSOR( GLUT_CURSOR_TEXT, XC_xterm); MAP_CURSOR( GLUT_CURSOR_CROSSHAIR, XC_crosshair); MAP_CURSOR( GLUT_CURSOR_UP_DOWN, XC_sb_v_double_arrow); MAP_CURSOR( GLUT_CURSOR_LEFT_RIGHT, XC_sb_h_double_arrow); MAP_CURSOR( GLUT_CURSOR_TOP_SIDE, XC_top_side); MAP_CURSOR( GLUT_CURSOR_BOTTOM_SIDE, XC_bottom_side); MAP_CURSOR( GLUT_CURSOR_LEFT_SIDE, XC_left_side); MAP_CURSOR( GLUT_CURSOR_RIGHT_SIDE, XC_right_side); MAP_CURSOR( GLUT_CURSOR_TOP_LEFT_CORNER, XC_top_left_corner); MAP_CURSOR( GLUT_CURSOR_TOP_RIGHT_CORNER, XC_top_right_corner); MAP_CURSOR( GLUT_CURSOR_BOTTOM_RIGHT_CORNER, XC_bottom_right_corner); MAP_CURSOR( GLUT_CURSOR_BOTTOM_LEFT_CORNER, XC_bottom_left_corner); /* MAP_CURSOR( GLUT_CURSOR_NONE, XC_bogosity); */ case GLUT_CURSOR_NONE: { /* * Note that we *never* change {no_cursor_bits} from anything * but all-zeros. It is our image and mask. We also apparently * need to pick a color for foreground/background---but what * one we pick doesn't matter for GLUT_CURSOR_NONE. */ static char no_cursor_bits[ 32 ]; XColor black; no_cursor = XCreatePixmapFromBitmapData( fgDisplay.Display, fgDisplay.RootWindow, no_cursor_bits, 16, 16, 1, 0, 1 ); XParseColor( fgDisplay.Display, DefaultColormap( fgDisplay.Display, DefaultScreen( fgDisplay.Display ) ), "black", &black ); cursor = XCreatePixmapCursor( fgDisplay.Display, no_cursor, no_cursor, &black, &black, 0, 0 ); break; } case GLUT_CURSOR_INHERIT: break; default: fgWarning( "Unknown cursor type: %d\n", cursorID ); return; } error = fgGetCursorError( cursor ); if( GLUT_CURSOR_INHERIT == cursorID ) XUndefineCursor( fgDisplay.Display, fgStructure.Window->Window.Handle ); else { XDefineCursor( fgDisplay.Display, fgStructure.Window->Window.Handle, cursor ); XFreeCursor( fgDisplay.Display, cursor ); if( GLUT_CURSOR_NONE == cursorID ) XFreePixmap( fgDisplay.Display, no_cursor ); } } #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE /* * This is a temporary solution only... */ /* Set the cursor AND change it for this window class. */ # define MAP_CURSOR(a,b) \ case a: \ SetCursor( LoadCursor( NULL, b ) ); \ SetClassLong( fgStructure.Window->Window.Handle, \ GCL_HCURSOR, \ ( LONG )LoadCursor( NULL, b ) ); \ break; /* Nuke the cursor AND change it for this window class. */ # define ZAP_CURSOR(a,b) \ case a: \ SetCursor( NULL ); \ SetClassLong( fgStructure.Window->Window.Handle, \ GCL_HCURSOR, ( LONG )NULL ); \ break; switch( cursorID ) { MAP_CURSOR( GLUT_CURSOR_RIGHT_ARROW, IDC_ARROW ); MAP_CURSOR( GLUT_CURSOR_LEFT_ARROW, IDC_ARROW ); MAP_CURSOR( GLUT_CURSOR_INFO, IDC_HELP ); MAP_CURSOR( GLUT_CURSOR_DESTROY, IDC_CROSS ); MAP_CURSOR( GLUT_CURSOR_HELP, IDC_HELP ); MAP_CURSOR( GLUT_CURSOR_CYCLE, IDC_SIZEALL ); MAP_CURSOR( GLUT_CURSOR_SPRAY, IDC_CROSS ); MAP_CURSOR( GLUT_CURSOR_WAIT, IDC_WAIT ); MAP_CURSOR( GLUT_CURSOR_TEXT, IDC_UPARROW ); MAP_CURSOR( GLUT_CURSOR_CROSSHAIR, IDC_CROSS ); /* MAP_CURSOR( GLUT_CURSOR_NONE, IDC_NO ); */ ZAP_CURSOR( GLUT_CURSOR_NONE, NULL ); default: MAP_CURSOR( GLUT_CURSOR_UP_DOWN, IDC_ARROW ); } #endif fgStructure.Window->State.Cursor = cursorID; }
int main(int argc, char *argv[]) { int rank, nprocs, x, y; Window win; // initialization for a window GC gc; // graphics context Display *display = NULL; Colormap screenColourmap; XColor colours[15]; unsigned int width = X_RESN, height = Y_RESN; /* window size */ clock_t start, end, elapsed; int pixelToDraw[3]; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &rank); ComplexNumber c; ComplexNumber z; int depth = 1000; int cSize = 4; double cX = -2; double cY = -2; double cMinR = cX; double cMinI = cY; double cMaxR = cMinR + cSize; double cMaxI = cMinI + cSize; double increaseX = (cMaxR - cMinR) / X_RESN; double increaseY = (cMaxI - cMinI) / Y_RESN; int drawable[X_RESN][Y_RESN]; if(rank==0) { display = x11setup(&win, &gc, width, height); screenColourmap = DefaultColormap(display, DefaultScreen(display)); setupColours(display, colours, screenColourmap); int probeFlag = 0; MPI_Status status; int count = 0; int start = 1; for (int i = 1; i < nprocs; i++) { MPI_Send(&start, 1, MPI_INT, i, 98, MPI_COMM_WORLD); } for (int y = 0; y < Y_RESN; y++) { for (int x = 0; x < X_RESN; x++) { while (!probeFlag) { MPI_Iprobe(MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, &probeFlag, &status); if (probeFlag) { int coords[2] = {x, y}; int slave = status.MPI_SOURCE; MPI_Recv(&pixelToDraw, 3, MPI_INT, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE); MPI_Send(&coords, 2, MPI_INT, slave, 99, MPI_COMM_WORLD); drawable[pixelToDraw[0]][pixelToDraw[1]] = pixelToDraw[2]; count++; } else { MPI_Iprobe(MPI_ANY_SOURCE, 98, MPI_COMM_WORLD, &probeFlag, &status); if (probeFlag) { int slave = status.MPI_SOURCE; int coords[2] = {x, y}; MPI_Recv(&start, 1, MPI_INT, MPI_ANY_SOURCE, 98, MPI_COMM_WORLD, MPI_STATUS_IGNORE); MPI_Send(&coords, 2, MPI_INT, slave, 99, MPI_COMM_WORLD); } } } probeFlag = 0; } } MPI_Recv(&pixelToDraw, 3, MPI_INT, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE); drawable[pixelToDraw[0]][pixelToDraw[1]] = pixelToDraw[2]; for (int y = 0; y < Y_RESN; y++) { for (int x = 0; x < X_RESN; x++) { drawPoint(display, win, gc, colours, x, y, depth, drawable[x][y]); } } } else { int flag = 1; int coords[2]; MPI_Recv(&start, 1, MPI_INT, 0, 98, MPI_COMM_WORLD, MPI_STATUS_IGNORE); MPI_Send(&start, 1, MPI_INT, 0, 98, MPI_COMM_WORLD); while (flag) { MPI_Recv(&coords, 2, MPI_INT, 0, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE); c.r = coords[0] * increaseX - 2; c.i = coords[1] * increaseY - 2; resetComplexNumber(&z); int limit = seriesDiverges(depth, &z, &c); pixelToDraw[0] = coords[0]; pixelToDraw[1] = coords[1]; pixelToDraw[2] = limit; MPI_Send(&pixelToDraw, 3, MPI_INT, 0, 99, MPI_COMM_WORLD); } } // main loop int running = 1; // loop variable start = clock(); while(running) { // checks to see if there have been any events, // will exit the main loop if any key is pressed if(rank==0) { if(XPending(display)) { XEvent ev; XNextEvent(display, &ev); switch(ev.type) { case KeyPress: running = 0; break; } } } end = clock(); elapsed = end - start; // only update the display if > 1 millisecond has passed since the last update if(elapsed / (CLOCKS_PER_SEC/1000) > 1 && rank==0) { //XClearWindow(display, win); start = end; XFlush(display); } } if(rank==0 && display) { XCloseDisplay(display); // close the display window printf("Display closed\n"); } else { MPI_Finalize(); return 0; } MPI_Finalize(); return 0; }
static BackgroundTexture *parseTexture(RContext * rc, char *text) { BackgroundTexture *texture = NULL; WMPropList *texarray; WMPropList *val; int count; char *tmp; char *type; #define GETSTRORGOTO(val, str, i, label) \ val = WMGetFromPLArray(texarray, i);\ if (!WMIsPLString(val)) {\ wwarning("could not parse texture %s", text);\ goto label;\ }\ str = WMGetFromPLString(val) texarray = WMCreatePropListFromDescription(text); if (!texarray || !WMIsPLArray(texarray) || (count = WMGetPropListItemCount(texarray)) < 2) { wwarning("could not parse texture %s", text); if (texarray) WMReleasePropList(texarray); return NULL; } texture = wmalloc(sizeof(BackgroundTexture)); GETSTRORGOTO(val, type, 0, error); if (strcasecmp(type, "solid") == 0) { XColor color; Pixmap pixmap; texture->solid = 1; GETSTRORGOTO(val, tmp, 1, error); if (!XParseColor(dpy, DefaultColormap(dpy, scr), tmp, &color)) { wwarning("could not parse color %s in texture %s", tmp, text); goto error; } XAllocColor(dpy, DefaultColormap(dpy, scr), &color); pixmap = XCreatePixmap(dpy, root, 8, 8, DefaultDepth(dpy, scr)); XSetForeground(dpy, DefaultGC(dpy, scr), color.pixel); XFillRectangle(dpy, pixmap, DefaultGC(dpy, scr), 0, 0, 8, 8); texture->pixmap = pixmap; texture->color = color; texture->width = 8; texture->height = 8; } else if (strcasecmp(type, "vgradient") == 0 || strcasecmp(type, "dgradient") == 0 || strcasecmp(type, "hgradient") == 0) { XColor color; RColor color1, color2; RImage *image; Pixmap pixmap; RGradientStyle gtype; int iwidth, iheight; GETSTRORGOTO(val, tmp, 1, error); if (!XParseColor(dpy, DefaultColormap(dpy, scr), tmp, &color)) { wwarning("could not parse color %s in texture %s", tmp, text); goto error; } color1.red = color.red >> 8; color1.green = color.green >> 8; color1.blue = color.blue >> 8; GETSTRORGOTO(val, tmp, 2, error); if (!XParseColor(dpy, DefaultColormap(dpy, scr), tmp, &color)) { wwarning("could not parse color %s in texture %s", tmp, text); goto error; } color2.red = color.red >> 8; color2.green = color.green >> 8; color2.blue = color.blue >> 8; switch (type[0]) { case 'h': case 'H': gtype = RHorizontalGradient; iwidth = scrWidth; iheight = 32; break; case 'V': case 'v': gtype = RVerticalGradient; iwidth = 32; iheight = scrHeight; break; default: gtype = RDiagonalGradient; iwidth = scrWidth; iheight = scrHeight; break; } image = RRenderGradient(iwidth, iheight, &color1, &color2, gtype); if (!image) { wwarning("could not render gradient texture:%s", RMessageForError(RErrorCode)); goto error; } if (!RConvertImage(rc, image, &pixmap)) { wwarning("could not convert texture:%s", RMessageForError(RErrorCode)); RReleaseImage(image); goto error; } texture->width = image->width; texture->height = image->height; RReleaseImage(image); texture->pixmap = pixmap; } else if (strcasecmp(type, "mvgradient") == 0
// #includ ur #life int main(int argc, char *argv[]) { bool q = false; if(argv[1] != NULL && strcmp(argv[1], "-q") == 0) q=true; Display *disp; Window win; XEvent e; int screen; int winy = 0; int winx = 0; int winheight = 300; int winwidth = 500; int borderwidth = 10; int stdcposx = 20; int stdcposy = 20; int cposx = stdcposx; int cposy = stdcposy; int lastdeltime = 0; int lastrowlength = 0; int lastkeysym = 0; char *msg = "Clear"; int bwidth=strlen(msg)*6; int bheight=15; int btop=20; int bmargin = 2; int bleft=winwidth - bwidth - 20; GC white; XColor white_color; Colormap colormap; char whiteidk[] = "#FFFFFF"; GC red; XColor red_color; Colormap rcolormap; char redidk[] = "#FF0000"; disp = XOpenDisplay(NULL); if (disp == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); } screen = DefaultScreen(disp); win = XCreateSimpleWindow(disp, RootWindow(disp, screen), winx, winy, winwidth, winheight, borderwidth, BlackPixel(disp, screen), WhitePixel(disp, screen)); XSelectInput(disp, win, ExposureMask | KeyPressMask | ButtonPressMask); // Window XCreateWindow(display, parent, x, y, width, height, border_width, depth, // class, visual, valuemask, attributes) XMapWindow(disp, win); colormap = DefaultColormap(disp, 0); white = XCreateGC(disp, win, 0, 0); XParseColor(disp, colormap, whiteidk, &white_color); XAllocColor(disp, colormap, &white_color); XSetForeground(disp, white, white_color.pixel); rcolormap = DefaultColormap(disp, 0); red = XCreateGC(disp, win, 0, 0); XParseColor(disp, colormap, redidk, &red_color); XAllocColor(disp, colormap, &red_color); XSetForeground(disp, red, red_color.pixel); while (1) { XNextEvent(disp, &e); if (e.type == Expose) { XFillRectangle(disp, win, red, bleft, btop, bwidth, bheight); XDrawString(disp, win, white, bleft+bmargin, btop+bmargin+9, msg, strlen(msg)); //http://tronche.com/gui/x/xlib/graphics/drawing-text/XDrawString.html } if(e.type == 4) // button press { int x=e.xbutton.x; int y=e.xbutton.y; int button = e.xbutton.button; if(!q) printf("Button pressed. X: %d, Y: %d Button: %d\n",x,y,button); if(button == 1) { if(y < bheight+btop && x < bwidth+bleft) { if(y > btop && x > bleft) { if(!q) printf("You've hitten the button!!\nClearing...\n"); XFillRectangle(disp, win, white, 0, 0, winwidth, winheight); cposx = stdcposx; cposy = stdcposy; if(!q) printf("Repainting clearbutton...\n"); XFillRectangle(disp, win, red, bleft, btop, bwidth, bheight); XDrawString(disp, win, white, bleft+bmargin, btop+bmargin+9, msg, strlen(msg)); } } } } if (e.type == KeyPress) { if(!q) printf("Keycode: %d\n", e.xkey.keycode); unsigned long keysym = XLookupKeysym(&e.xkey, 0); if(!q) printf("Keysym: %lu\n",keysym); char *ascii = XKeysymToString(keysym); if(!q) printf("ASCII: %s\n",ascii); if(keysym == 65307 && lastkeysym == 65406) // alt+ESC { printf("Exiting...\n"); return 0; } else if(keysym == 65293) // line break { cposy+=10; lastrowlength = cposx; cposx = stdcposx; } else if(keysym == 32) // " " { cposx+=6; } else if(keysym == 65288) // delete { time_t now = time(0); if(!q) printf("Time: %ld\n",now); int diff = now-lastdeltime; if(!q) printf("Time since last deletion: %d\n",diff); XFillRectangle(disp, win, white, cposx-6, cposy-9, 6, 11); if(diff == 0) { XFillRectangle(disp, win, white, cposx-12, cposy-9, 6, 11); } lastdeltime = now; if(cposx <= stdcposx) { if(cposy != stdcposy) { cposy-=10; cposx = lastrowlength; } } else { cposx-=6; if(diff == 0 && cposx-6 > stdcposx) { cposx-=6; } } } else if(keysym == 43) // plus { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, "+", 1); cposx+=6; } else if(keysym == 44) // comma { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ",", 1); cposx+=6; } else if(keysym == 45) // minus { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, "-", 1); cposx+=6; } else if(keysym == 46) // period { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ".", 1); cposx+=6; } else if(keysym == 65289) // tab { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, " ", 3); cposx+=18; } else { if(lastkeysym != 65506 || lastkeysym != 65505) { if(keysym == 49) { ascii = "!"; } else if(keysym == 43) { ascii = "?"; } } if(keysym != 65506 && keysym != 65505) { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ascii, strlen(ascii)); cposx+=strlen(ascii)*6; } } lastkeysym = keysym; } } XCloseDisplay(disp); return 0; }
Colormap XDefaultColormap(Display *dpy, int scr) { return (DefaultColormap(dpy, scr)); }
int main (void) { int i; int allocateOK; ximg = NULL; d = XOpenDisplay (NULL); if (!d) fputs ("Couldn't open display\n", stderr), exit (1); screen = DefaultScreen (d); gc = DefaultGC (d, screen); /* Find a visual */ vis.screen = screen; vlist = XGetVisualInfo (d, VisualScreenMask, &vis, &match); if (!vlist) fputs ("No matched visuals\n", stderr), exit (1); vis = vlist[0]; XFree (vlist); // That's not a fair comparison colormap_size is depth in bits! // if (vis.colormap_size < COLORS) // printf("Colormap is too small: %i.\n",vis.colormap_size); // , exit (1); // printf("Colour depth: %i\n",vis.colormap_size); // No way this number means nothing! It is 64 for 16-bit truecolour and 256 for 8-bit! win = XCreateSimpleWindow (d, DefaultRootWindow (d), 0, 0, WIN_W, WIN_H, 0, WhitePixel (d, screen), BlackPixel (d, screen)); int xclass=get_xvisinfo_class(vis); // printf("class = %i\n",xclass); stylee = ( vis.depth > 8 ? styleeTrueColor : styleePrivate ); // printf("stylee=%i\n",stylee); if ( get_xvisinfo_class(vis) % 2 == 1) { /* The odd numbers can redefine colors */ // printf("%i\n",get_xvisinfo_class(vis)); colormap = DefaultColormap (d, screen); Visual *defaultVisual=DefaultVisual(d,screen); /* Allocate cells */ allocateOK = (XAllocColorCells (d, colormap, 1, NULL, 0, color, COLORS) != 0); printf("Allocated OK? %i\n",allocateOK); if (allocateOK) { // printf("Allocated OK\n"); // This doesn't work for installed colormap! /* Modify the colorcells */ for (i = 0; i < COLORS; i++) xrgb[i].pixel = color[i]; XStoreColors (d, colormap, xrgb, COLORS); } else { colormap = XCreateColormap(d,win,defaultVisual,AllocNone); // redocolors(); } // black = XBlackPixel(d,screen); // white = XWhitePixel(d,screen); XAllocColorCells(d,colormap,1,0,0,color,colors); XSetWindowColormap(d,win,colormap); } else if ( get_xvisinfo_class(vis) == TrueColor) { colormap = DefaultColormap (d, screen); // printf("TrueColor %i = %i\n",xclass,TrueColor); /* This will lookup the color and sets the xrgb[i].pixel value */ // for (i = 0; i < COLORS; i++) // XAllocColor (d, colormap, &xrgb[i]); } else fprintf (stderr, "Not content with visual class %d.\n", get_xvisinfo_class(vis) ), exit (1); /* Find out if MITSHM is supported and useable */ printf ("MITSHM: "); if (XShmQueryVersion (d, &mitshm_major_code, &mitshm_minor_code, &shared_pixmaps)) { int (*handler) (Display *, XErrorEvent *); ximg = XShmCreateImage (d, vis.visual, vis.depth, XShmPixmapFormat (d), NULL, &shminfo, WIN_W, WIN_H); shminfo.shmid = shmget (IPC_PRIVATE, ximg->bytes_per_line * ximg->height, IPC_CREAT | 0777); shminfo.shmaddr = (char *)shmat (shminfo.shmid, 0, 0); ximg->data = (char *)shminfo.shmaddr; handler = XSetErrorHandler (mitshm_handler); XShmAttach (d, &shminfo); /* Tell the server to attach */ XSync (d, 0); XSetErrorHandler (handler); shmctl (shminfo.shmid, IPC_RMID, 0); /* Mark this shm segment for deletion at once. The segment will * automatically become released when both the server and this * client have detached from it. * (Process termination automagically detach shm segments) */ if (!can_use_mitshm) { shmdt (shminfo.shmaddr); ximg = NULL; } } if (ximg == NULL) { can_use_mitshm = 0; /* XInitImage(ximg); */ ximg = XCreateImage (d, vis.visual, vis.depth, ZPixmap, 0, (char *)malloc (WIN_W * WIN_H), WIN_W, WIN_H, 8, 0); } if (can_use_mitshm) printf ("YES!\n"); else printf ("NO, using fallback instead.\n"); // DrawFractal (ximg,xrgb); XSelectInput (d, win, ButtonPressMask | ExposureMask); XMapWindow (d, win); real_main(); // XNextEvent (d, &ev); // switch (ev.type) { // case ButtonPress: // should_quit = 1; // break; // case Expose: // if (can_use_mitshm) // XShmPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H, True); // else // XPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H); // break; // default: // break; // } if (get_xvisinfo_class(vis) % 2 == 1 || get_xvisinfo_class(vis) == TrueColor) { unsigned long color[COLORS]; if (allocateOK) { for (i = 0; i < COLORS; i++) color[i] = xrgb[i].pixel; XFreeColors (d, colormap, color, COLORS, 0); } /* Allocated colors freed */ } else { XUninstallColormap (d, colormap); } if (can_use_mitshm) { XShmDetach (d, &shminfo); /* Server detached */ XDestroyImage (ximg); /* Image struct freed */ shmdt (shminfo.shmaddr); /* We're detached */ } else XDestroyImage (ximg); /* Image struct freed */ XDestroyWindow (d, win); /* Window removed */ XCloseDisplay (d); /* Display disconnected */ /* So you can see how your computer compares to your friend's */ getrusage (RUSAGE_SELF, &resource_utilization); float seconds=(float)resource_utilization.ru_utime.tv_sec +(float)resource_utilization.ru_utime.tv_usec*0.000000001; printf("CPU seconds per frame: %f\n",seconds/(float)frameno); // printf ("CPU seconds consumed: %ds and %dµs\n", // (int) resource_utilization.ru_utime.tv_sec, // (int) resource_utilization.ru_utime.tv_usec); return 0; }
int main () { printf ("X11 demo\n"); Display* display = NULL; GC graphics_context; Window window; int black_colour, white_colour; { // create window and display combo printf ("init window...\n"); display = XOpenDisplay (NULL); if (!display) { fprintf (stderr, "ERROR: opening display\n"); return 1; } black_colour = BlackPixel (display, DefaultScreen (display)); white_colour = WhitePixel (display, DefaultScreen (display)); // colour map Colormap colour_map; char green[] = "#00FF00"; char charcoal[] ="RGBi:0.01/0.02/0.01"; char lcharcoal[] = "RGBi:0.02/0.03/0.02";//"#445544"; char textc[] = "#DDEEDD"; char linenoc[] = "#667766"; char rulerc[] = "#556655"; colour_map = DefaultColormap (display, 0); // add colours XParseColor (display, colour_map, green, &green_col); XAllocColor (display, colour_map, &green_col); XParseColor (display, colour_map, charcoal, &charcoal_col); XAllocColor (display, colour_map, &charcoal_col); XParseColor (display, colour_map, lcharcoal, &lcharcoal_col); XAllocColor (display, colour_map, &lcharcoal_col); XParseColor (display, colour_map, textc, &text_col); XAllocColor (display, colour_map, &text_col); XParseColor (display, colour_map, rulerc, &ruler_col); XAllocColor (display, colour_map, &ruler_col); XParseColor (display, colour_map, linenoc, &lineno_col); XAllocColor (display, colour_map, &lineno_col); // note: can use CopyFromParent instead of colour index // note: there is also XCreateWindow with more params // simplewindow also clears the window to background colour // 0,0 is request position, other 0 is border (not used) window = XCreateSimpleWindow (display, DefaultRootWindow (display), 0, 0, 1024, 768, 0, charcoal_col.pixel, charcoal_col.pixel); XStoreName (display, window, "Anton's X11 demo"); // get MapNotify events etc. XSelectInput (display, window, ExposureMask); // was StructureNotifyMask // put window on screen command XMapWindow (display, window); // create graphics context graphics_context = XCreateGC (display, window, 0, 0); } // endinitwindow { // draw // note: can also unload a font const char* font_name = "-*-Monospace-*-10-*"; XFontStruct* font = XLoadQueryFont (display, font_name); if (!font) { fprintf (stderr, "ERROR: could not load font %s\n", font_name); font = XLoadQueryFont (display, "fixed"); if (!font) { fprintf (stderr, "ERROR: default font fixed did not load\n"); return 1; } } XSetFont (display, graphics_context, font->fid); event_loop (display, window, graphics_context); } // enddraw return 0; }