自学教程：C++ DefaultDepthOfScreen函数代码示例

void MSPixmap::create(MSDisplayServer *pServer_,const char *pName_,		      const char *bitmapFile_,unsigned long fg_,unsigned long bg_){  Display *display=pServer_->display();  Window window=pServer_->root();  int depth=DefaultDepthOfScreen(pServer_->screen());  unsigned w,h;  Pixmap bitmap;#ifdef MS_WINDOWS  int res;  if (bitmapFile_==0) res=MSXReadBitmapFromResource(display,window,_name,&w,&h,&bitmap);  else res=MSXReadBitmapFromXbmFile(display,window,bitmapFile_,&w,&h,&bitmap,fg_,bg_,depth);  if( res==BitmapSuccess)  {     _pData=new MSPixmapData(pServer_,pName_,bitmap,w,h,depth,fg_,bg_);#else  if (XReadBitmapFile(display,window,bitmapFile_,&w,&h,&bitmap,0,0)==BitmapSuccess)   {     Pixmap pixmap=XCreatePixmap(display,window,w,h,depth);     GC gc=XCreateGC(display,window,0,0);     XSetForeground(display,gc,fg_);     XSetBackground(display,gc,bg_);     XCopyPlane(display,bitmap,pixmap,gc,0,0,w,h,0,0,1);     XFreeGC(display,gc);     XFreePixmap(display,bitmap);     _pData=new MSPixmapData(pServer_,pName_,pixmap,w,h,depth,fg_,bg_);#endif     addToHashTable(pName_,(void *)_pData);     addReference();        }  else   {     // Can't read bitmap file, create one with background color     MSMessageLog::warningMessage("MSPixmap warning: Unable to create Pixmap from file %s/n",bitmapFile_);     char buf[255];     sprintf(buf,"Predefined_%s_%d_%d_%d_%d",MSPixmap::SolidBackgroundPixmap,fg_,bg_,depth,display);     if(copyPixmapDataWithKey(buf)==MSFalse)        create(pServer_,MSPixmap::SolidBackgroundPixmap,fg_,bg_);   }}void MSPixmap::create(MSDisplayServer *pServer_,const char *pName_,		      int w_,int h_,unsigned long fg_,unsigned long bg_){  int dep=DefaultDepthOfScreen(pServer_->screen());  Pixmap p=XCreatePixmap(pServer_->display(),pServer_->root(),w_,h_,dep);  create(pServer_,pName_,p,w_,h_,dep,fg_,bg_);}

int x11_shadow_subsystem_base_init(x11ShadowSubsystem* subsystem){	if (subsystem->display)		return 1; /* initialize once */	if (!getenv("DISPLAY"))		setenv("DISPLAY", ":0", 1);	if (!XInitThreads())		return -1;	subsystem->display = XOpenDisplay(NULL);	if (!subsystem->display)	{		WLog_ERR(TAG, "failed to open display: %s", XDisplayName(NULL));		return -1;	}	subsystem->xfds = ConnectionNumber(subsystem->display);	subsystem->number = DefaultScreen(subsystem->display);	subsystem->screen = ScreenOfDisplay(subsystem->display, subsystem->number);	subsystem->depth = DefaultDepthOfScreen(subsystem->screen);	subsystem->width = WidthOfScreen(subsystem->screen);	subsystem->height = HeightOfScreen(subsystem->screen);	subsystem->root_window = RootWindow(subsystem->display, subsystem->number);	return 1;}

/* Create pixmap to store contents of drawing area; assumes MainCanvas has been setup already */void initPixmap() {	/* create a pixmap the same size as the drawing area. */	pixmap = XCreatePixmap (XtDisplay(MainCanvas), RootWindowOfScreen (XtScreen (MainCanvas)),			width, height, DefaultDepthOfScreen (XtScreen(MainCanvas)));	/* clear pixmap with white */	XFillRectangle (XtDisplay (MainCanvas), pixmap, gc, 0, 0, width, height);}

/* WIDGET is an Xt widget, VISUAL and DEPTH are return values */voidvisual_info_from_widget (Widget widget, Visual **visual, int *depth){  /* grab the visual and depth from the nearest shell ancestor */  Widget p = XtParent(widget);  *visual = CopyFromParent;  *depth = -1;  while (*visual == CopyFromParent && p)    {      if (XtIsShell(p))	{	  *visual = ((ShellWidget)p)->shell.visual;	  *depth = p->core.depth;	}      p = XtParent(p);    }  if (*visual == CopyFromParent || !*visual)    {      if (debug_colors > 1)	fprintf (stderr, "/nvisual_info_from_widget:"		 " failed, using DefaultVisualOfScreen");      *visual = DefaultVisualOfScreen (XtScreen (widget));      *depth = DefaultDepthOfScreen (XtScreen (widget));    }  else if (debug_colors > 1)    fprintf (stderr, "/nvisual_info_from_widget: succeeded");}

static GC DisplayInfoSharedGC(DisplayInfo d, Screen *screen, int depth){    int s = XScreenNumberOfScreen(screen);    register int i;    XGCValues v;    Pixmap p;    if (s >= ScreenCount(DisplayOfScreen(screen))) return NULL;	      for (i = 0; i < d->depthsForScreen[s] &&	       d->validDepths[s][i] != depth; i++) {}	      if (i >= d->depthsForScreen[s]) return NULL;	      if (d->gcForDepth[s][i] == 0) {	/* Not "None" -- used calloc */	if (depth == DefaultDepthOfScreen(screen)) {	    d->gcForDepth[s][i] = XCreateGC(d->display,					    RootWindowOfScreen(screen), 0, &v);	} else {	    p = XCreatePixmap(d->display,			      RootWindowOfScreen(screen),			      1, 1, depth);	    d->gcForDepth[s][i] = XCreateGC(d->display, p, 0, &v);	    XFreePixmap(d->display, p);	}    }    return d->gcForDepth[s][i];}

Pixmap XcodaCreatePixmapFromXpm(Widget parent,				const char** data,				int    type){  Display        *dpy = XtDisplay(parent);  Window         win = XDefaultRootWindow(dpy);  Screen         *scr = XDefaultScreenOfDisplay(dpy);  int            depth = DefaultDepthOfScreen(scr);  Colormap       cmap = DefaultColormapOfScreen(scr);  XpmAttributes  attr;  unsigned int  valuemask = 0;  int            err;  /*unsigned int  pixmap_ret, pixmap_mask;*/  Pixmap pixmap_ret, pixmap_mask;  XpmColorSymbol col_symbol[1];  Arg            arg[5];  int            ac = 0;  Pixel          parent_bg;  if(type){ /* normal background for pixmap */    XtSetArg (arg[ac], XmNbackground, &parent_bg); ac++;    XtGetValues (parent, arg, ac);    ac = 0;  }  else{  /* inverted or highlighted pixmap */    XtSetArg (arg[ac], XmNforeground, &parent_bg); ac++;    XtGetValues (parent, arg, ac);    ac = 0;  }      col_symbol[0].name = (char *)NULL;  col_symbol[0].value = (char *)malloc((strlen("LightBlue")+1)*sizeof(char));  strcpy(col_symbol[0].value,"LightBlue");  col_symbol[0].pixel = parent_bg;    attr.colormap = cmap;  attr.depth = depth;  attr.colorsymbols = col_symbol;  attr.valuemask = valuemask;  attr.numsymbols = 1;  attr.closeness = 65536;    attr.valuemask |= XpmReturnPixels;  attr.valuemask |= XpmColormap;  attr.valuemask |= XpmColorSymbols;  attr.valuemask |= XpmDepth;  attr.valuemask |= XpmCloseness;  /*  printf("Calling XpmCreatePixmapFromData .../n");  */  err = XpmCreatePixmapFromData(dpy, win, (char **)data, &pixmap_ret, &pixmap_mask, &attr);    free (col_symbol[0].value);  if(err != XpmSuccess){    pixmap_ret = 0;  }  return pixmap_ret;}

voidRollEnhanceCB ( Widget w, XtPointer client_data, XtPointer xt_call_data ){	WindowObjectType        *wo;	int			cbank;	int			scale;	int			verbose;	XmScaleCallbackStruct *cbs =		(XmScaleCallbackStruct *) xt_call_data;	verbose = GetVerboseLevel();        wo = GetActiveWindowObject();	cbank = GetGempakColorBank( wo );		scale =   cbs->value ;		if( verbose > VERBOSE_1 )		printf ("RollEnhanceCB - value: %d", cbs->value );	if ( cbank == -1 ) return;	RollColorEnhancement ( wo, cbank, scale );        if( DefaultDepthOfScreen(DefaultScreenOfDisplay(XtDisplay(w))) != 8 ) {            RefreshDisplay ( );  /* Necessary for > 8-bit displays to redraw                                    images with new pixel values reflecting                                    new read-only color table entries */        }}

static void switch_to_best_mode (void){    Screen *scr = ScreenOfDisplay (display, screen);    int w = WidthOfScreen (scr);    int h = HeightOfScreen (scr);    int d = DefaultDepthOfScreen (scr);#ifdef USE_VIDMODE_EXTENSION    int i, best;    if (vidmodeavail) {	best = 0;	for (i = 1; i < vidmodecount; i++) {	    if (allmodes[i]->hdisplay >= current_width		&& allmodes[i]->vdisplay >= current_height		&& allmodes[i]->hdisplay <= allmodes[best]->hdisplay		&& allmodes[i]->vdisplay <= allmodes[best]->vdisplay)		best = i;	}	write_log ("entering DGA mode: %dx%d (%d, %d)/n",		allmodes[best]->hdisplay, allmodes[best]->vdisplay,		current_width, current_height);	XF86VidModeSwitchToMode (display, screen, allmodes[best]);	XF86VidModeSetViewPort (display, screen, 0, 0);    }#endif    XMoveWindow (display, mywin, 0, 0);    XWarpPointer (display, None, rootwin, 0, 0, 0, 0, 0, 0);    XF86DGADirectVideo (display, screen, XF86DGADirectGraphics | XF86DGADirectMouse | XF86DGADirectKeyb);    XF86DGASetViewPort (display, screen, 0, 0);    memset (fb_addr, 0, (w * h) * (d / 8));}

/* * A pixmap caching function that generates a pixmap, stores it in a pixmap * cache and returns the pixmap. */extern PixmapXmGetPixmap(Screen *screen, char *image_name,	    Pixel foreground, Pixel background){    Pixmap p;    p = XmGetPixmapByDepth(screen, image_name, foreground, background,			   DefaultDepthOfScreen(screen));    DEBUGOUT(_LtDebug(__FILE__, NULL,		      "XmGetPixmap(%s, %d, %d) => 0x%x (depth %d)/n",		      image_name, foreground, background, p,		      DefaultDepthOfScreen(screen)));    return p;}

Window create_window(Display *dsp, Screen *screen) {	Window window;	int x, y;	int width, height;	int depth;	XSetWindowAttributes winAttrib;	XWindowAttributes window_attributes;		x = 30;	y = 60;	width = 200;	height = 300;	winAttrib.background_pixel = BlackPixelOfScreen(screen);	winAttrib.border_pixel = WhitePixelOfScreen(screen);	winAttrib.backing_store = Always/*NotUseful*/;	winAttrib.override_redirect = False;	winAttrib.bit_gravity = NorthWestGravity;	winAttrib.win_gravity = NorthWestGravity;	depth = DefaultDepthOfScreen(screen);	if (XGetWindowAttributes(dsp, RootWindowOfScreen(screen), &window_attributes) == 0)	{		fprintf(stderr, "xf_get_pixmap_info: XGetWindowAttributes failed/n");		return 1;	}	window = XCreateWindow(dsp, RootWindowOfScreen(screen),						x, y,						width, height,						0,						depth,						InputOutput, /*window_attributes.visual*/DefaultVisual(dsp, 0),						0, &winAttrib);	setWindowDecorations(dsp, window, 0);	//设置后没有Ubuntu自带的关闭、最小和最大这三个键	return window;}

voidFadeScaleCB (Widget w, XtPointer client_data, XtPointer xt_call_data ){	WindowObjectType		*wo;	int				cbank;	int				scale;	int				fadeWid;	int				verbose;	GuiImageEnhanceDialogType	*img;	Widget				fadeW = NULL;	        XmScaleCallbackStruct *cbs =	       (XmScaleCallbackStruct *) xt_call_data;	fadeWid = (int) client_data;	verbose = GetVerboseLevel();	wo = GetActiveWindowObject();/* *	Get Gempak Color bank number.   *		-1   no image loaded *		 1   satellite *		 2   nids/nowrad  */	cbank = GetGempakColorBank( wo );		scale =   cbs->value ;		if( verbose > VERBOSE_1 )	    printf ("FadeScaleCB - value: %d/n", cbs->value );	if ( cbank == -1 ) return;	ChangeImageBrightness ( wo, cbank, scale );        if( DefaultDepthOfScreen(DefaultScreenOfDisplay(XtDisplay(w))) != 8 ) {            RefreshDisplay ( );  /* Necessary for > 8-bit displays to redraw                                    images with new pixel values reflecting                                    new read-only color table entries */        }/* *	Synchronize the fade slider controls. Set the one who did NOT *	call this routine. */ 	img = GetGuiImageEnhanceDialog();	if ( fadeWid == MAIN_CONTROL_FADER )		fadeW = GetSatImageFadeScaleW ( img );	else if ( fadeWid == ENHANCE_POPUP_FADER )		fadeW = GetImageFadeScaleW ( img );	if( fadeW ) XtVaSetValues ( fadeW, XmNvalue, scale, NULL );}

boolean xf_pre_connect(freerdp* instance){	xfInfo* xfi;	rdpSettings* settings;	xfi = (xfInfo*) xzalloc(sizeof(xfInfo));	SET_XFI(instance, xfi);	xfi->instance = instance;	settings = instance->settings;	settings->order_support[NEG_DSTBLT_INDEX] = True;	settings->order_support[NEG_PATBLT_INDEX] = True;	settings->order_support[NEG_SCRBLT_INDEX] = True;	settings->order_support[NEG_OPAQUE_RECT_INDEX] = True;	settings->order_support[NEG_DRAWNINEGRID_INDEX] = False;	settings->order_support[NEG_MULTIDSTBLT_INDEX] = False;	settings->order_support[NEG_MULTIPATBLT_INDEX] = False;	settings->order_support[NEG_MULTISCRBLT_INDEX] = False;	settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True;	settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False;	settings->order_support[NEG_LINETO_INDEX] = True;	settings->order_support[NEG_POLYLINE_INDEX] = True;	settings->order_support[NEG_MEMBLT_INDEX] = True;	settings->order_support[NEG_MEM3BLT_INDEX] = False;	settings->order_support[NEG_SAVEBITMAP_INDEX] = True;	settings->order_support[NEG_GLYPH_INDEX_INDEX] = True;	settings->order_support[NEG_FAST_INDEX_INDEX] = True;	settings->order_support[NEG_FAST_GLYPH_INDEX] = True;	settings->order_support[NEG_POLYGON_SC_INDEX] = False;	settings->order_support[NEG_POLYGON_CB_INDEX] = False;	settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;	settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;	freerdp_chanman_pre_connect(GET_CHANMAN(instance), instance);	xfi->display = XOpenDisplay(NULL);	if (xfi->display == NULL)	{		printf("xf_pre_connect: failed to open display: %s/n", XDisplayName(NULL));		return False;	}	xf_kbd_init(xfi);	xfi->xfds = ConnectionNumber(xfi->display);	xfi->screen_number = DefaultScreen(xfi->display);	xfi->screen = ScreenOfDisplay(xfi->display, xfi->screen_number);	xfi->depth = DefaultDepthOfScreen(xfi->screen);	xfi->big_endian = (ImageByteOrder(xfi->display) == MSBFirst);	xfi->decoration = True;	xfi->mouse_motion = True;	return True;}

MSPixmap::MSPixmap(MSDisplayServer *pServer_,const char *pName_,unsigned long fg_,unsigned long bg_): _name(pName_){  char buf[255];  MSGUARD(_hashTableMutex);  init();  sprintf(buf,"Predefined_%s_%d_%d_%d_%d",pName_,	  fg_,bg_,DefaultDepthOfScreen(pServer_->screen()),pServer_->display());  if(copyPixmapDataWithKey(buf)==MSFalse) create(pServer_,pName_,fg_,bg_);}

void MSPixmap::create(MSDisplayServer *pServer_,const char *pName_,const char *bitmap_,		      int w_,int h_,unsigned long fg_,unsigned long bg_){  int dep=DefaultDepthOfScreen(pServer_->screen());  Pixmap p=XCreatePixmapFromBitmapData(pServer_->display(),pServer_->root(),(char*)bitmap_,				       w_,h_,fg_,bg_,dep);  _pData=new MSPixmapData(pServer_,pName_,p,w_,h_,dep,fg_,bg_);  addToHashTable(pName_,(void *)_pData);  addReference();  }

voidSatEnhancementCB  (Widget w, XtPointer client_data, XtPointer xt_call_data ){	extern Widget	sat_enhance_list;	extern Widget	sat_enhance_but;	extern struct enhance_list	satenhance_list;	char		color_table[20];	int		*pos_list;	int		pos_cnt;	int		i;	GlobalDataObjectType	*gd;	XmListCallbackStruct *cbs =	              (XmListCallbackStruct *) xt_call_data;/* *	Get color table to use. */	if ( ! ( XmListGetSelectedPos ( sat_enhance_list,	                              &pos_list, &pos_cnt ) &&	                            ( pos_cnt == 1 ) ) ) return;	i = pos_list[0] - 1;	free ( pos_list );	strcpy ( color_table, satenhance_list.list[i] );/* *	Add extension for color tables. */	if ( ! ( strcmp ( color_table, "DEFAULT" ) == 0 ||	         strcmp ( color_table, "gray" )    == 0  ) )	    strcat ( color_table, ".tbl" );/* *	Save parameters. */	gd = GetGlobalDataObject();	SetDefColortable ( gd, color_table );	SetBackgroundColors ( gd, satenhance_list.background[i] );	SetForegroundColors ( gd, satenhance_list.foreground[i] );/* *	Change lutfile. */	newlut ( color_table );	if( DefaultDepthOfScreen(DefaultScreenOfDisplay(XtDisplay(w))) != 8 ) {	    RefreshDisplay ( );  /* Necessary for > 8-bit displays to redraw				    images with new pixel values reflecting				    new read-only color table entries */	}}

Pixmapmakepixmap(Widget toplevel, char bits[], int width, int height){  return (Pixmap)XCreatePixmapFromBitmapData(XtDisplay(toplevel),			   DefaultRootWindow(XtDisplay(toplevel)),                           bits,                           width,                           height,                           BlackPixelOfScreen(XtScreen(toplevel)),                           WhitePixelOfScreen(XtScreen(toplevel)),                           DefaultDepthOfScreen(XtScreen(toplevel)));}

/* Create the icon window */static Windowcreate_icon(Widget shell){    Display *display = XtDisplay(shell);    Screen *screen = XtScreen(shell);    Colormap colormap = XDefaultColormapOfScreen(screen);    int depth = DefaultDepthOfScreen(screen);    unsigned long black = BlackPixelOfScreen(screen);    Window window;    Pixmap pixmap, mask;    XColor color;    GC gc;    XGCValues values;    /* Create the actual icon window */    window = XCreateSimpleWindow(        display, RootWindowOfScreen(screen),        0, 0, mask_width, mask_height, 0,        CopyFromParent, CopyFromParent);    /* Allocate the color red by name */    XAllocNamedColor(display, colormap, "red", &color, &color);    /* Create a pixmap from the red bitmap data */    pixmap = XCreatePixmapFromBitmapData(        display, window, (char *)red_bits, red_width, red_height,        color.pixel, black, depth);    /* Create a graphics context */    values.function = GXxor;    gc = XCreateGC(display, pixmap, GCFunction, &values);    /* Create a pixmap for the white 'e' and paint it on top */    mask = XCreatePixmapFromBitmapData(        display, pixmap, (char *)white_bits, white_width, white_height,        WhitePixelOfScreen(screen) ^ black, 0, depth);    XCopyArea(display, mask, pixmap, gc, 0, 0,              white_width, white_height, 0, 0);    XFreePixmap(display, mask);    XFreeGC(display, gc);#ifdef HAVE_LIBXEXT    /* Create a shape mask and apply it to the window */    mask = XCreateBitmapFromData(display, pixmap, (char *)mask_bits,                                 mask_width, mask_height);    XShapeCombineMask(display, window, ShapeBounding, 0, 0, mask, ShapeSet);#endif /* HAVE_LIBXEXT */    /* Set the window's background to be the pixmap */    XSetWindowBackgroundPixmap(display, window, pixmap);    return window;}

/** * @breif 创建实例 */testContext *test_context_new() {    testContext *cxt = (testContext *)malloc(sizeof(testContext));    cxt->display = XOpenDisplay(NULL);	cxt->_NET_WM_STATE = XInternAtom(cxt->display, "_NET_WM_STATE", False);	cxt->_NET_WM_STATE_SKIP_PAGER = XInternAtom(cxt->display, "_NET_WM_STATE_SKIP_PAGER", False);	cxt->_NET_WM_STATE_SKIP_TASKBAR = XInternAtom(cxt->display, "_NET_WM_STATE_SKIP_TASKBAR", False);	cxt->_MOTIF_WM_HINTS = XInternAtom(cxt->display, "_MOTIF_WM_HINTS", False);    cxt->_NET_WM_MOVERESIZE = XInternAtom(cxt->display, "_NET_WM_MOVERESIZE", False);    cxt->screen_number = DefaultScreen(cxt->display);    cxt->screen = ScreenOfDisplay(cxt->display, cxt->screen_number);    cxt->depth = DefaultDepthOfScreen(cxt->screen);    return cxt;}

void register_canvas(Widget w, GC gc){    draww = w;    drawGC = gc;    XtVaGetValues(w, XmNwidth, &width, XmNheight, &height, NULL);    pixmap = XCreatePixmap(XtDisplay(w),			   RootWindowOfScreen(XtScreen(w)), width, height,			   (unsigned int)DefaultDepthOfScreen(XtScreen(w)));    set_color("White");    (void)XFillRectangle(XtDisplay(draww), pixmap, drawGC, 0,0, width,height);    diameter = min(width, height) - RM;}

FvwmPicture *LoadPicture(Display *dpy,Window Root,char *path, int color_limit){  int l;  FvwmPicture *p;#ifdef XPM  XpmAttributes xpm_attributes;  int rc;  XpmImage	my_image = {0};#endif  p=(FvwmPicture*)safemalloc(sizeof(FvwmPicture));  p->count=1;  p->name=path;  p->next=NULL;#ifdef XPM  /* Try to load it as an X Pixmap first */  xpm_attributes.colormap=PictureCMap;  xpm_attributes.closeness=40000; /* Allow for "similar" colors */  xpm_attributes.valuemask=    XpmSize | XpmReturnPixels | XpmColormap | XpmCloseness;  rc =XpmReadFileToXpmImage(path, &my_image, NULL);  if (rc == XpmSuccess) {    color_reduce_pixmap(&my_image, color_limit);    rc = XpmCreatePixmapFromXpmImage(dpy, Root, &my_image,                                     &p->picture,&p->mask,                                     &xpm_attributes);    if (rc == XpmSuccess) {      p->width = my_image.width;      p->height = my_image.height;      XpmFreeXpmImage(&my_image);      p->depth = DefaultDepthOfScreen(DefaultScreenOfDisplay(dpy));      return p;    }    XpmFreeXpmImage(&my_image);  }#endif  /* If no XPM support, or XPM loading failed, try bitmap */  if(XReadBitmapFile(dpy,Root,path,&p->width,&p->height,&p->picture,&l,&l)     == BitmapSuccess)    {      p->depth = 0;      p->mask = None;      return p;    }  free(p);  return NULL;}

Pixmap get_pp_pixmap(void){	if(!pp_pixmap) {		pp_pixmap = XCreatePixmapFromBitmapData(			XtDisplay(root),			RootWindowOfScreen(XtScreen(root)),			(char*)pp_bitmap_bits,			pp_bitmap_width,			pp_bitmap_height,			BlackPixelOfScreen(XtScreen(root)), /* foreground pixel */			WhitePixelOfScreen(XtScreen(root)), /* background pixel */			DefaultDepthOfScreen(XtScreen(root)) /* depth */);	}	return pp_pixmap;}

//// Pattern callback for Get_XInfo requests//Tt_message_ttdt_do_Get_XInfo(	Tt_message	msg,	void	       *_widget,	Tt_message	,	char          **display,	int	       *visual,	int	       *depth){	_TttkItem2Free fuse = msg;	Widget widget = _ttdt_realized_widget( _widget, 0 );	if (widget == 0) {		tttk_message_fail( msg, TT_DESKTOP_ENOTSUP, 0, 0 );		return 0;	}	Display *dpy = (Display *)CALLXT(XtDisplay)( widget );	*display = DisplayString( dpy );	if (*display == 0) {		tttk_message_fail( msg, TT_ERR_INTERNAL,				   "DisplayString() == 0", 0 );		return 0;	}	int is_local = 0;	char *display_and_screen;	if ((*display)[0] == ':') {		display_and_screen = *display;		is_local = 1;	} else if (strncmp(*display, "unix:", 5) == 0) {		display_and_screen = (*display)+4; // !5; we want the colon		is_local = 1;	}	if (is_local) {		_Tt_string portable_display = _tt_gethostname();		portable_display = portable_display.cat(display_and_screen);		*display = _tt_strdup((char *)portable_display);	} else {		*display = _tt_strdup( *display );	}	*visual = DefaultVisualOfScreen(			DefaultScreenOfDisplay( dpy ))->c_class;	*depth = DefaultDepthOfScreen( DefaultScreenOfDisplay( dpy ));	fuse = (caddr_t)0;	return msg;}

static voidset_text (struct widget_xft_data *data, Widget toplevel, char *lbl, int margin){    int width, height;    width = get_text_width_and_height (data->widget, lbl, data->xft_font,                                       &height);    data->p_width = width + margin;    data->p_height = height + margin;    data->p = XCreatePixmap (XtDisplay (data->widget),                             XtWindow (toplevel),                             data->p_width,                             data->p_height,                             DefaultDepthOfScreen (XtScreen (data->widget)));    draw_text (data, lbl, 0);    XtVaSetValues (data->widget, XtNbitmap, data->p, NULL);}

/* * Monstrous hack. */static void Term_xtra_xaw_react_aux(term_data *td){	AngbandWidget wnew = td->widget;	Display *dpy = XtDisplay((Widget) wnew);	int depth = DefaultDepthOfScreen(XtScreen((Widget) wnew));	int i;	/* See if any colors need to be changed */	for (i = 0; i < NUM_COLORS; i++)	{		if (depth > 1)		{			if ((wnew->angband.color[i][0] != angband_color_table[i][0]) ||			    (wnew->angband.color[i][1] != angband_color_table[i][1]) ||			    (wnew->angband.color[i][2] != angband_color_table[i][2]) ||			    (wnew->angband.color[i][3] != angband_color_table[i][3]))			{				unsigned long pixel;				/* Save new values */				wnew->angband.color[i][0] = angband_color_table[i][0];				wnew->angband.color[i][1] = angband_color_table[i][1];				wnew->angband.color[i][2] = angband_color_table[i][2];				wnew->angband.color[i][3] = angband_color_table[i][3];				/* Create pixel */				pixel = create_pixel(dpy,				                     wnew->angband.color[i][1],				                     wnew->angband.color[i][2],				                     wnew->angband.color[i][3]);				/* Change */				XSetForeground(dpy, wnew->angband.gc[i], pixel);			}		}	}}

Pixmap XbrGfxReadBitmap(Display *display, Screen *screen, GC gc, char *bits,                        int width, int height){    Pixmap bitmap, pixmap;    /* Create a bitmap from the bits passed in */    bitmap = XCreateBitmapFromData(display, RootWindowOfScreen(screen), bits,      width, height);    /* Create a pixmap with the same dimensions */    pixmap = XCreatePixmap(display, RootWindowOfScreen(screen), width, height,      DefaultDepthOfScreen(screen));    /* Copy the bitmap onto the first plane of the pixmap */    XCopyPlane(display, bitmap, pixmap, gc, 0, 0, width, height, 0, 0, 1);    /* Finished with the bitmap */    XFreePixmap(display, bitmap);    /* Done. */    return(pixmap);}