int main(int argc, char *argv[]){ FILE *fp; char buff[1000]; int ch, i, j, x, y; int line_count = 0; count = -1; count_intersect = 0; k = 0; fp = fopen(argv[1], "r"); if (fp == NULL){ printf("There's no input file.\n"); exit(0); } else{ if( (display = XOpenDisplay(display_name)) == NULL ){ printf("Could not open display. \n"); exit(-1); } printf("Connected to X server %s\n", XDisplayName(display_name) ); screen_num = DefaultScreen(display); screen = DefaultScreenOfDisplay(display); colormap = XDefaultColormap(display, screen_num); display_width = DisplayWidth(display, screen_num); display_height = DisplayHeight(display, screen_num); //obtaining line count while(!feof(fp)){ ch = fgetc(fp); if (ch == '\n'){ line_count++; } } rewind(fp); } //int m[line_count][6]; int m[line_count+1][6]; //Creating window border_width = 10; win_x = 0; win_y = 0; win_width = display_width/2; win_height = display_height * 0.8; //win_height = (int)(win_width/1.7); //rectangular window printf("window width: %d\n window height: %d\n", display_width, display_height); //win = XCreateSimpleWindow(display, RootWindow(display, 0), 1, 1, win_width, win_height, 10, WhitePixel (display, 0), WhitePixel (display, 0)); win = XCreateSimpleWindow(display, RootWindow(display, screen_num), win_x, win_y, win_width, win_height, border_width, BlackPixel(display, screen_num), WhitePixel(display, screen_num)); //Maps window on screen size_hints = XAllocSizeHints(); wm_hints = XAllocWMHints(); class_hints = XAllocClassHint(); if (size_hints == NULL || wm_hints == NULL || class_hints == NULL){ printf("Error allocating memory for hints\n"); exit(-1); } size_hints -> flags = PPosition | PSize | PMinSize; size_hints -> min_width = 60; size_hints -> min_height = 60; XStringListToTextProperty(&win_name_string, 1, &win_name); XStringListToTextProperty(&icon_name_string, 1, &icon_name); wm_hints -> flags = StateHint | InputHint; wm_hints -> initial_state = NormalState; wm_hints -> input = False; class_hints -> res_name = "x_use_example"; class_hints -> res_class = "homework1"; XSetWMProperties(display, win, &win_name, &icon_name, argv, argc, size_hints, wm_hints, class_hints ); XSelectInput(display, win, ExposureMask | KeyPressMask | ButtonPressMask); // put on screen XMapWindow(display, win); XFlush(display); //graphics setup green_gc = XCreateGC(display, win, 0, 0); XParseColor(display, colormap, green, &green_col); if (XAllocColor(display, colormap, &green_col) == 0){ printf("Failed to get color green\n"); exit(-1); } else{ printf("Success green!\n"); XSetForeground(display, green_gc, green_col.pixel); } red_gc = XCreateGC(display, win, 0, 0); XParseColor(display, colormap, red, &red_col); if (XAllocColor(display, colormap, &red_col) == 0){ printf("Failed to get color red\n"); exit(-1); } else{ printf("Success red!\n"); XSetForeground(display, red_gc, red_col.pixel); } black_gc = XCreateGC(display, win, 0, 0); XParseColor(display, colormap, black, &black_col); if (XAllocColor(display, colormap, &black_col) == 0){ printf("Failed to get color black\n"); exit(-1); } else{ printf("Success black!\n"); XSetForeground(display, black_gc, black_col.pixel); } light_purple_gc = XCreateGC(display, win, 0, 0); XParseColor(display, colormap, light_purple, &light_purple_col); if (XAllocColor(display, colormap, &light_purple_col) == 0){ printf("Failed to get color light purple\n"); exit(-1); } else{ printf("Success light purple!\n"); XSetForeground(display, light_purple_gc, light_purple_col.pixel); } white_gc = XCreateGC(display, win, 0, 0); XParseColor(display, colormap, white, &white_col); if (XAllocColor(display, colormap, &white_col) == 0){ printf("Failed to get color white\n"); exit(-1); } else{ printf("Success white!\n"); XSetForeground(display, white_gc, white_col.pixel); } while(1){ XNextEvent(display, &report); switch(report.type){ case Expose: { for (i = 0; i <= line_count; i++){ fscanf(fp, "%*s ( %d, %d) ( %d, %d) (%d, %d)", &m[i][0], &m[i][1], &m[i][2], &m[i][3], &m[i][4], &m[i][5]); } m[line_count+1][0] = -5; for (i = 0; i <= line_count ; i++){ for (j=0; j<6; j+=2){ m[i][j] = m[i][j] + 100; m[i][j+1] = m[i][j+1] + 100; } } for (i = 0; i <=line_count; i++){ //Draw the triangles XDrawLine(display, win, green_gc, m[i][0], m[i][1], m[i][2], m[i][3]); XDrawLine(display, win, green_gc, m[i][2], m[i][3], m[i][4], m[i][5]); XDrawLine(display, win, green_gc, m[i][4], m[i][5], m[i][0], m[i][1]); } rewind(fp); if (valid_vertex[0][0] != 0.0){ for (i= 0; i<k; i++){ if (valid_vertex[i][6] == 0.0 || valid_vertex[i][6] == -4.0){ printf("from (%d, %d) to (%d, %d) length: %f and path length: %f\n", (int)valid_vertex[i][0], (int)valid_vertex[i][1], (int)valid_vertex[i][2], (int)valid_vertex[i][3], valid_vertex[i][4], valid_vertex[i][5]); XDrawLine(display, win, light_purple_gc, valid_vertex[i][0], valid_vertex[i][1], valid_vertex[i][2], valid_vertex[i][3]); } } XFillArc( display, win, black_gc, start_x, start_y, win_width/200, win_width/200, 0, 360*64); XFillArc( display, win, black_gc, target_x, target_y, win_width/200, win_width/200, 0, 360*64); } else{} //printf("exposed\n"); XFlush(display); break; } case ButtonPress: { //printf("Button press %d, %d.\n",report.xbutton.x, report.xbutton.y); double distance1; x = report.xbutton.x; y = report.xbutton.y; int inTriangle; if (report.xbutton.button == Button1){ /* left click */ count++; inTriangle = check_if_in_triangle(line_count, m, x, y); if (inTriangle == 0){ XFillArc( display, win, black_gc, x, y, win_width/200, win_width/200, 0, 360*64); } } else{ printf("Closing Window.\n"); XDestroyWindow(display, win); XCloseDisplay(display); exit(1); } //printf("count: %d\n", count); if (count == 0){ reset(m, line_count); start_x = x; start_y = y; if (inTriangle == 1){ count = -1; } } else if (count == 1){ if (inTriangle == 0){ target_x = x; target_y = y; printf("\n\nStarting point: (%d, %d)\nTarget point: (%d, %d)\n", start_x, start_y, target_x, target_y); int vertex[line_count][6]; int * nearest_triangles; int * result_line_seg; for(i=0;i<=line_count;i++){ //store formatted input file in array m fscanf(fp, "%*s ( %d, %d) ( %d, %d) (%d, %d)", &vertex[i][0], &vertex[i][1], &vertex[i][2], &vertex[i][3], &vertex[i][4], &vertex[i][5]); } rewind(fp); printf("Total triangles: %d\n", line_count+1); for (i = 0; i <= line_count ; i++){ for (j=0; j<6; j+=2){ vertex[i][j] = vertex[i][j] + 100; vertex[i][j+1] = vertex[i][j+1] + 100; } } start_graph(line_count, vertex, start_x, start_y, target_x, target_y); printf("Applied start_graph()\n"); shortest_path(); printf("Applied shortest_path()\n"); organize(); printf("The shortest path: \n"); for (i= 0; i<k; i++){ if (valid_vertex[i][6] == 0.0 || valid_vertex[i][6] == -4.0){ printf("from (%d, %d) to (%d, %d) length: %f and path length: %f\n", (int)valid_vertex[i][0], (int)valid_vertex[i][1], (int)valid_vertex[i][2], (int)valid_vertex[i][3], valid_vertex[i][4], valid_vertex[i][5]); XDrawLine(display, win, light_purple_gc, valid_vertex[i][0], valid_vertex[i][1], valid_vertex[i][2], valid_vertex[i][3]); } } printf("DONE\n"); count = -1; } } XFlush(display); break; } default: break; } } fclose(fp); return 0; }
static unsigned long * SetPalette(struct state *st ) { XWindowAttributes XWinAttribs; XColor Color, *aColors; signed short iColor; float nHalfColors; XGetWindowAttributes( st->dpy, st->window, &XWinAttribs ); Color.red = RANDOM() % 0xFFFF; Color.green = RANDOM() % 0xFFFF; Color.blue = RANDOM() % 0xFFFF; if( strcasecmp( st->sColor, "random" ) && !XParseColor( st->dpy, XWinAttribs.colormap, st->sColor, &Color ) ) fprintf( stderr, "%s: color %s not found in database. Choosing to random...\n", progname, st->sColor ); #ifdef VERBOSE printf( "%s: Base color (RGB): <%d, %d, %d>\n", progname, Color.red, Color.green, Color.blue ); #endif /* VERBOSE */ st->iColorCount = get_integer_resource(st->dpy, "ncolors", "Integer" ); if( st->iColorCount < 2 ) st->iColorCount = 2; if( st->iColorCount > 255 ) st->iColorCount = 255; aColors = calloc( st->iColorCount, sizeof(XColor) ); st->aiColorVals = calloc( st->iColorCount, sizeof(unsigned long) ); for( iColor=0; iColor<st->iColorCount; iColor++ ) { nHalfColors = st->iColorCount / 2.0F; /* Black -> Base Color */ if( iColor < (st->iColorCount/2) ) { aColors[ iColor ].red = ( Color.red / nHalfColors ) * iColor; aColors[ iColor ].green = ( Color.green / nHalfColors ) * iColor; aColors[ iColor ].blue = ( Color.blue / nHalfColors ) * iColor; } /* Base Color -> White */ else { aColors[ iColor ].red = ( ( ( 0xFFFF - Color.red ) / nHalfColors ) * ( iColor - nHalfColors ) ) + Color.red; aColors[ iColor ].green = ( ( ( 0xFFFF - Color.green ) / nHalfColors ) * ( iColor - nHalfColors ) ) + Color.green; aColors[ iColor ].blue = ( ( ( 0xFFFF - Color.blue ) / nHalfColors ) * ( iColor - nHalfColors ) ) + Color.blue; } if( !XAllocColor( st->dpy, XWinAttribs.colormap, &aColors[ iColor ] ) ) { /* start all over with less colors */ XFreeColors( st->dpy, XWinAttribs.colormap, st->aiColorVals, iColor, 0 ); free( aColors ); free( st->aiColorVals ); st->iColorCount--; aColors = calloc( st->iColorCount, sizeof(XColor) ); st->aiColorVals = calloc( st->iColorCount, sizeof(unsigned long) ); iColor = -1; } else st->aiColorVals[ iColor ] = aColors[ iColor ].pixel; } free( aColors ); XSetWindowBackground( st->dpy, st->window, st->aiColorVals[ 0 ] ); return st->aiColorVals; }
Status XAllocNamedColor( register Display *dpy, Colormap cmap, _Xconst char *colorname, /* STRING8 */ XColor *hard_def, /* RETURN */ XColor *exact_def) /* RETURN */ { long nbytes; xAllocNamedColorReply rep; xAllocNamedColorReq *req; XcmsCCC ccc; XcmsColor cmsColor_exact; Status ret; /* * Let's Attempt to use Xcms and i18n approach to Parse Color */ if ((ccc = XcmsCCCOfColormap(dpy, cmap)) != (XcmsCCC)NULL) { const char *tmpName = colorname; switch (_XcmsResolveColorString(ccc, &tmpName, &cmsColor_exact, XcmsRGBFormat)) { case XcmsSuccess: case XcmsSuccessWithCompression: _XcmsRGB_to_XColor(&cmsColor_exact, exact_def, 1); memcpy((char *)hard_def, (char *)exact_def, sizeof(XColor)); ret = XAllocColor(dpy, cmap, hard_def); exact_def->pixel = hard_def->pixel; return(ret); case XcmsFailure: case _XCMS_NEWNAME: /* * if the result was _XCMS_NEWNAME tmpName points to * a string in cmsColNm.c:pairs table, for example, * gray70 would become tekhvc:0.0/70.0/0.0 */ break; } } /* * Xcms and i18n approach failed. */ LockDisplay(dpy); GetReq(AllocNamedColor, req); req->cmap = cmap; nbytes = req->nbytes = strlen(colorname); req->length += (nbytes + 3) >> 2; /* round up to mult of 4 */ _XSend(dpy, colorname, nbytes); /* _XSend is more efficient that Data, since _XReply follows */ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { UnlockDisplay(dpy); SyncHandle(); return (0); } exact_def->red = rep.exactRed; exact_def->green = rep.exactGreen; exact_def->blue = rep.exactBlue; hard_def->red = rep.screenRed; hard_def->green = rep.screenGreen; hard_def->blue = rep.screenBlue; exact_def->pixel = hard_def->pixel = rep.pixel; UnlockDisplay(dpy); SyncHandle(); return (1); }
dsxc_lutput (void) /* C-- */ { float tcol[LVX*3]; int k, istat, ka, kdiv; char flags; unsigned short int j; /* Cbegin */ DSOPEN = F77_NAMED_COMMON(ds_genb).dsopen; PDSOPEN = F77_NAMED_COMMON(ds_panelb).pdsopen; NUMDDCOL = F77_NAMED_COMMON(lutacom).numddcol; (void) dsxc_lutload ( tcol ); /* Load LUT into working LUT */ flags = DoRed | DoGreen | DoBlue; if ( DSOPEN || PDSOPEN ) { if ( OWNCOL ) { kdiv = LVX/NUMDDCOL; for ( k = 15; k<15+LVX; k++ ) { ka = 15 + ((k-15)/kdiv); COLOUR[ka].pixel = PC_ID[ka]; COLOUR[ka].flags = flags; j = tcol[3*(k-15)+0]*65535.0; COLOUR[ka].red = j; j = tcol[3*(k-15)+1]*65535.0; COLOUR[ka].green = j; j = tcol[3*(k-15)+2]*65535.0; COLOUR[ka].blue = j; } XStoreColors ( VD_ID, CM_ID, COLOUR, 15+NUMDDCOL ); XInstallColormap ( VD_ID, CM_ID ); XFlush ( VD_ID ); } else { for ( k = 15; k < 15+LVX; k++ ) { COLOUR[k].flags = flags; j = tcol[3*(k-15)+0]*65535.0; COLOUR[k].red = j; j = tcol[3*(k-15)+1]*65535.0; COLOUR[k].green = j; j = tcol[3*(k-15)+2]*65535.0; COLOUR[k].blue = j; istat = XAllocColor ( VD_ID, CM_ID, &COLOUR[k] ); if ( istat==0 ) { (void) c_printo ( "ERROR: Colour pixel not allocated" ); PC_ID[k] = 0 ; } else PC_ID[k] = COLOUR[k].pixel; } XFlush ( VD_ID ); } } }
void CGX_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask) { #if 0 SDL_Surface *sicon; XWMHints *wmhints; XImage *icon_image; Pixmap icon_pixmap; Pixmap mask_pixmap; #ifdef USE_ICON_WINDOW Window icon_window; #endif GC GC; XGCValues GCvalues; int i, b, dbpp; SDL_Rect bounds; Uint8 *LSBmask, *color_tried; Visual *dvis; /* Lock the event thread, in multi-threading environments */ SDL_Lock_EventThread(); /* The icon must use the default visual, depth and colormap of the screen, so it might need a conversion */ dbpp = DefaultDepth(SDL_Display, SDL_Screen); switch(dbpp) { case 15: dbpp = 16; break; case 24: dbpp = 32; break; } dvis = DefaultVisual(SDL_Display, SDL_Screen); /* The Visual struct is supposed to be opaque but we cheat a little */ sicon = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h, dbpp, dvis->red_mask, dvis->green_mask, dvis->blue_mask, 0); if ( sicon == NULL ) { goto done; } /* If we already have allocated colours from the default colormap, copy them */ if(SDL_Visual == dvis && SDL_XColorMap == SDL_DisplayColormap && this->screen->format->palette && sicon->format->palette) { memcpy(sicon->format->palette->colors, this->screen->format->palette->colors, this->screen->format->palette->ncolors * sizeof(SDL_Color)); } bounds.x = 0; bounds.y = 0; bounds.w = icon->w; bounds.h = icon->h; if ( SDL_LowerBlit(icon, &bounds, sicon, &bounds) < 0 ) goto done; /* Lock down the colors used in the colormap */ color_tried = NULL; if ( sicon->format->BitsPerPixel == 8 ) { SDL_Palette *palette; Uint8 *p; XColor wanted; palette = sicon->format->palette; color_tried = malloc(palette->ncolors); if ( color_tried == NULL ) { goto done; } if ( SDL_iconcolors != NULL ) { free(SDL_iconcolors); } SDL_iconcolors = malloc(palette->ncolors * sizeof(*SDL_iconcolors)); if ( SDL_iconcolors == NULL ) { free(color_tried); goto done; } memset(color_tried, 0, palette->ncolors); memset(SDL_iconcolors, 0, palette->ncolors * sizeof(*SDL_iconcolors)); p = (Uint8 *)sicon->pixels; for ( i = sicon->w*sicon->h; i > 0; --i, ++p ) { if ( ! color_tried[*p] ) { wanted.pixel = *p; wanted.red = (palette->colors[*p].r<<8); wanted.green = (palette->colors[*p].g<<8); wanted.blue = (palette->colors[*p].b<<8); wanted.flags = (DoRed|DoGreen|DoBlue); if (XAllocColor(SDL_Display, SDL_DisplayColormap, &wanted)) { ++SDL_iconcolors[wanted.pixel]; } color_tried[*p] = 1; } } } if ( color_tried != NULL ) { free(color_tried); } /* Translate mask data to LSB order and set the icon mask */ i = (sicon->w/8)*sicon->h; LSBmask = (Uint8 *)malloc(i); if ( LSBmask == NULL ) { goto done; } memset(LSBmask, 0, i); while ( --i >= 0 ) { for ( b=0; b<8; ++b ) LSBmask[i] |= (((mask[i]>>b)&0x01)<<(7-b)); } mask_pixmap = XCreatePixmapFromBitmapData(SDL_Display, WMwindow, LSBmask, sicon->w, sicon->h, 1L, 0L, 1); /* Transfer the image to an X11 pixmap */ icon_image = XCreateImage(SDL_Display, DefaultVisual(SDL_Display, SDL_Screen), DefaultDepth(SDL_Display, SDL_Screen), ZPixmap, 0, (char *)sicon->pixels, sicon->w, sicon->h, ((sicon->format)->BytesPerPixel == 3) ? 32 : (sicon->format)->BytesPerPixel*8, 0); icon_pixmap = XCreatePixmap(SDL_Display, SDL_Root, sicon->w, sicon->h, DefaultDepth(SDL_Display, SDL_Screen)); GC = XCreateGC(SDL_Display, icon_pixmap, 0, &GCvalues); XPutImage(SDL_Display, icon_pixmap, GC, icon_image, 0, 0, 0, 0, sicon->w, sicon->h); XFreeGC(SDL_Display, GC); XDestroyImage(icon_image); free(LSBmask); sicon->pixels = NULL; #ifdef USE_ICON_WINDOW /* Create an icon window and set the pixmap as its background */ icon_window = XCreateSimpleWindow(SDL_Display, SDL_Root, 0, 0, sicon->w, sicon->h, 0, CopyFromParent, CopyFromParent); XSetWindowBackgroundPixmap(SDL_Display, icon_window, icon_pixmap); XClearWindow(SDL_Display, icon_window); #endif /* Set the window icon to the icon pixmap (and icon window) */ wmhints = XAllocWMHints(); wmhints->flags = (IconPixmapHint | IconMaskHint); wmhints->icon_pixmap = icon_pixmap; wmhints->icon_mask = mask_pixmap; #ifdef USE_ICON_WINDOW wmhints->flags |= IconWindowHint; wmhints->icon_window = icon_window; #endif XSetWMHints(SDL_Display, WMwindow, wmhints); XFree(wmhints); XSync(SDL_Display, False); done: SDL_Unlock_EventThread(); if ( sicon != NULL ) { SDL_FreeSurface(sicon); } #endif return; }
void init_blue() { blue_gc = XCreateGC(dis, win, 0, 0); XParseColor(dis, colormap, blue, &blue_col); XAllocColor(dis, colormap, &blue_col); XSetForeground(dis, blue_gc, blue_col.pixel); }
/* * NAME * XcmsAllocNamedColor - * * SYNOPSIS */ Status XcmsAllocNamedColor ( Display *dpy, Colormap cmap, _Xconst char *colorname, XcmsColor *pColor_scrn_return, XcmsColor *pColor_exact_return, XcmsColorFormat result_format) /* * DESCRIPTION * Finds the color specification associated with the color * name in the Device-Independent Color Name Database, then * converts that color specification to an RGB format. This * RGB value is then used in a call to XAllocColor to allocate * a read-only color cell. * * RETURNS * 0 if failed to parse string or find any entry in the database. * 1 if succeeded in converting color name to XcmsColor. * 2 if succeeded in converting color name to another color name. * */ { long nbytes; xAllocNamedColorReply rep; xAllocNamedColorReq *req; XColor hard_def; XColor exact_def; Status retval1 = 1; Status retval2 = XcmsSuccess; XcmsColor tmpColor; XColor XColor_in_out; XcmsCCC ccc; /* * 0. Check for invalid arguments. */ if (dpy == NULL || colorname[0] == '\0' || pColor_scrn_return == 0 || pColor_exact_return == NULL) { return(XcmsFailure); } if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) { return(XcmsFailure); } /* * 1. Convert string to a XcmsColor using Xcms and i18n mechanism */ if ((retval1 = _XcmsResolveColorString(ccc, &colorname, &tmpColor, result_format)) == XcmsFailure) { return(XcmsFailure); } if (retval1 == _XCMS_NEWNAME) { goto PassToServer; } memcpy((char *)pColor_exact_return, (char *)&tmpColor, sizeof(XcmsColor)); /* * 2. Convert tmpColor to RGB * Assume pColor_exact_return is now adjusted to Client White Point */ if ((retval2 = XcmsConvertColors(ccc, &tmpColor, 1, XcmsRGBFormat, (Bool *) NULL)) == XcmsFailure) { return(XcmsFailure); } /* * 3. Convert to XColor and call XAllocColor */ _XcmsRGB_to_XColor(&tmpColor, &XColor_in_out, 1); if (XAllocColor(ccc->dpy, cmap, &XColor_in_out) == 0) { return(XcmsFailure); } /* * 4. pColor_scrn_return * * Now convert to the target format. * We can ignore the return value because we're already in a * device-dependent format. */ _XColor_to_XcmsRGB(ccc, &XColor_in_out, pColor_scrn_return, 1); if (result_format != XcmsRGBFormat) { if (result_format == XcmsUndefinedFormat) { result_format = pColor_exact_return->format; } if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format, (Bool *) NULL) == XcmsFailure) { return(XcmsFailure); } } return(retval1 > retval2 ? retval1 : retval2); PassToServer: /* * All previous methods failed, so lets pass it to the server * for parsing. */ dpy = ccc->dpy; LockDisplay(dpy); GetReq(AllocNamedColor, req); req->cmap = cmap; nbytes = req->nbytes = strlen(colorname); req->length += (nbytes + 3) >> 2; /* round up to mult of 4 */ _XSend(dpy, colorname, nbytes); /* _XSend is more efficient that Data, since _XReply follows */ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { UnlockDisplay(dpy); SyncHandle(); return (0); } exact_def.red = rep.exactRed; exact_def.green = rep.exactGreen; exact_def.blue = rep.exactBlue; hard_def.red = rep.screenRed; hard_def.green = rep.screenGreen; hard_def.blue = rep.screenBlue; exact_def.pixel = hard_def.pixel = rep.pixel; UnlockDisplay(dpy); SyncHandle(); /* * Now convert to the target format. */ _XColor_to_XcmsRGB(ccc, &exact_def, pColor_exact_return, 1); _XColor_to_XcmsRGB(ccc, &hard_def, pColor_scrn_return, 1); if (result_format != XcmsRGBFormat && result_format != XcmsUndefinedFormat) { if (XcmsConvertColors(ccc, pColor_exact_return, 1, result_format, (Bool *) NULL) == XcmsFailure) { return(XcmsFailure); } if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format, (Bool *) NULL) == XcmsFailure) { return(XcmsFailure); } } return(XcmsSuccess); }
static int initGraphics(struct state *st) { XGCValues xgcv; XWindowAttributes xgwa; /* XSetWindowAttributes xswa;*/ Colormap cmap; XColor color; int n, i; initCMap(st); XGetWindowAttributes(st->dpy,st->win,&xgwa); cmap=xgwa.colormap; /* xswa.backing_store=Always; XChangeWindowAttributes(st->dpy,st->win,CWBackingStore,&xswa);*/ xgcv.function=GXcopy; st->delay = get_integer_resource(st->dpy, "delay","Integer"); xgcv.foreground=get_pixel_resource (st->dpy, cmap, "background", "Background"); st->fgc[0]=XCreateGC(st->dpy, st->win, GCForeground|GCFunction,&xgcv); #ifdef HAVE_COCOA jwxyz_XSetAntiAliasing (st->dpy, st->fgc[0], False); #endif n=0; if (mono_p) { xgcv.foreground=get_pixel_resource (st->dpy, cmap, "foreground", "Foreground"); st->fgc[1]=XCreateGC(st->dpy,st->win,GCForeground|GCFunction,&xgcv); #ifdef HAVE_COCOA jwxyz_XSetAntiAliasing (st->dpy, st->fgc[1], False); #endif for (i=0;i<st->numColors;i+=2) st->fgc[i]=st->fgc[0]; for (i=1;i<st->numColors;i+=2) st->fgc[i]=st->fgc[1]; } else { for (i = 0; i < st->numColors; i++) { color.red=st->colors[n++]<<8; color.green=st->colors[n++]<<8; color.blue=st->colors[n++]<<8; color.flags=DoRed|DoGreen|DoBlue; XAllocColor(st->dpy,cmap,&color); xgcv.foreground=color.pixel; st->fgc[i] = XCreateGC(st->dpy, st->win, GCForeground | GCFunction,&xgcv); #ifdef HAVE_COCOA jwxyz_XSetAntiAliasing (st->dpy, st->fgc[i], False); #endif } } st->cgc = XCreateGC(st->dpy,st->win,GCForeground|GCFunction,&xgcv); XSetGraphicsExposures(st->dpy,st->cgc,False); #ifdef HAVE_COCOA jwxyz_XSetAntiAliasing (st->dpy, st->cgc, False); #endif st->xsize = xgwa.width; st->ysize = xgwa.height; st->xc = st->xsize >> 1; st->yc = st->ysize >> 1; st->maxx = 1.0; st->maxy = st->ysize/(float)st->xsize; if (st->colorScheme < 0) st->colorScheme = random()%NUM_SCHEMES; return True; }
/* 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; }
/****************************************************************************** * Routine to allocate the requested colors from the X server. * * Two stages are performed: * * 1. Colors are requested directly. * * 2. If not enough colors can be allocated, the closest current color * * in current table is selected instead. * * This allocation is not optimal as when fail to allocate all colors one * * should pick the right colors to do allocate in order to minimize the * * closest distance from the unallocated ones under some norm (what is a good * * norm for the RGB space?). Improve it if you are bored. * ******************************************************************************/ static void AllocateColors2(void) { int i, j, Index = 0, Count = 0, XNumOfColors; char Msg[80]; unsigned long D, Distance, AvgDistance = 0, Red, Green, Blue; GifBooleanType Failed = FALSE; XColor *XOldColorTable; for (i = 0; i < 256; i++) { if (i < ColorMapSize) { /* Prepere color entry in X format. */ XColorTable[i].red = ColorMap[i].Red << 8; XColorTable[i].green = ColorMap[i].Green << 8; XColorTable[i].blue = ColorMap[i].Blue << 8; XColorTable[i].flags = DoRed | DoGreen | DoBlue; XPixelTable[i] = -1; /* Not allocated yet. */ } else XPixelTable[i] = 0; /* Put reasonable color for out of range. */ } for (i = 0; i < ColorMapSize; i++) /* Allocate the colors from X: */ if (XAllocColor(XDisplay, XColorMap, &XColorTable[i])) XPixelTable[i] = XColorTable[i].pixel; else Failed = TRUE; if (Failed) { XNumOfColors = DisplayCells(XDisplay, XScreen); XOldColorTable = (XColor *) malloc(sizeof(XColor) * XNumOfColors); for (i = 0; i < XNumOfColors; i++) XOldColorTable[i].pixel = i; XQueryColors(XDisplay, XColorMap, XOldColorTable, XNumOfColors); for (i = 0; i < ColorMapSize; i++) { /* Allocate closest colors from X: */ if (XPixelTable[i] == -1) { /* Failed to allocate this one. */ Distance = 0xffffffff; Red = XColorTable[i].red; Green = XColorTable[i].green; Blue = XColorTable[i].blue; for (j = 0; j < XNumOfColors; j++) { /* Find the closest color in 3D RGB space using L1 norm. */ if ((D = ABS(Red - XOldColorTable[j].red) + ABS(Green - XOldColorTable[j].green) + ABS(Blue - XOldColorTable[j].blue)) < Distance) { Distance = D; Index = j; } } XPixelTable[i] = Index; AvgDistance += Distance; Count++; } } free(XOldColorTable); sprintf(Msg, "Colors will be approximated (average error = %d).\n", AvgDistance / Count); GIF_MESSAGE(Msg); } }
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; }
XColor *xGetXColor(Display *display, Colormap cmap, x_color_list_index_t *list_index, const char *colorname) { int pixval; int get_next; x_color_list_t *new_entry, *this_entry; if (list_index->n_entries == 0) { new_entry = (x_color_list_t *) umalloc (sizeof(x_color_list_t)); list_index->first_entry = new_entry; } else { this_entry = list_index->first_entry; get_next = TRUE; while (get_next) { if (!strcmp(colorname, this_entry->colorname)) return(&this_entry->x_color); if (this_entry->next == NULL) { get_next = FALSE; } else { this_entry = this_entry->next; } } /* while */ new_entry = (x_color_list_t *) umalloc (sizeof(x_color_list_t)); this_entry->next = new_entry; } /* if (list_index ..... */ list_index->n_entries++; new_entry->next = NULL; new_entry->duplicate = FALSE; new_entry->colorname = (char *) umalloc (strlen(colorname) + 1); strcpy(new_entry->colorname, colorname); if (XParseColor(display, cmap, colorname, &new_entry->x_color) == 0) { fprintf(stderr, "ERROR - xGetXColor\n"); fprintf(stderr, "Cannot match color '%s'\n", colorname); return(NULL); } XAllocColor(display, cmap, &new_entry->x_color); new_entry->gc = XCreateGC(display, DefaultRootWindow(display), 0, 0); XSetForeground(display, new_entry->gc, new_entry->x_color.pixel); /* * search through the list to check whether the same pixel value has * been allocated to a previous entry - this sometimes happens * if the server has run out of color cells. If there is a duplicate * entry, set the duplicate flag in the new entry */ pixval = new_entry->x_color.pixel; this_entry = list_index->first_entry; while (this_entry->next != NULL) { if (this_entry->x_color.pixel == pixval) { new_entry->duplicate = TRUE; break; } this_entry = this_entry->next; } /* while */ return(&new_entry->x_color); }
PetscErrorCode PetscDrawSetUpColormap_Private(Display *display,int screen,Visual *visual,Colormap colormap) { int i,found; Colormap defaultmap = DefaultColormap(display,screen); XColor colordef; PetscBool fast = PETSC_FALSE; PetscErrorCode ierr; PetscFunctionBegin; if (colormap) gColormap = colormap; else gColormap = XCreateColormap(display,RootWindow(display,screen),visual,AllocAll); cmap_base = 0; ierr = PetscMemzero(cmap_pixvalues_used,256*sizeof(PetscBool));CHKERRQ(ierr); /* set the basic colors into the color map */ for (i=0; i<PETSC_DRAW_BASIC_COLORS; i++) { XParseColor(display,gColormap,colornames[i],&colordef); /* try to allocate the color in the default-map */ found = XAllocColor(display,defaultmap,&colordef); /* use it, if it it exists and is not already used in the new colormap */ if (found && colordef.pixel < 256 && !cmap_pixvalues_used[colordef.pixel]) { cmap_pixvalues_used[colordef.pixel] = PETSC_TRUE; /* otherwise search for the next available slot */ } else { while (cmap_pixvalues_used[cmap_base]) cmap_base++; colordef.pixel = cmap_base; cmap_pixvalues_used[cmap_base++] = PETSC_TRUE; } XStoreColor(display,gColormap,&colordef); gCmapping[i] = colordef.pixel; } /* set the contour colors into the colormap */ ierr = PetscOptionsGetBool(NULL,NULL,"-draw_fast",&fast,NULL);CHKERRQ(ierr); if (!fast) { int ncolors = 256-PETSC_DRAW_BASIC_COLORS; unsigned char *red,*green,*blue; ierr = PetscMalloc3(ncolors,&red,ncolors,&green,ncolors,&blue);CHKERRQ(ierr); ierr = PetscDrawUtilitySetCmap(NULL,ncolors,red,green,blue);CHKERRQ(ierr); for (i=0; i<ncolors; i++) { colordef.red = (unsigned short)(red[i] << 8); colordef.green = (unsigned short)(green[i] << 8); colordef.blue = (unsigned short)(blue[i] << 8); colordef.flags = DoRed|DoGreen|DoBlue; /* try to allocate the color in the default-map */ found = XAllocColor(display,defaultmap,&colordef); /* use it, if it it exists and is not already used in the new colormap */ if (found && colordef.pixel < 256 && !cmap_pixvalues_used[colordef.pixel]) { cmap_pixvalues_used[colordef.pixel] = PETSC_TRUE; /* otherwise search for the next available slot */ } else { while (cmap_pixvalues_used[cmap_base]) cmap_base++; colordef.pixel = cmap_base; cmap_pixvalues_used[cmap_base++] = PETSC_TRUE; } XStoreColor(display,gColormap,&colordef); gCmapping[PETSC_DRAW_BASIC_COLORS + i] = colordef.pixel; } ierr = PetscFree3(red,green,blue);CHKERRQ(ierr); } ierr = PetscInfo(0,"Successfully allocated colors\n");CHKERRQ(ierr); PetscFunctionReturn(0); }
void do_setcustompalette (XColor * inpal) { int i, n, me = 0, flag[256], vid; int depth; long unsigned int plane_masks[3]; XColor pal[256]; int writeable_p; display.cmap = XDefaultColormap (display.dpy, display.screen); depth = DefaultDepth (display.dpy, display.screen); /* Decide, if the colormap is writable */ { Visual *visual = DefaultVisual (display.dpy, display.screen); #if defined(__cplusplus) || defined(c_plusplus) int visual_class = visual->c_class; #else int visual_class = visual->class; #endif writeable_p = (visual_class == PseudoColor || visual_class == GrayScale); } if (writeable_p) { if (XAllocColorCells (display.dpy, display.cmap, 0 ,plane_masks, 0, colour_table, 256) == 0) { me = (*DefaultVisual (display.dpy, display.screen)).map_entries; vid = (*DefaultVisual (display.dpy, display.screen)).visualid; display.cmap = XCreateColormap (display.dpy, display.win ,DefaultVisual (display.dpy, display.screen) /* ,PseudoColor */ ,AllocNone); if (me == 256 && depth != 24) { if (XAllocColorCells (display.dpy, display.cmap, 0 ,plane_masks, 0, colour_table, 256) != 0) { /* printf ("Allocated 256 cells\n"); */ } else { printf ("Couldn't allocate 256 cells\n"); } } else for (i = 0; i < 256; i++) colour_table[i] = i; } if (!display.cmap) HandleError ("No default colour map", FATAL); } for (i = 0; i < 256; i++) flag[i] = 0; for (n = 0; n < 256; n++) { pal[n].red = inpal[n].red << 10; pal[n].green = inpal[n].green << 10; pal[n].blue = inpal[n].blue << 10; pal[n].flags = DoRed | DoGreen | DoBlue; if (writeable_p) pal[n].pixel = colour_table[n]; else { if (XAllocColor (display.dpy ,display.cmap, &(pal[n])) == 0) HandleError ("alloc colour failed" ,FATAL); colour_table[n] = pal[n].pixel; XSetForeground (display.dpy ,display.pixcolour_gc[n] ,colour_table[n]); } flag[n] = 1; } if (writeable_p) { XStoreColors (display.dpy, display.cmap, pal, 256); XFlush (display.dpy); } XSetWindowColormap (display.dpy, display.win, display.cmap); }
/* *********************************************************************** * 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; }
static Bool InitializeAll(struct state *st) { XGCValues xgcv; XWindowAttributes xgwa; /* XSetWindowAttributes xswa;*/ Colormap cmap; XColor color; int n,i; double rspeed; st->cosilines = True; XGetWindowAttributes(st->dpy,st->win[0],&xgwa); cmap=xgwa.colormap; /* xswa.backing_store=Always; XChangeWindowAttributes(st->dpy,st->win[0],CWBackingStore,&xswa);*/ xgcv.function=GXcopy; xgcv.foreground=get_pixel_resource (st->dpy, cmap, "background", "Background"); st->fgc[32]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv); n=0; if (mono_p) { st->fgc[0]=st->fgc[32]; xgcv.foreground=get_pixel_resource (st->dpy, cmap, "foreground", "Foreground"); st->fgc[1]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv); for (i=0;i<32;i+=2) st->fgc[i]=st->fgc[0]; for (i=1;i<32;i+=2) st->fgc[i]=st->fgc[1]; } else for (i=0;i<32;i++) { color.red=colors[n++]<<8; color.green=colors[n++]<<8; color.blue=colors[n++]<<8; color.flags=DoRed|DoGreen|DoBlue; XAllocColor(st->dpy,cmap,&color); xgcv.foreground=color.pixel; st->fgc[i]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv); } st->cgc=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv); XSetGraphicsExposures(st->dpy,st->cgc,False); st->cosilines = get_boolean_resource(st->dpy, "random","Boolean"); #ifdef HAVE_DOUBLE_BUFFER_EXTENSION if (get_boolean_resource (st->dpy, "useDBE", "Boolean")) st->usedouble = True; st->win[1] = xdbe_get_backbuffer (st->dpy, st->win[0], XdbeUndefined); if (!st->win[1]) { st->usedouble = False; st->win[1] = st->win[0]; } #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ st->delay=get_integer_resource(st->dpy, "delay","Integer"); rspeed=get_float_resource(st->dpy, "speed","Float"); if (rspeed<0.0001 || rspeed>0.2) { fprintf(stderr,"Speed not in valid range! (0.0001 - 0.2), using 0.1 \n"); rspeed=0.1; } st->sizx=xgwa.width; st->sizy=xgwa.height; st->midx=st->sizx>>1; st->midy=st->sizy>>1; st->stateX=0; st->stateY=0; if (!make_rots(st,rspeed,rspeed)) { fprintf(stderr,"Not enough memory for tables!\n"); return False; } return True; }
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; }
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; }
void init_red() { red_gc = XCreateGC(dis, win, 0, 0); XParseColor(dis, colormap, red, &red_col); XAllocColor(dis, colormap, &red_col); XSetForeground(dis, red_gc, red_col.pixel); }
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 ; }
dsxc_lutcol (void) /* C-- */ { int k, ka, kdiv; Status istat; unsigned short int c; char flags; /* Cbegin */ DSOPEN = F77_NAMED_COMMON(ds_genb).dsopen; PDSOPEN = F77_NAMED_COMMON(ds_panelb).pdsopen; NUMDDCOL = F77_NAMED_COMMON(lutacom).numddcol; flags = DoRed | DoGreen | DoBlue; if ( DSOPEN || PDSOPEN ) { (void) dsxc_lutvget(); if ( OWNCOL ) { kdiv = LVX/NUMDDCOL; for ( k = 15; k<15+LVX; k++ ) { ka = 15 + ((k-15)/kdiv); COLOUR[ka].pixel = PC_ID[ka]; COLOUR[ka].flags = flags; c = LUTC_VAL[(k-15)][0]*65535.0; COLOUR[ka].red = c; c = LUTC_VAL[(k-15)][1]*65535.0; COLOUR[ka].green = c; c = LUTC_VAL[(k-15)][2]*65535.0; COLOUR[ka].blue = c; } XStoreColors ( VD_ID, CM_ID, COLOUR, 15+NUMDDCOL ); XInstallColormap ( VD_ID, CM_ID ); XFlush ( VD_ID ); } else { for (k = 15; k<15+LVX; k++ ) { COLOUR[k].flags = flags; c = LUTC_VAL[(k-15)][0]*65535.0; COLOUR[k].red = c; c = LUTC_VAL[(k-15)][1]*65535.0; COLOUR[k].green = c; c = LUTC_VAL[(k-15)][2]*65535.0; COLOUR[k].blue = c; istat = XAllocColor ( VD_ID, CM_ID, &COLOUR[k] ); if ( istat==0 ) { (void) c_printo ( "ERROR,x_lut: Colour pixel not allocated" ); PC_ID[k] = 0; } else PC_ID[k] = COLOUR[k].pixel; } XFlush ( VD_ID ); } } }
static Bool GradientLoader(XawParams *params, Screen *screen, Colormap colormap, int depth, Pixmap *pixmap_return, Pixmap *mask_return, Dimension *width_return, Dimension *height_return) { double ired, igreen, iblue, red, green, blue; XColor start, end, color; XGCValues values; GC gc; double i, inc, x, y, xend, yend; Pixmap pixmap; XawArgVal *argval; int orientation, dimension, steps; char *value; if (XmuCompareISOLatin1(params->name, "vertical") == 0) orientation = VERTICAL; else if (XmuCompareISOLatin1(params->name, "horizontal") == 0) orientation = HORIZONTAL; else return (False); if ((argval = XawFindArgVal(params, "dimension")) != NULL && argval->value) { dimension = atoi(argval->value); if (dimension <= 0) return (False); } else dimension = 50; if ((argval = XawFindArgVal(params, "steps")) != NULL && argval->value) { steps = atoi(argval->value); if (steps <= 0) return (False); } else steps = dimension; steps = XawMin(steps, dimension); value = NULL; if ((argval = XawFindArgVal(params, "start")) != NULL) value = argval->value; if (value && !XAllocNamedColor(DisplayOfScreen(screen), colormap, value, &start, &color)) return (False); else if (!value) { start.pixel = WhitePixelOfScreen(screen); XQueryColor(DisplayOfScreen(screen), colormap, &start); } value = NULL; if ((argval = XawFindArgVal(params, "end")) != NULL) value = argval->value; if (value && !XAllocNamedColor(DisplayOfScreen(screen), colormap, value, &end, &color)) return (False); else if (!value) { end.pixel = BlackPixelOfScreen(screen); XQueryColor(DisplayOfScreen(screen), colormap, &end); } if ((pixmap = XCreatePixmap(DisplayOfScreen(screen), RootWindowOfScreen(screen), orientation == VERTICAL ? 1 : dimension, orientation == VERTICAL ? dimension : 1, depth)) == 0) return (False); ired = (double)(end.red - start.red) / (double)steps; igreen = (double)(end.green - start.green) / (double)steps; iblue = (double)(end.blue - start.blue) / (double)steps; red = color.red = start.red; green = color.green = start.green; blue = color.blue = start.blue; inc = (double)dimension / (double)steps; gc = XCreateGC(DisplayOfScreen(screen), pixmap, 0, &values); x = y = 0.0; if (orientation == VERTICAL) { xend = 1; yend = 0; } else { xend = 0; yend = 1; } color.flags = DoRed | DoGreen | DoBlue; XSetForeground(DisplayOfScreen(screen), gc, start.pixel); for (i = 0.0; i < dimension; i += inc) { if ((int)color.red != (int)red || (int)color.green != (int)green || (int)color.blue != (int)blue) { XFillRectangle(DisplayOfScreen(screen), pixmap, gc, (int)x, (int)y, (unsigned int)xend, (unsigned int)yend); color.red = (unsigned short)red; color.green = (unsigned short)green; color.blue = (unsigned short)blue; if (!XAllocColor(DisplayOfScreen(screen), colormap, &color)) { XFreePixmap(DisplayOfScreen(screen), pixmap); return (False); } XSetForeground(DisplayOfScreen(screen), gc, color.pixel); if (orientation == VERTICAL) y = yend; else x = xend; } red += ired; green += igreen; blue += iblue; if (orientation == VERTICAL) yend += inc; else xend += inc; } XFillRectangle(DisplayOfScreen(screen), pixmap, gc, (int)x, (int)y, (unsigned int)xend, (unsigned int)yend); *pixmap_return = pixmap; *mask_return = None; *width_return = orientation == VERTICAL ? 1 : dimension; *height_return = orientation == VERTICAL ? dimension : 1; XFreeGC(DisplayOfScreen(screen), gc); return (True); }
WTexSolid *wTextureMakeSolid(WScreen * scr, XColor * color) { WTexSolid *texture; int gcm; XGCValues gcv; texture = wmalloc(sizeof(WTexture)); texture->type = WTEX_SOLID; texture->subtype = 0; XAllocColor(dpy, scr->w_colormap, color); texture->normal = *color; if (color->red == 0 && color->blue == 0 && color->green == 0) { texture->light.red = 0xb6da; texture->light.green = 0xb6da; texture->light.blue = 0xb6da; texture->dim.red = 0x6185; texture->dim.green = 0x6185; texture->dim.blue = 0x6185; } else { RColor rgb; RHSVColor hsv, hsv2; int v; rgb.red = color->red >> 8; rgb.green = color->green >> 8; rgb.blue = color->blue >> 8; RRGBtoHSV(&rgb, &hsv); RHSVtoRGB(&hsv, &rgb); hsv2 = hsv; v = hsv.value * 16 / 10; hsv.value = (v > 255 ? 255 : v); RHSVtoRGB(&hsv, &rgb); texture->light.red = rgb.red << 8; texture->light.green = rgb.green << 8; texture->light.blue = rgb.blue << 8; hsv2.value = hsv2.value / 2; RHSVtoRGB(&hsv2, &rgb); texture->dim.red = rgb.red << 8; texture->dim.green = rgb.green << 8; texture->dim.blue = rgb.blue << 8; } texture->dark.red = 0; texture->dark.green = 0; texture->dark.blue = 0; XAllocColor(dpy, scr->w_colormap, &texture->light); XAllocColor(dpy, scr->w_colormap, &texture->dim); XAllocColor(dpy, scr->w_colormap, &texture->dark); gcm = GCForeground | GCBackground | GCGraphicsExposures; gcv.graphics_exposures = False; gcv.background = gcv.foreground = texture->light.pixel; texture->light_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv); gcv.background = gcv.foreground = texture->dim.pixel; texture->dim_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv); gcv.background = gcv.foreground = texture->dark.pixel; texture->dark_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv); gcv.background = gcv.foreground = color->pixel; texture->normal_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv); return texture; }
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); }
// #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; }
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; }
void init_tik_tak(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i, max_objects, size_object; tik_takstruct *tiktak; /* initialize */ if (tik_taks == NULL) { if ((tik_taks = (tik_takstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (tik_takstruct))) == NULL) return; } tiktak = &tik_taks[MI_SCREEN(mi)]; tiktak->mi = mi; if (tiktak->gc == None) { if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { XColor color; #ifndef STANDALONE tiktak->fg = MI_FG_PIXEL(mi); tiktak->bg = MI_BG_PIXEL(mi); #endif tiktak->blackpixel = MI_BLACK_PIXEL(mi); tiktak->whitepixel = MI_WHITE_PIXEL(mi); if ((tiktak->cmap = XCreateColormap(display, window, MI_VISUAL(mi), AllocNone)) == None) { free_tik_tak(display, tiktak); return; } XSetWindowColormap(display, window, tiktak->cmap); (void) XParseColor(display, tiktak->cmap, "black", &color); (void) XAllocColor(display, tiktak->cmap, &color); MI_BLACK_PIXEL(mi) = color.pixel; (void) XParseColor(display, tiktak->cmap, "white", &color); (void) XAllocColor(display, tiktak->cmap, &color); MI_WHITE_PIXEL(mi) = color.pixel; #ifndef STANDALONE (void) XParseColor(display, tiktak->cmap, background, &color); (void) XAllocColor(display, tiktak->cmap, &color); MI_BG_PIXEL(mi) = color.pixel; (void) XParseColor(display, tiktak->cmap, foreground, &color); (void) XAllocColor(display, tiktak->cmap, &color); MI_FG_PIXEL(mi) = color.pixel; #endif tiktak->colors = (XColor *) NULL; tiktak->ncolors = 0; } if ((tiktak->gc = XCreateGC(display, MI_WINDOW(mi), (unsigned long) 0, (XGCValues *) NULL)) == None) { free_tik_tak(display, tiktak); return; } } /* Clear Display */ MI_CLEARWINDOW(mi); tiktak->painted = False; XSetFunction(display, tiktak->gc, GXxor); /*Set up tik_tak data */ tiktak->direction = (LRAND() & 1) ? 1 : -1; tiktak->win_width = MI_WIDTH(mi); tiktak->win_height = MI_HEIGHT(mi); tiktak->num_object = MI_COUNT(mi); tiktak->x0 = tiktak->win_width / 2; tiktak->y0 = tiktak->win_height / 2; max_objects = MI_COUNT(mi); if (tiktak->num_object == 0) { tiktak->num_object = DEF_NUM_OBJECT; max_objects = DEF_NUM_OBJECT; } else if (tiktak->num_object < 0) { max_objects = -tiktak->num_object; tiktak->num_object = NRAND(-tiktak->num_object) + 1; } if (tiktak->object == NULL) if ((tiktak->object = (tik_takobject *) calloc(max_objects, sizeof (tik_takobject))) == NULL) { free_tik_tak(display, tiktak); return; } size_object = MIN( tiktak->win_width , tiktak->win_height) / 3; if ( abs( MI_SIZE(mi) ) > size_object) { if ( MI_SIZE( mi ) < 0 ) { size_object = -size_object; } } else { size_object = MI_SIZE(mi); } if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { /* Set up colour map */ if (tiktak->colors != NULL) { if (tiktak->ncolors && !tiktak->no_colors) free_colors(display, tiktak->cmap, tiktak->colors, tiktak->ncolors); free(tiktak->colors); tiktak->colors = (XColor *) NULL; } tiktak->ncolors = MI_NCOLORS(mi); if (tiktak->ncolors < 2) tiktak->ncolors = 2; if (tiktak->ncolors <= 2) tiktak->mono_p = True; else tiktak->mono_p = False; if (tiktak->mono_p) tiktak->colors = (XColor *) NULL; else if ((tiktak->colors = (XColor *) malloc(sizeof (*tiktak->colors) * (tiktak->ncolors + 1))) == NULL) { free_tik_tak(display, tiktak); return; } tiktak->cycle_p = has_writable_cells(mi); if (tiktak->cycle_p) { if (MI_IS_FULLRANDOM(mi)) { if (!NRAND(8)) tiktak->cycle_p = False; else tiktak->cycle_p = True; } else { tiktak->cycle_p = cycle_p; } } if (!tiktak->mono_p) { if (!(LRAND() % 10)) make_random_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tiktak->cmap, tiktak->colors, &tiktak->ncolors, True, True, &tiktak->cycle_p); else if (!(LRAND() % 2)) make_uniform_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tiktak->cmap, tiktak->colors, &tiktak->ncolors, True, &tiktak->cycle_p); else make_smooth_colormap( #ifdef STANDALONE MI_DISPLAY(mi), MI_WINDOW(mi), #else mi, #endif tiktak->cmap, tiktak->colors, &tiktak->ncolors, True, &tiktak->cycle_p); } XInstallColormap(display, tiktak->cmap); if (tiktak->ncolors < 2) { tiktak->ncolors = 2; tiktak->no_colors = True; } else tiktak->no_colors = False; if (tiktak->ncolors <= 2) tiktak->mono_p = True; if (tiktak->mono_p) tiktak->cycle_p = False; } for (i = 0; i < tiktak->num_object; i++) { tik_takobject *object0; object0 = &tiktak->object[i]; if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) { if (tiktak->ncolors > 2) object0->colour = NRAND(tiktak->ncolors - 2) + 2; else object0->colour = 1; /* Just in case */ XSetForeground(display, tiktak->gc, tiktak->colors[object0->colour].pixel); } else { if (MI_NPIXELS(mi) > 2) object0->colour = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi))); else object0->colour = 1; /*Xor'red so WHITE may not be appropriate */ XSetForeground(display, tiktak->gc, object0->colour); } object0->angle = NRAND(90) * PI_RAD; object0->angle1 = NRAND(90) * PI_RAD; object0->velocity_a = (NRAND(7) - 3) * PI_RAD; object0->velocity_a1 = (NRAND(7) - 3) * PI_RAD; if (size_object == 0) object0->size_ob = 9; else if (size_object > 0) object0->size_ob = size_object; else object0->size_ob = NRAND(-size_object) + 1; object0->size_ob++; object0->num_point = NRAND(6)+3; if (LRAND() & 1) object0->size_mult = 1.0; else { object0->num_point *= 2; object0->size_mult = 1.0 - ( 1.0 / (float) ((LRAND() & 1) + 2 ) ); } if (object0->xy != NULL) free(object0->xy); if ((object0->xy = (XPoint *) malloc(sizeof( XPoint ) * (2 * object0->num_point + 2))) == NULL) { free_tik_tak(display, tiktak); return; } if ((LRAND() & 1) || object0->size_ob < 10 ) { object0->inner = False; if ( object0->xy1 != NULL ) free( object0->xy1 ); object0->xy1 = (XPoint *) NULL; } else { object0->inner = True; object0->size_ob1 = object0->size_ob - NRAND( object0->size_ob / 5 ) - 1; object0->num_point1 = NRAND(6)+3; if (LRAND() & 1) object0->size_mult1 = 1.0; else { object0->num_point1 *= 2; object0->size_mult1 = 1.0 - ( 1.0 / (float) ((LRAND() & 1) + 2 ) ); } if (object0->xy1 != NULL) free(object0->xy1); if ((object0->xy1 = (XPoint *) malloc(sizeof( XPoint ) * (2 * object0->num_point1 + 2))) == NULL) { free_tik_tak(display, tiktak); return; } object0->size_mult1 = 1.0; } tik_tak_setupobject( mi , object0); tik_tak_reset_object( object0); tik_tak_drawobject(mi, object0 ); } XFlush(display); XSetFunction(display, tiktak->gc, GXcopy); }
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
static void winopen(void) { XWMHints *wmhints; XClassHint *classhint; xdpy = XOpenDisplay(NULL); if (!xdpy) fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot open display"); XA_CLIPBOARD = XInternAtom(xdpy, "CLIPBOARD", False); XA_TARGETS = XInternAtom(xdpy, "TARGETS", False); XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False); XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False); WM_DELETE_WINDOW = XInternAtom(xdpy, "WM_DELETE_WINDOW", False); NET_WM_STATE = XInternAtom(xdpy, "_NET_WM_STATE", False); NET_WM_STATE_FULLSCREEN = XInternAtom(xdpy, "_NET_WM_STATE_FULLSCREEN", False); WM_RELOAD_PAGE = XInternAtom(xdpy, "_WM_RELOAD_PAGE", False); xscr = DefaultScreen(xdpy); ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr)); xcarrow = XCreateFontCursor(xdpy, XC_left_ptr); xchand = XCreateFontCursor(xdpy, XC_hand2); xcwait = XCreateFontCursor(xdpy, XC_watch); xccaret = XCreateFontCursor(xdpy, XC_xterm); xbgcolor.red = 0x7000; xbgcolor.green = 0x7000; xbgcolor.blue = 0x7000; xshcolor.red = 0x4000; xshcolor.green = 0x4000; xshcolor.blue = 0x4000; XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor); XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor); xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy), 10, 10, 200, 100, 0, ximage_get_depth(), InputOutput, ximage_get_visual(), 0, NULL); if (xwin == None) fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot create window"); XSetWindowColormap(xdpy, xwin, ximage_get_colormap()); XSelectInput(xdpy, xwin, StructureNotifyMask | ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask); mapped = 0; xgc = XCreateGC(xdpy, xwin, 0, NULL); XDefineCursor(xdpy, xwin, xcarrow); wmhints = XAllocWMHints(); if (wmhints) { wmhints->flags = IconPixmapHint | IconMaskHint; xicon = XCreateBitmapFromData(xdpy, xwin, (char*)mupdf_icon_bitmap_16_bits, mupdf_icon_bitmap_16_width, mupdf_icon_bitmap_16_height); xmask = XCreateBitmapFromData(xdpy, xwin, (char*)mupdf_icon_bitmap_16_mask_bits, mupdf_icon_bitmap_16_mask_width, mupdf_icon_bitmap_16_mask_height); if (xicon && xmask) { wmhints->icon_pixmap = xicon; wmhints->icon_mask = xmask; XSetWMHints(xdpy, xwin, wmhints); } XFree(wmhints); } classhint = XAllocClassHint(); if (classhint) { classhint->res_name = "mupdf"; classhint->res_class = "MuPDF"; XSetClassHint(xdpy, xwin, classhint); XFree(classhint); } XSetWMProtocols(xdpy, xwin, &WM_DELETE_WINDOW, 1); x11fd = ConnectionNumber(xdpy); }
int main (int argc, char **argv) { Display *dpy; int opt, ncolors = 0, i; XColor *allocated; int nallocated; XColor color; Colormap cmap; while ((opt = getopt (argc, argv, "n:")) != EOF) switch (opt) { case 'n': ncolors = atoi (optarg); break; case '?': usage (argv[0]); } if (ncolors == 0) usage (argv[0]); dpy = XOpenDisplay (""); if (dpy == NULL) fatal ("Cannot open display"); cmap = DefaultColormap (dpy, 0); allocated = malloc (ncolors * sizeof *allocated); nallocated = 0; memset (&color, 0, sizeof color); while (nallocated < ncolors && color.red < 65536) { allocated[nallocated] = color; if (XAllocColor (dpy, cmap, &allocated[nallocated])) { for (i = 0; i < nallocated; ++i) if (allocated[i].red == allocated[nallocated].red && allocated[i].green == allocated[nallocated].green && allocated[i].blue == allocated[nallocated].blue) break; if (i == nallocated) { printf ("allocated %d/%d/%d\n", allocated[nallocated].red, allocated[nallocated].green, allocated[nallocated].blue); ++nallocated; } } ++color.red; ++color.green; ++color.blue; } fprintf (stderr, "Waiting. Press ^C to stop.\n"); while (1) sleep (10); XCloseDisplay (dpy); return 0; }