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 */
void
visual_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");
}
void XschInitializeGraphicWindow()
{
autbegin();
XtVaGetValues( XschGraphicWindow,
XmNwidth, &XschGraphicDx,
XmNheight, &XschGraphicDy,
NULL
);
XschOldGraphicDx = XschGraphicDx;
XschOldGraphicDy = XschGraphicDy;
XschGraphicPixmap =
XCreatePixmap ( XschGraphicDisplay,
RootWindowOfScreen( XtScreen ( XschGraphicWindow ) ),
XschGraphicDx,
XschGraphicDy,
DefaultDepthOfScreen ( XtScreen ( XschGraphicWindow ) )
);
XschClearGraphicWindow( 0, 0, XschGraphicDx, XschGraphicDy );
XschInitializeUnitGrid();
XschSetMouseCursor( XschGraphicWindow, XSCH_NORMAL_CURSOR );
autend();
}
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;
}
void
RollEnhanceCB ( 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 Pixmap
XmGetPixmap(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;
}
void MSPixmap::create(MSDisplayServer *pServer_,const char *pName_,const char *bitmapFile_)
{
Display *display=pServer_->display();
Window window=pServer_->root();
unsigned w,h;
Pixmap bitmap;
if (XReadBitmapFile(display,window,bitmapFile_,&w,&h,&bitmap,0,0)==BitmapSuccess)
{
_pData=new MSPixmapData(pServer_,pName_,bitmap,bitmap,w,h,1,0,0);
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];
unsigned long fg=pServer_->defaultForeground();
unsigned long bg=pServer_->defaultBackground();
int depth=DefaultDepthOfScreen(pServer_->screen());
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
FadeScaleCB (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();
}
void
SatEnhancementCB (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 */
}
}
MSPixmap::MSPixmap(MSDisplayServer *pServer_,const char *pName_,
const char *bitmap_,int w_,int h_)
: _name(pName_)
{
char buf[255];
MSGUARD(_hashTableMutex);
init();
sprintf(buf,"Array_%s_%d_%d_%d_%d",pName_,w_,h_,
DefaultDepthOfScreen(pServer_->screen()),pServer_->display());
if(copyPixmapDataWithKey(buf)==MSFalse) create(pServer_,buf,bitmap_,w_,h_);
}
Pixmap
makepixmap(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 Window
create_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;
}
MSPixmap::MSPixmap(MSDisplayServer *pServer_,const char *pName_,int w_,int h_,
const char *foreground_,const char *background_)
: _name(pName_)
{
char buf[255];
MSGUARD(_hashTableMutex);
init();
unsigned long fg=pServer_->pixel(foreground_);
unsigned long bg=pServer_->pixel(background_);
sprintf(buf,"General_%s_%d_%d_%d_%d_%d_%d",pName_,w_,h_,
fg,bg,DefaultDepthOfScreen(pServer_->screen()),pServer_->display());
if(copyPixmapDataWithKey(buf)==MSFalse) create(pServer_,buf,w_,h_,fg,bg);
}
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;
}
int
schro_opengl_connect (SchroOpenGL * display, const char *display_name)
{
int usable;
XGCValues values;
XPixmapFormatValues *px_formats;
int n_formats;
int i;
display->display = XOpenDisplay (display_name);
if (display->display == NULL) {
return FALSE;
}
#ifdef HANDLE_X_ERRORS
XSynchronize (display->display, True);
XSetErrorHandler (x_error_handler);
#endif
usable = schro_opengl_check_features (display);
if (!usable) {
return FALSE;
}
display->screen = DefaultScreenOfDisplay (display->display);
display->screen_num = DefaultScreen (display->display);
display->visual = DefaultVisual (display->display, display->screen_num);
display->root = DefaultRootWindow (display->display);
display->white = XWhitePixel (display->display, display->screen_num);
display->black = XBlackPixel (display->display, display->screen_num);
display->depth = DefaultDepthOfScreen (display->screen);
display->gc = XCreateGC (display->display,
DefaultRootWindow (display->display), 0, &values);
px_formats = XListPixmapFormats (display->display, &n_formats);
for (i = 0; i < n_formats; i++) {
SCHRO_ERROR ("%d: depth %d bpp %d pad %d", i,
px_formats[i].depth,
px_formats[i].bits_per_pixel, px_formats[i].scanline_pad);
}
schro_opengl_init_tmp_window (display);
return TRUE;
}
static void
set_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);
}
