コード例 #1
0
ファイル: xemul.c プロジェクト: sakhnik/ThermoPlast
	GC
create_gc(Display* display, Window win, int reverse_video)
{
	GC gc;
	unsigned long valuemask = 0;
	XGCValues values;
	unsigned int line_width = 2;
	int line_style = LineSolid;
	int cap_style = CapButt;
	int join_style = JoinBevel;
	int screen_num = DefaultScreen(display);

	gc = XCreateGC(display, win, valuemask, &values);
	if (gc < 0) {
		fprintf(stderr, "XCreateGC: \n");
	}

	if (reverse_video) {
		XSetForeground(display, gc, WhitePixel(display, screen_num));
		XSetBackground(display, gc, BlackPixel(display, screen_num));
	}
	else {
		XSetForeground(display, gc, BlackPixel(display, screen_num));
		XSetBackground(display, gc, WhitePixel(display, screen_num));
	}

	XSetLineAttributes(display, gc,
			line_width, line_style, cap_style, join_style);

	XSetFillStyle(display, gc, FillSolid);

	return gc;
}
コード例 #2
0
ファイル: xpainter.cpp プロジェクト: neurodebian/iv-hines
void Painter::SetColors(const Color* f, const Color* b) {
    if (rep->iv_xor) {
	End_xor();
    }

    /*
     * Make sure to reference both new colors before unreferencing the old
     * in case the call is swapping colors.
     */
    if (foreground != f) {
	Resource::ref(f);
    }
    if (background != b) {
	Resource::ref(b);
    }

    XDisplay* dpy = rep->display->rep()->display_;
    if (f != nil && foreground != f) {
	Resource::unref(foreground);
	foreground = f;
	unsigned long pixel = foreground->PixelValue();
        XSetForeground(dpy, rep->fillgc, pixel);
        XSetForeground(dpy, rep->dashgc, pixel);
    }

    if (b != nil && background != b) {
	Resource::unref(background);
	background = b;
	unsigned long pixel = background->PixelValue();
	XSetBackground(dpy, rep->fillgc, pixel);
	XSetBackground(dpy, rep->dashgc, pixel);
    }
}
コード例 #3
0
ファイル: xf_graphics.c プロジェクト: jat255/FreeRDP
static BOOL xf_Glyph_BeginDraw(rdpContext* context, UINT32 x, UINT32 y,
                               UINT32 width, UINT32 height, UINT32 bgcolor,
                               UINT32 fgcolor, BOOL fOpRedundant)
{
	xfContext* xfc = (xfContext*) context;
	XRectangle rect;
	XColor xbgcolor, xfgcolor;

	if (!xf_decode_color(xfc, bgcolor, &xbgcolor))
		return FALSE;

	if (!xf_decode_color(xfc, fgcolor, &xfgcolor))
		return FALSE;

	rect.x = x;
	rect.y = y;
	rect.width = width;
	rect.height = height;
	xf_lock_x11(xfc, FALSE);

	if (!fOpRedundant)
	{
		XSetForeground(xfc->display, xfc->gc, xfgcolor.pixel);
		XSetBackground(xfc->display, xfc->gc, xfgcolor.pixel);
		XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
		XFillRectangle(xfc->display, xfc->drawable, xfc->gc, x, y, width, height);
	}

	XSetForeground(xfc->display, xfc->gc, xbgcolor.pixel);
	XSetBackground(xfc->display, xfc->gc, xfgcolor.pixel);
	xf_unlock_x11(xfc, FALSE);
	return TRUE;
}
コード例 #4
0
ファイル: mandelbrot.c プロジェクト: Aslan-Apps/Mandelbrot
GC create_gc(Display* display, Window win, int reverse_video){
  	GC gc;                                /* handle of newly created GC.  */
  	unsigned long valuemask = 0;          /* which values in 'values' to  */
    /* check when creating the GC.  */
  	XGCValues values;                     /* initial values for the GC.   */
  	unsigned int line_width = 2;          /* line width for the GC.       */
  	int line_style = LineSolid;           /* style for lines drawing and  */
  	int cap_style = CapButt;              /* style of the line's edje and */
  	int join_style = JoinBevel;           /*  joined lines.               */
  	int screen_num = DefaultScreen(display);
    
  	gc = XCreateGC(display, win, valuemask, &values);
  	if (gc < 0) {
        fprintf(stderr, "XCreateGC: \n");
  	}
    
  	/* allocate foreground and background colors for this GC. */
  	if (reverse_video) {
        XSetForeground(display, gc, WhitePixel(display, screen_num));
        XSetBackground(display, gc, BlackPixel(display, screen_num));
  	}
  	else {
        XSetForeground(display, gc, BlackPixel(display, screen_num));
        XSetBackground(display, gc, WhitePixel(display, screen_num));
  	}
    
  	/* define the style of lines that will be drawn using this GC. */
  	XSetLineAttributes(display, gc,
                       line_width, line_style, cap_style, join_style);
    
  	/* define the fill style for the GC. to be 'solid filling'. */
  	XSetFillStyle(display, gc, FillSolid);
    
  	return gc;
}
コード例 #5
0
ファイル: setbkcolor.c プロジェクト: romanz/crystal-maze-3d
void setbkcolor(int color)
{
        XColor background;
        XColor unused;
        char *bg;
        int screen_number;
	int rc;

#ifdef ALLOCATE_COLOR_CELLS
	XStoreNamedColor(dpy, cmap, Colors[color], background_pixel,
			 (DoRed|DoGreen|DoBlue));
#else
  if (-1 == color) { // returned by COLOR()
    XSetBackground(dpy, gc, current_rgb_colour);
    if (visual_page == active_page)
      XSetWindowBackground(dpy, window, current_rgb_colour);
    bg_rgb_colour = current_rgb_colour;
  }
  else {
    rc = XSetBackground(dpy, gc, vga_palette[color].pixel_value);
    
    if (visual_page == active_page) { 
      XSetWindowBackground(dpy, window, vga_palette[color].pixel_value);
    }
    bg_colour = color;
  }
    
#endif
}
コード例 #6
0
ファイル: spore.c プロジェクト: doctorfree/Spore
void
init_contexts()
{
    static int i;

    /*
     * create default, writable, graphics contexts for the canvas.
     */
    Data_GC[0] = XCreateGC(dpy, DefaultRootWindow(dpy),
        (unsigned long) NULL, (XGCValues *) NULL);
    /* set the background to black */
    XSetBackground(dpy,Data_GC[0],BlackPixel(dpy, screen));
    /* set the foreground of the 0th context to black */
    XSetForeground(dpy, Data_GC[0], BlackPixel(dpy, screen));
    Data_GC[1] = XCreateGC(dpy, DefaultRootWindow(dpy),
        (unsigned long) NULL, (XGCValues *) NULL);
    /* set the background to black */
    XSetBackground(dpy,Data_GC[1],BlackPixel(dpy, screen));
    /* set the foreground of the 1st context to white */
    XSetForeground(dpy, Data_GC[1], WhitePixel(dpy,  screen));
    for (i=2; i<maxcolor; i++) {
        Data_GC[i] = XCreateGC(dpy, DefaultRootWindow(dpy),
            (unsigned long) NULL, (XGCValues *) NULL);
        /* set the background to black */
        XSetBackground(dpy,Data_GC[i],BlackPixel(dpy, screen));
        /* set the foreground of the ith context to i */
        XSetForeground(dpy, Data_GC[i], i);
    }
}
コード例 #7
0
void MyFrame::init_graphics()
{
    /* global variables */
    Widget canvas;
    Display *theDisplay;
    XImage *pic_array[MAXIMAGES];
    GC invertGC, drawGC;

    int scrn;
    Display *dpy;
    Window grwin;
    Colormap fixedcmap;
    unsigned long blackPix, whitePix;

    unsigned int depth;
    Visual *use_visual;

    dpy = XtDisplay(canvas);
    grwin = XtWindow(canvas);
    scrn = DefaultScreen(dpy);
    use_visual = DefaultVisual(dpy, scrn);
#if 1
    fixedcmap = XCreateColormap(dpy, grwin, use_visual, AllocNone);
#else
    fixedcmap = DefaultColormap(dpy, scrn);
#endif
    fixedcmap = InitColorTableFixed(fixedcmap);

    XtVaGetValues(canvas, XmNdepth, &depth, NULL);

    XtVaSetValues(toplevel, XmNcolormap, fixedcmap, NULL);
    XtSetWMColormapWindows(toplevel, &canvas, 1);

    /**************************************************************/

    blackPix = _get_lookup_for_color(0, 0, 0);
    whitePix = _get_lookup_for_color(255, 255, 255);

    drawGC =
        XCreateGC(XtDisplay(canvas), XtWindow(canvas), (unsigned long)0,
                  NULL);

    theDisplay = XtDisplay(toplevel);

    XSetFunction(theDisplay, drawGC, GXcopy);
    XSetForeground(theDisplay, drawGC, blackPix);
    XSetBackground(theDisplay, drawGC, whitePix);

    invertGC =
        XCreateGC(XtDisplay(canvas), XtWindow(canvas), (unsigned long)0,
                  NULL);
    XSetFunction(theDisplay, invertGC, GXcopy);
    XSetForeground(theDisplay, invertGC, whitePix);
    XSetBackground(theDisplay, invertGC, blackPix);

}
コード例 #8
0
ファイル: XSpadFill.c プロジェクト: acralfs/fricas
GC
SpadFillGC(Display *dsply,int  hue, int theshade,char * fill_routine)
{
    int dither;
    int color;


    if (!SpadFillInit) {
        fprintf(stderr, "Tried to use SpadFillGC before calling XInitSpadFill\n");
        exit(0);
    }

    if (theshade >= totalShades) {
        fprintf(stderr, "Shade %d out of range\n",theshade);
        exit(-1);
    }
    if (hue >= totalHues) {
        fprintf(stderr, "Error Hue %d is out of range\n",hue);
        exit(-1);
    }
    dither = ((theshade) % (totalDithered - 1));
    if (dither != 0) {
        XChangeDither(dsply, stippleGC, dither);
        if (theshade < totalDithered) {    /* Dither to black */
            color = totalSolid * hue;
            XSetForeground(dsply, stippleGC, black);
            XSetBackground(dsply, stippleGC, spadColors[color]);
        }
        else if (theshade > (totalShades - totalDithered)) {       /* Dither to white */
            color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1;
            XSetForeground(dsply, stippleGC, spadColors[color]);
            XSetBackground(dsply, stippleGC, white);
        }
        else {
            color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1;
            XSetForeground(dsply, stippleGC, spadColors[color]);
            XSetBackground(dsply, stippleGC, spadColors[color + 1]);
        }
        return (stippleGC);
    }
    else {
        if (theshade == 0)
            XSetForeground(dsply, solidGC, black);
        else if (theshade == (totalShades - 1))
            XSetForeground(dsply, solidGC, white);
        else {
            color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1;
            XSetForeground(dsply, solidGC, spadColors[color]);
        }
        return (solidGC);
    }

}
コード例 #9
0
ファイル: main.c プロジェクト: itdaniher/SucklessDebXO
static void
x_create_gcs(void) {
	/* normal GC */
	dzen.gc  = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), 0, 0);
	XSetForeground(dzen.dpy, dzen.gc, dzen.norm[ColFG]);
	XSetBackground(dzen.dpy, dzen.gc, dzen.norm[ColBG]);
	/* reverse color GC */
	dzen.rgc = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), 0, 0);
	XSetForeground(dzen.dpy, dzen.rgc, dzen.norm[ColBG]);
	XSetBackground(dzen.dpy, dzen.rgc, dzen.norm[ColFG]);
	/* temporary GC */
	dzen.tgc = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), 0, 0);
}
コード例 #10
0
static void ui_sel_showSelectedItem (struct Ui_DisplayType *displayPtr,
		FlagType scope, int unitNo, struct PosType gridPos)

{   
    struct PosType  pos1, pos2;
    struct Ui_DisplayType *dPtr;

    if (scope == UI_GLOBAL) {
	for (dPtr = ui_displ_listPtr;
	     dPtr != NULL;
	     dPtr = dPtr ->nextPtr)
	    ui_sel_showSelectedItem(dPtr, UI_LOCAL, unitNo, gridPos);
    } else {
	if ((NOT displayPtr->frozen) AND 
	    ui_isUnitVisibleInDisplay(displayPtr, unitNo)) { 
	    if (ui_col_colorDisplay) {
		XSetFunction(ui_display, ui_gc, GXcopy);
		XSetBackground(ui_display, ui_gc, 
			       ui_backgroundColor);
		XSetForeground(ui_display, ui_gc, 
			       ui_selectionColor);
	    } else {
		XSetFunction(ui_display, ui_gc, GXcopyInverted);
		XSetBackground(ui_display, ui_gc, 
			       ui_backgroundColor);
		XSetForeground(ui_display, ui_gc, 
			       ui_textColor);
	    }
	    
	    pos1    = ui_utilGridToPix(displayPtr, gridPos);
	    pos1.x -= (ui_selectionSize / 2);
	    pos1.y -= (ui_selectionSize / 2);
	    pos2.x  = pos1.x + ui_selectionSize - 1;
	    pos2.y  = pos1.y + ui_selectionSize - 1;
	    /* ui_xDeleteRect(ui_display, displayPtr->drawable, 
	       ui_gc, pos1, pos2); */
	    if (ui_col_colorDisplay)
		ui_xDeleteRect(ui_display, displayPtr->drawable, ui_gc,
			       pos1, pos2);
	    else {
		ui_xDeleteRect(ui_display, displayPtr->drawable, ui_gc,
			       pos1, pos2);
		XSetFunction(ui_display, ui_gc, GXcopy);
		ui_xDrawCrossBox(ui_display, displayPtr->drawable, 
				 ui_gc, pos1, pos2);
	    }
	}
    }
}
コード例 #11
0
ファイル: gfx.c プロジェクト: 16Bitt/forthstrap
//F gfx_init gfx 0 0
void gfx_init(){
	//Initialize our environment
	disp = XOpenDisplay(NULL);
	screen = DefaultScreen(disp);
	fg = WhitePixel(disp, screen);
	bg = BlackPixel(disp, screen);
	
	cm = DefaultColormap(disp, DefaultScreen(disp));
	colors = (XColor*) malloc(sizeof(XColor) * 8);
	
	int err = 0;
	err = XAllocNamedColor(disp, cm, "white", &colors[0], &colors[0]);
	err += XAllocNamedColor(disp, cm, "black", &colors[1], &colors[1]);
	err += XAllocNamedColor(disp, cm, "red", &colors[2], &colors[2]);
	err += XAllocNamedColor(disp, cm, "blue", &colors[3], &colors[3]);
	err += XAllocNamedColor(disp, cm, "green", &colors[4], &colors[4]);
	
	if(err == 0){
		puts("Failed to allocate color!!!");
		exit(-1);
	}

	//Register our window with default properties
	win = XCreateSimpleWindow(disp, DefaultRootWindow(disp), \
		200, 200, 640, 480, 5, fg, bg);
	XSetStandardProperties(disp, win, title, "Placeholder", None, NULL, 0, NULL);
	
	//Initialize the graphics and input
	context = XCreateGC(disp, win, 0, 0);
	XSetBackground(disp, context, bg);
	XSetForeground(disp, context, fg);
        XClearWindow(disp, win);
        XMapWindow(disp, win);
}
コード例 #12
0
ファイル: xwin.c プロジェクト: pmkenned/tidbits
void init_x() {
	unsigned long black,white;

	dis=XOpenDisplay((char *)0);

	if(dis == NULL) {
	    fprintf(stderr,"error: cannot open window\n");
	    exit(1);
    }

	screen = DefaultScreen(dis);
	black = BlackPixel(dis,screen),	/* get color black */
	white = WhitePixel(dis, screen);  /* get color white */

	win = XCreateSimpleWindow(dis,DefaultRootWindow(dis),0,0,	
		200, 300, 5, black, white);

	XSetStandardProperties(dis,win,"My Window","HI!",None,NULL,0,NULL);

	XSelectInput(dis, win, ExposureMask|ButtonPressMask|KeyPressMask);

	gc=XCreateGC(dis, win, 0,0);        

	XSetBackground(dis,gc,white);
	XSetForeground(dis,gc,black);

	XClearWindow(dis, win);
	XMapRaised(dis, win);
}
コード例 #13
0
ファイル: test.c プロジェクト: MayKeoN/ysh
void
handleButtonPress    (XEvent *myevent, struct drawing *canvas,
                      struct window *win)
/* Zoom in on the mouse pointer */
{
   double range = 0.0;


   range = fractal_options.range;

   /* center clicked area */
   fractal_options.origin.real += (double) (range * myevent->xbutton.x)
                                / (double) (canvas->width * 2.0);
   fractal_options.origin.imag -= (double) (range * myevent->xbutton.y)
                                / (double) (canvas->height * 2.0);

   /* and magnify */
   fractal_options.range /= 2.0;

   /* increase the depth so there's a picture worth looking at */
   fractal_options.depth *= 2.0;

   print_fractal_info ();

   XSetForeground (win->display, win->gc, 0x00);
   XSetBackground (win->display, win->gc, 0x00);
   XFillRectangle (win->display, canvas->pixmap, win->gc, 0, 0,
                   canvas->width, canvas->height);
   XClearWindow (win->display, win->win);
   if (fractal_options.type == MANDELBROT)
      mandelbrot (canvas, win);
   else
      julia (canvas, win);
}
コード例 #14
0
ファイル: ifr_xtext.c プロジェクト: clemej/ifrac
void draw_score_board(PANE_TYPE which_pane)
{
    int i, y;
    const char *string;

    PANE  pane = all_panes[which_pane];
	
	XSetForeground(disp, gc, cm_pixels[bkgr_colour]);
    XFillRectangle(disp, pane, gc, ScoreX-5, ScoreY-5, ScoreWidth+10, ScoreHeight+10);         
    XSetForeground(disp, gc, cm_pixels[score_colour]);
    XDrawRectangle(disp, pane, gc, ScoreX-5, ScoreY-5, ScoreWidth+10, ScoreHeight+10);         
    XDrawRectangle(disp, pane, gc, ScoreX-3, ScoreY-3, ScoreWidth+6, ScoreHeight+6);         
	if (ConsFont == 0) 
	{  XSetBackground(disp, gc, cm_pixels[bkgr_colour]);
	   XSetFont(disp, gc, FontId[FT_FIXED]);
	}	   

    for (i=0; i< ScoreLines; i++)
	{
	  string = ScoreLineText[i];
	  y = ScoreLineY[i];

	  if (ConsFont == 0)
		XDrawImageString (disp, pane, gc, ScoreLineX, y, 
			string, strlen(string));	
	  else
  		show_shadow_text(which_pane, FT_FIXED,
  		  string, ScoreLineX, y-FixedFontAscent, 1, 1, 0, 0,
	      score_colour, bkgr_colour, ST_NO_STIPPLE);
    }
	
	flush_pane(which_pane, ScoreX-5, ScoreY-5, ScoreWidth+10, ScoreHeight+10);         
}
コード例 #15
0
void paintLabel(AppInfo *app, Drawable draw, LabelInfo label)
{
   TextObject *t;
   Position x;
   Position y;

   if (!(label.fullText)) {
      return;
   }
   XSetForeground(app->dpy, app->textGC, label.w.foreground);
   XSetBackground(app->dpy, app->textGC, label.w.background);
   XSetFont(app->dpy, app->textGC, label.font->fid);
   
   t = label.multiText;
   x = label.w.x;
   y = label.w.y + t->ascent;
   while (NULL != t) {
      if (t->text) {
	 XDrawString(app->dpy, draw, app->textGC, x, y, t->text,
		     t->textLength);
      }
      y += t->descent;
      t = t->next;
      if (t) {
	 y += t->ascent;
      }
   }
}
コード例 #16
0
ファイル: wmAppKill.c プロジェクト: d-torrance/dockapps
void CreateDock(int argc, char *argv[])    /* this part comes from http://www.linuxmag-france.org/ */
{
   Window root;
   XWMHints wmHints;
   XSizeHints sizeHints;
   XClassHint classHint;
   Pixmap pixmask;
   unsigned long p_blanc;
   unsigned long p_noir;
   unsigned int borderWidth = 2;
   char *wname = argv[0] ;

   dpy = XOpenDisplay(NULL) ;

   if(dpy == NULL)
	  {
	     fprintf(stderr, "Can't open display\n") ;
	     exit(1) ;
	  }

   root = RootWindow(dpy,screen);
   p_blanc = WhitePixel(dpy,screen) ;
   p_noir = BlackPixel(dpy,screen) ;
   gc = XDefaultGC(dpy,screen) ;
   XSetForeground(dpy, gc, p_noir);
   XSetBackground(dpy, gc,p_noir);

   sizeHints.x = 0 ;
   sizeHints.y = 0 ;
   sizeHints.width = 64 ;
   sizeHints.height = 64 ;

   win = XCreateSimpleWindow(dpy,root,sizeHints.x,sizeHints.y , sizeHints.width, sizeHints.height, borderWidth, p_noir,p_noir) ;
   iconWin = XCreateSimpleWindow(dpy,root,sizeHints.x,sizeHints.y,sizeHints.width, sizeHints.height, borderWidth, p_noir,p_noir ) ;

   sizeHints.flags = USSize | USPosition ;
   XSetWMNormalHints(dpy,win,&sizeHints) ;
   wmHints.initial_state = WithdrawnState ;
   wmHints.icon_window = iconWin ;
   wmHints.icon_x = sizeHints.x ;
   wmHints.icon_y = sizeHints.y ;
   wmHints.window_group = win ;
   wmHints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint ;
   XSetWMHints(dpy, win, &wmHints) ;
   classHint.res_name = wname ;
   classHint.res_class = wname ;

   XSetClassHint(dpy, win, &classHint) ;
   XSetCommand(dpy,win, argv, argc) ;

   pixmask = XCreateBitmapFromData(dpy,win,fond_bits, fond_width, fond_height) ;
   XShapeCombineMask(dpy,win,ShapeBounding,0,0,pixmask,ShapeSet) ;
   XShapeCombineMask(dpy,iconWin,ShapeBounding, 0, 0, pixmask, ShapeSet) ;
   XpmCreatePixmapFromData(dpy,root,wmAppKill_xpm, &XPM, NULL,NULL) ;

   XSelectInput(dpy,win, ExposureMask | ButtonPressMask) ;
   XSelectInput(dpy,iconWin, ExposureMask | ButtonPressMask) ;

   XMapWindow(dpy,win) ;
}
コード例 #17
0
ファイル: font.c プロジェクト: raboof/notion
void debrush_do_draw_string_default_bmf(
        DEBrush *brush,
        int x, int y, const char *str,
        int len, bool needfill,
        DEColourGroup *colours)
{
    GC gc=brush->d->normal_gc;

    if(brush->d->font==NULL)
        return;

    XSetForeground(ioncore_g.dpy, gc, PIXEL(colours->fg));

    if(!needfill){
        if(brush->d->font->fontset!=NULL){
#ifdef CF_DE_USE_XUTF8
            if(ioncore_g.enc_utf8)
                Xutf8DrawString(ioncore_g.dpy, brush->win,
                                brush->d->font->fontset,
                                gc, x, y, str, len);
            else
#endif
                XmbDrawString(ioncore_g.dpy, brush->win,
                              brush->d->font->fontset,
                              gc, x, y, str, len);
        }else if(brush->d->font->fontstruct!=NULL){
            if(ioncore_g.enc_utf8){
                XChar2b *str16; int len16=0;
                toucs(str, len, &str16, &len16);
                XDrawString16(ioncore_g.dpy, brush->win, gc, x, y, str16, len16);
                free(str16);
            }else{
                XDrawString(ioncore_g.dpy, brush->win, gc, x, y, str, len);
            }
        }
    }else{
        XSetBackground(ioncore_g.dpy, gc, PIXEL(colours->bg));
        if(brush->d->font->fontset!=NULL){
#ifdef CF_DE_USE_XUTF8
            if(ioncore_g.enc_utf8)
                Xutf8DrawImageString(ioncore_g.dpy, brush->win,
                                     brush->d->font->fontset,
                                     gc, x, y, str, len);
            else
#endif
                XmbDrawImageString(ioncore_g.dpy, brush->win,
                                   brush->d->font->fontset,
                                   gc, x, y, str, len);
        }else if(brush->d->font->fontstruct!=NULL){
            if(ioncore_g.enc_utf8){
                XChar2b *str16; int len16=0;
                toucs(str, len, &str16, &len16);
                XDrawImageString16(ioncore_g.dpy, brush->win, gc, x, y, str16, len16);
                free(str16);
            }else{
                XDrawImageString(ioncore_g.dpy, brush->win, gc, x, y, str, len);
            }
        }
    }
}
コード例 #18
0
ファイル: hci_uipm.c プロジェクト: likev/CodeOrpgPub
static void RefreshAppearance () {
    static char *operation_text = NULL;
    XmString label;
    Window window;

    window = XtWindow (Progress_widget);
    XSetForeground (display, Progress_gc, hci_get_read_color (WHITE));
    XSetBackground (display, Progress_gc, hci_get_read_color (WHITE));
    XFillRectangle (display, window, Progress_gc, 
				0, 0, PROGRESS_BAR_WIDTH, PROGRESS_BAR_HEIGHT);
    XSetForeground (display, Progress_gc, hci_get_read_color (BLACK));
    XFillRectangle (display, window, Progress_gc, 
				0, 0, Bar_width, PROGRESS_BAR_HEIGHT);

    operation_text = STR_copy (operation_text, "Operation:\t");
    operation_text = STR_cat (operation_text, Operation);

    label = XmStringCreateLocalized (operation_text);
    XtVaSetValues (Operation_label, XmNlabelString, label, NULL);
    XmStringFree (label);

    label = XmStringCreateLocalized (Transfer_op_label_str);
    XtVaSetValues (Transfer_op_label, XmNlabelString, label, NULL);
    XmStringFree (label);

    label = XmStringCreateLocalized (Transfer_rate_label_str);
    XtVaSetValues (Transfer_rate_label, XmNlabelString, label, NULL);
    XmStringFree (label);

    if( Visible ){ XmUpdateDisplay( Main_widget ); }
}
コード例 #19
0
ファイル: deletion_message.c プロジェクト: QMonkey/Xlib-demo
static void set_up_gc ()
{
    text_box.screen = DefaultScreen (text_box.display);
    text_box.gc = XCreateGC (text_box.display, text_box.window, 0, 0);
    XSetBackground (text_box.display, text_box.gc, text_box.white_pixel); 
    XSetForeground (text_box.display, text_box.gc, text_box.black_pixel); 
}
コード例 #20
0
ファイル: CrGC.c プロジェクト: ghaerr/microwindows
/* note: unused Drawable d */
GC
XCreateGC(Display *dpy, Drawable d, unsigned long valuemask, XGCValues *values)
{
	GC gc;
	XGCValues *vp;

	if ((gc = (GC) Xmalloc(sizeof(struct _XGC))) == NULL)
		return NULL;
	if ((vp = (XGCValues *)Xmalloc(sizeof(XGCValues))) == NULL) {
		Xfree(gc);
		return NULL;
	}
	gc->ext_data = (XExtData *)vp;
	memcpy(vp, &initial_GC, sizeof(initial_GC));
	gc->gid = GrNewGC();

	/* X11 doesn't draw background, must set on all GrNewGC's*/
	GrSetGCUseBackground(gc->gid, GR_FALSE);

	/* X11 defaults to fg=black, bg=white, NX is opposite...*/
	if (!(valuemask & GCForeground))
		XSetForeground(dpy, gc, 0L);	/* black*/
	if (!(valuemask & GCBackground))
		XSetBackground(dpy, gc, ~0L);	/* white*/

	setupGC(dpy, gc, valuemask, values);
	return gc;
}
コード例 #21
0
ファイル: xf_graphics.c プロジェクト: MrRecovery/FreeRDP
void xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
{
	xfContext* xfc = (xfContext*) context;

	bgcolor = freerdp_convert_gdi_order_color(bgcolor, context->settings->ColorDepth, xfc->format, xfc->palette);
	fgcolor = freerdp_convert_gdi_order_color(fgcolor, context->settings->ColorDepth, xfc->format, xfc->palette);

	xf_lock_x11(xfc, FALSE);

	XSetFunction(xfc->display, xfc->gc, GXcopy);

	if (width && height)
	{
		XSetFillStyle(xfc->display, xfc->gc, FillSolid);
		XSetForeground(xfc->display, xfc->gc, fgcolor);
		XFillRectangle(xfc->display, xfc->drawing, xfc->gc, x, y, width, height);
	}

	XSetForeground(xfc->display, xfc->gc, bgcolor);
	XSetBackground(xfc->display, xfc->gc, fgcolor);

	XSetFillStyle(xfc->display, xfc->gc, fOpRedundant ? FillOpaqueStippled : FillStippled);

	xf_unlock_x11(xfc, FALSE);
}
コード例 #22
0
ファイル: planet.cpp プロジェクト: dibyendu/X-Apps
int
drawText(Display *d, int screen, Window *w, GC *gc, const char *str) {
    XFontStruct *font;
    XColor textColor;
    char **list;
    int textWidth, textHeight, textX, textY, returnNo;

    list = XListFonts(d, "-*-*-bold-r-normal--*-*-100-100-c-*-*", 200, &returnNo);
    if (returnNo) {
        srand(time(NULL));
        static int fontIndex = rand() % returnNo;
        font = XLoadQueryFont(d, *(list + fontIndex));
        XFreeFontNames(list);
    }

    if (!font)
        return -1;

    XParseColor(d, DefaultColormap(d, screen), text, &textColor);
    XAllocColor(d, DefaultColormap(d, screen), &textColor);
    XSetForeground(d, *gc, textColor.pixel);
    XSetBackground(d, *gc, WhitePixel(d, screen));
    XSetFont(d, *gc, font->fid);

    textWidth = XTextWidth(font, str, strlen(str));
    textHeight = font->ascent + font->descent;
    textX = (windowWidth - textWidth) / 2;
    textY = ((windowHeight - rectHeight) / 2 - textHeight) / 2 + textHeight / 2;

    XDrawImageString(d, *w, *gc, textX, textY, str, strlen(str));
    return 0;
}
コード例 #23
0
void
DisplayX11::ASetBackground( char * color )
{
    XColor def, closest;
    XAllocNamedColor( disp, DefaultColormap( disp, 0 ), color, &def, &closest );
    XSetBackground( disp, gc, closest.pixel );
}
コード例 #24
0
ファイル: x11_window.c プロジェクト: kamanashisroy/roopkotha
static x11_window_t*create_window(Display*disp, Window root, int wid) {
	x11_window_t*win = NULL;
	opp_str2_alloc2((char**)&win,sizeof(x11_window_t));
	win->black_pixel = WhitePixel (gcore.disp, gcore.scrn);
 	win->white_pixel = BlackPixel (gcore.disp, gcore.scrn);
	win->title = "great";
	/* Suggest where to position the window: */
  	XSizeHints myhint;
	myhint.x = 200,myhint.y = 200;
	myhint.width = win->width = 200;
	myhint.height = win->height = 200;
	myhint.flags = PPosition | PSize;
	win->w = XCreateSimpleWindow(
		disp
		, root
		, 200, 200
		, win->width, win->height
		, 5 /* border width */
		, win->black_pixel/*foreground*/, win->white_pixel /*background*/
	);
	aroop_indexed_list_set(&gcore.pwins, wid, win);
	XSetStandardProperties (disp, win->w, win->title, win->title, None, argv, argc, &myhint);
	win->gc = XCreateGC(disp, win->w, 0, 0);
	XSetBackground (disp, win->gc, win->white_pixel);
	XSetForeground (disp, win->gc, win->black_pixel);
	/* Select input devices to listen to: */
	XSelectInput (disp, win->w, StructureNotifyMask | ButtonPressMask | KeyPressMask | ExposureMask);
	// display window
	XMapRaised (disp, win->w);
	//XMapWindow(disp, win->w);
	gcore.wid = wid;
	watchdog_log_string("Created new X11 window\n");
	return win;
}
コード例 #25
0
ファイル: Simple3D.cpp プロジェクト: AVGP/Simple3D
/**
* @brief The default constructor. You need to call this to initialize the engine.
* @param[in] width The width of the desired screen.
* @param[in] height The height of the desired screen.
* @param[in] title You can supply a title for a window here.
* @param[in] argc The number of arguments passed to your application (optional)
* @param[in] argv The arguments passed to your application (optional)
*/
Simple3D::Simple3D(int width, int height,std::string title,int argc, char **argv)
{
	for(int i=0;i<argc;i++)
	{
		if(argv[i][1] == 'A') options |= S3DOptionDrawAxis;
	}
	//This is temporary...hopefully :D
	options |= S3DOptionDrawAxis;
	
	disp = XOpenDisplay((char *)0);
	screen = DefaultScreen(disp);
	
	backColor = BlackPixel(disp,screen);
	foreColor = WhitePixel(disp,screen);
	
	this->width  = (unsigned int)width;
	this->height = (unsigned int)height;
	
	window = XCreateSimpleWindow(disp,DefaultRootWindow(disp),0,0,width,height,0,backColor,0);
	
	XSetStandardProperties(disp,window,title.c_str(),title.c_str(),None,NULL,0,NULL);
	XMapWindow(disp,window);
	XSelectInput(disp, window, StructureNotifyMask | ExposureMask | KeyPressMask | ButtonPressMask);

	gc = XCreateGC(disp,window,0,0);

	XSetForeground(disp,gc,foreColor);
	XSetBackground(disp,gc,backColor);
	
	backbuffer = XCreatePixmap(disp,window,width,height,24);

	zbuffer = new S3DZBuffer(width,height);
}
コード例 #26
0
ファイル: xf_graphics.c プロジェクト: BUGgs/FreeRDP
BOOL xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
{
	xfContext* xfc = (xfContext*) context;

	bgcolor = xf_convert_rdp_order_color(xfc, bgcolor);
	fgcolor = xf_convert_rdp_order_color(xfc, fgcolor);

	xf_lock_x11(xfc, FALSE);

	XSetFunction(xfc->display, xfc->gc, GXcopy);

	if (width && height)
	{
		XSetFillStyle(xfc->display, xfc->gc, FillSolid);
		XSetForeground(xfc->display, xfc->gc, fgcolor);
		XFillRectangle(xfc->display, xfc->drawing, xfc->gc, x, y, width, height);
	}

	XSetForeground(xfc->display, xfc->gc, bgcolor);
	XSetBackground(xfc->display, xfc->gc, fgcolor);

	XSetFillStyle(xfc->display, xfc->gc, fOpRedundant ? FillOpaqueStippled : FillStippled);

	xf_unlock_x11(xfc, FALSE);
	return TRUE;
}
コード例 #27
0
ファイル: menu.cpp プロジェクト: pshendry/RSWR
void paintBackground( XInfo& xinfo, PixmapArray& pixmapArray ) {
    XClearWindow( xinfo.display, xinfo.window );

    // Paint rainbow
    paintRainbowArc( xinfo, 0, XInfoColor::ORANGE );
    paintRainbowArc( xinfo, 1, XInfoColor::YELLOW );
    paintRainbowArc( xinfo, 2, XInfoColor::GREEN );
    paintRainbowArc( xinfo, 3, XInfoColor::BLUE );
    paintRainbowArc( xinfo, 4, XInfoColor::INDIGO );
    paintRainbowArc( xinfo, 5, XInfoColor::PURPLE );
    paintRainbowArc( xinfo, 6, XInfoColor::RED );

    // Paint title
    int titleX = xinfo.windowAttr.width/2 - (290/2);
    int titleY = 50;
    XSetForeground( xinfo.display, xinfo.gc,
                    xinfo.color[ (int) XInfoColor::BLACK ].pixel );
    XSetBackground( xinfo.display, xinfo.gc,
                    xinfo.color[ (int) XInfoColor::RED ].pixel );
    XCopyPlane( xinfo.display,
                pixmapArray[ PixmapArray::TITLE ],
                xinfo.window, xinfo.gc,
                0, 0, 290, 184, titleX, titleY, 1 );
    
    // Paint Stalin and instructions
    int stalinX = xinfo.windowAttr.width - 469;
    int stalinY = xinfo.windowAttr.height - 307;
    XCopyPlane( xinfo.display,
                pixmapArray[ PixmapArray::STALIN ],
                xinfo.window, xinfo.gc,
                0, 0, 469, 307, stalinX, stalinY, 1 );
}
コード例 #28
0
//Display functions.
void display_init (void) {
	_D=XOpenDisplay(NULL);
	if (_D==NULL) {
		fprintf(stderr, "Could not open display.\n");
		exit(EXIT_FAILURE);
	}
	_S=DefaultScreen(_D);
	white_pixel=WhitePixel(_D, _S);
	black_pixel=BlackPixel(_D, _S);
	_W=XCreateSimpleWindow(_D, RootWindow(_D, _S), 100, 100, W_Width, W_Height, 1, black_pixel, white_pixel);
	XSelectInput(_D, _W, ExposureMask|KeyPressMask);
	XMapWindow(_D, _W);
	if ((font_info=XLoadQueryFont(_D, "9x15"))==NULL) {
		fprintf(stderr, "Could not open 9x15 font.\n");
		exit(EXIT_FAILURE);
	}
	_gc=XCreateGC(_D, _W, 0, &_V);
	XSetFont(_D, _gc, font_info->fid);
	XSetBackground(_D, _gc, white_pixel);
	_CM = DefaultColormap(_D, _S);
	if (!XAllocNamedColor(_D, _CM, "red", &red, &red) || !XAllocNamedColor(_D, _CM, "blue", &blue, &blue)) {
		fprintf(stderr, "Failed to allocated color.\n");
		exit(EXIT_FAILURE);		//Maybe add support for grayscale displays.
	}
}
コード例 #29
0
ファイル: main.c プロジェクト: SparklePigBang/dzen
static void
x_create_gcs(void) {
	XGCValues gcv;
	gcv.graphics_exposures = 0;

	/* normal GC */
	dzen.gc  = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), GCGraphicsExposures, &gcv);
	XSetForeground(dzen.dpy, dzen.gc, dzen.norm[ColFG]);
	XSetBackground(dzen.dpy, dzen.gc, dzen.norm[ColBG]);
	/* reverse color GC */
	dzen.rgc = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), GCGraphicsExposures, &gcv);
	XSetForeground(dzen.dpy, dzen.rgc, dzen.norm[ColBG]);
	XSetBackground(dzen.dpy, dzen.rgc, dzen.norm[ColFG]);
	/* temporary GC */
	dzen.tgc = XCreateGC(dzen.dpy, RootWindow(dzen.dpy, dzen.screen), GCGraphicsExposures, &gcv);
}
コード例 #30
0
ファイル: xf_graphics.c プロジェクト: JozLes77/FreeRDP
void xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
{
	xfContext* context_ = (xfContext*) context;
	xfContext* xfc = (xfContext*) context;

	bgcolor = (xfc->clrconv->invert)?
		freerdp_color_convert_var_bgr(bgcolor, context_->settings->ColorDepth, xfc->bpp, xfc->clrconv):
		freerdp_color_convert_var_rgb(bgcolor, context_->settings->ColorDepth, xfc->bpp, xfc->clrconv);

	fgcolor = (xfc->clrconv->invert)?
		freerdp_color_convert_var_bgr(fgcolor, context_->settings->ColorDepth, xfc->bpp, xfc->clrconv):
		freerdp_color_convert_var_rgb(fgcolor, context_->settings->ColorDepth, xfc->bpp, xfc->clrconv);

	xf_lock_x11(xfc, FALSE);

	XSetFunction(xfc->display, xfc->gc, GXcopy);
	XSetFillStyle(xfc->display, xfc->gc, FillSolid);
	XSetForeground(xfc->display, xfc->gc, fgcolor);
	XFillRectangle(xfc->display, xfc->drawing, xfc->gc, x, y, width, height);

	XSetForeground(xfc->display, xfc->gc, bgcolor);
	XSetBackground(xfc->display, xfc->gc, fgcolor);
	XSetFillStyle(xfc->display, xfc->gc, FillStippled);

	xf_unlock_x11(xfc, FALSE);
}