static void *
lcdscrub_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
st->dpy = dpy;
st->window = window;
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->spread = get_integer_resource (st->dpy, "spread", "Integer");
st->cycles = get_integer_resource (st->dpy, "cycles", "Integer");
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
gcv.foreground = BlackPixelOfScreen (st->xgwa.screen);
gcv.background = WhitePixelOfScreen (st->xgwa.screen);
st->bg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
gcv.foreground = WhitePixelOfScreen (st->xgwa.screen);
gcv.background = BlackPixelOfScreen (st->xgwa.screen);
st->fg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (st->dpy, st->fg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg, False);
#endif
return st;
}
static void *
lcdscrub_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
st->dpy = dpy;
st->window = window;
//st->delay = get_integer_resource (st->dpy, "delay", "Integer");
//st->spread = get_integer_resource (st->dpy, "spread", "Integer");
//st->cycles = get_integer_resource (st->dpy, "cycles", "Integer");
st->delay = delay;
st->spread = spread;
st->cycles = cycles;
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
gcv.foreground = BlackPixelOfScreen (st->xgwa.screen);
gcv.background = WhitePixelOfScreen (st->xgwa.screen);
st->bg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
st->bg2 = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
gcv.foreground = WhitePixelOfScreen (st->xgwa.screen);
gcv.background = BlackPixelOfScreen (st->xgwa.screen);
st->fg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (st->dpy, st->fg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg2, False);
#endif
st->enabled_mask = 0;
#if 1
# define PREF(R,F) \
if (R) st->enabled_mask |= (1 << F)
#else
# define PREF(R,F) \
if (get_boolean_resource (st->dpy, R, "Mode")) st->enabled_mask |= (1 << F)
#endif
PREF("modeHW", HORIZ_W);
PREF("modeHB", HORIZ_B);
PREF("modeVW", VERT_W);
PREF("modeVB", VERT_B);
PREF("modeDW", DIAG_W);
PREF("modeDB", DIAG_B);
PREF("modeW", WHITE);
PREF("modeB", BLACK);
PREF("modeRGB", RGB);
# undef PREF
if (! st->enabled_mask)
{
fprintf (stderr, "%s: no modes enabled\n", progname);
exit (1);
}
pick_mode (st);
return st;
}
bool KXMessages::sendMessageX( Display* disp, WId w_P, const char* msg_type_P,
const QString& message_P, bool obsolete_P )
{
if( disp == NULL )
return false;
Atom a2 = XInternAtom( disp, msg_type_P, false );
Atom a1 = obsolete_P ? a2 : XInternAtom( disp, QByteArray(QByteArray( msg_type_P ) + "_BEGIN").constData(), false );
Window win = XCreateSimpleWindow( disp, DefaultRootWindow( disp ), 0, 0, 1, 1,
0, BlackPixelOfScreen( DefaultScreenOfDisplay( disp )),
BlackPixelOfScreen( DefaultScreenOfDisplay( disp )));
send_message_internal( w_P, message_P, 0, disp, a1, a2, win );
XDestroyWindow( disp, win );
return true;
}
IMAGE_CONTEXT *new_window( char *wnd_name, int x, int y, int width, int height )
{
IMAGE_CONTEXT *img_ctx;
img_ctx = new IMAGE_CONTEXT;
g_width = width;
g_height = height;
// First we are creating the window
if ( ( img_ctx->display = XOpenDisplay(NULL) ) == NULL )
{
printf("Error: XOpenDisplay failed.\n");
exit(1);
}
img_ctx->screenNumber = DefaultScreen( img_ctx->display );
img_ctx->screen = XScreenOfDisplay( img_ctx->display, img_ctx->screenNumber );
img_ctx->window = XCreateSimpleWindow (
img_ctx->display,
RootWindowOfScreen( img_ctx->screen ),
0,
0,
g_width,
g_height,
0,
BlackPixelOfScreen( img_ctx->screen ),
BlackPixelOfScreen( img_ctx->screen )
);
img_ctx->xImage = NULL;
if( image_create( img_ctx, g_width, g_height ) < 0 )
{
printf("Error: image_create() failed\n");
exit(1);
}
XSelectInput( img_ctx->display, img_ctx->window, ButtonPressMask | KeyPressMask );
XMapRaised( img_ctx->display, img_ctx->window );
XStoreName( img_ctx->display, img_ctx->window, wnd_name );
XGetWindowAttributes( img_ctx->display, img_ctx->window, &(img_ctx->windowAttributes ) );
XMoveWindow( img_ctx->display, img_ctx->window, x, y );
return img_ctx;
}
HelloWorld::HelloWorld(Display* display) :
_game() {
_display = display;
_screen = XDefaultScreenOfDisplay(display);
_blackColor = BlackPixelOfScreen(_screen);
_whiteColor = WhitePixelOfScreen(_screen);
_font = XLoadFont(_display, WINDOW_FONT);
int screenWidth = XWidthOfScreen(_screen);
int screenHeight = XHeightOfScreen(_screen);
int windowWidth = MIN_CELL_SIZE * 3;
int windowHeight = MIN_CELL_SIZE * 3 + STRING_HEIGHT * 3;
int windowX = (screenWidth + windowWidth) / 2;
int windowY = (screenHeight + windowHeight) / 2;
_window = XCreateSimpleWindow(_display, XRootWindowOfScreen(_screen),
windowX, windowY, windowWidth, windowHeight, 1, _blackColor,
_whiteColor);
long eventMask = ButtonPressMask | ExposureMask | KeyPressMask;
XSelectInput(_display, _window, eventMask);
draw();
}
void
drawimage(perwindow *pwin)
{
imagestruct *ip;
int i;
ip = (imagestruct *)pwin->data;
XSetForeground(dsp, pwin->gc, BlackPixelOfScreen(pwin->perscreen->screen));
for (i = 0; i < ip->iconcount; i++) {
if (!ip->iconmode)
XFillRectangle(dsp, pwin->w, pwin->gc,
ip->xb + xlogo_width * ip->icons[i].x,
ip->yb + xlogo_height * ip->icons[i].y,
xlogo_width, xlogo_height);
ip->icons[i].x = random() % ip->ncols;
ip->icons[i].y = random() % ip->nrows;
}
if (pwin->perscreen->npixels == 2)
XSetForeground(dsp, pwin->gc, WhitePixelOfScreen(pwin->perscreen->screen));
for (i = 0; i < ip->iconcount; i++) {
if (pwin->perscreen->npixels > 2)
XSetForeground(dsp, pwin->gc,
pwin->perscreen->pixels[random() % pwin->perscreen->npixels]);
XPutImage(dsp, pwin->w, pwin->gc, &logo,
0, 0,
ip->xb + xlogo_width * ip->icons[i].x,
ip->yb + xlogo_height * ip->icons[i].y,
xlogo_width, xlogo_height);
}
}
void
initimage(perwindow *pwin)
{
XWindowAttributes xgwa;
imagestruct *ip;
if (pwin->data) free(pwin->data);
pwin->data = (void *)malloc(sizeof(imagestruct));
memset(pwin->data, '\0', sizeof(imagestruct));
ip = (imagestruct *)pwin->data;
ip->startTime = seconds();
logo.data = (char *) xlogo_bits;
logo.width = xlogo_width;
logo.height = xlogo_height;
logo.bytes_per_line = (xlogo_width + 7) / 8;
XGetWindowAttributes(dsp, pwin->w, &xgwa);
ip->width = xgwa.width;
ip->height = xgwa.height;
ip->ncols = ip->width / xlogo_width;
ip->nrows = ip->height / xlogo_height;
ip->iconmode = (ip->ncols < 2 || ip->nrows < 2);
if (ip->iconmode) {
ip->xb = 0;
ip->yb = 0;
ip->iconcount = 1; /* icon mode */
} else {
ip->xb = (ip->width - xlogo_width * ip->ncols) / 2;
ip->yb = (ip->height - xlogo_height * ip->nrows) / 2;
ip->iconcount = batchcount;
}
XSetForeground(dsp, pwin->gc, BlackPixelOfScreen(pwin->perscreen->screen));
XFillRectangle(dsp, pwin->w, pwin->gc, 0, 0, ip->width, ip->height);
}
/*
** BeginWait/EndWait
**
** Display/Remove a watch cursor over topCursorWidget and its descendents
*/
void BeginWait(Widget topCursorWidget)
{
Display *display = XtDisplay(topCursorWidget);
Pixmap pixmap;
Pixmap maskPixmap;
XColor xcolors[2];
static Cursor waitCursor = 0;
/* if the watch cursor hasn't been created yet, create it */
if (!waitCursor) {
pixmap = XCreateBitmapFromData(display, DefaultRootWindow(display),
(char *)watch_bits, watch_width, watch_height);
maskPixmap = XCreateBitmapFromData(display, DefaultRootWindow(display),
(char *)watch_mask_bits, watch_width, watch_height);
xcolors[0].pixel = BlackPixelOfScreen(DefaultScreenOfDisplay(display));
xcolors[1].pixel = WhitePixelOfScreen(DefaultScreenOfDisplay(display));
XQueryColors(display, DefaultColormapOfScreen(
DefaultScreenOfDisplay(display)), xcolors, 2);
waitCursor = XCreatePixmapCursor(display, pixmap, maskPixmap,
&xcolors[0], &xcolors[1], watch_x_hot, watch_y_hot);
XFreePixmap(display, pixmap);
XFreePixmap(display, maskPixmap);
}
/* display the cursor */
XDefineCursor(display, XtWindow(topCursorWidget), waitCursor);
}
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;
}
static void *
t3d_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
st->dpy = dpy;
st->window = window;
st->dpy = dpy;
st->window = window;
initialize(st);
initColor(st,st->r,st->g,st->b);
init_3d(st);
st->zeit=(struct tm *)malloc(sizeof(struct tm));
init_kugel(st);
st->startx=st->scrnWidth/2;
st->starty=st->scrnHeight/2;
st->scrnH2=st->startx;
st->scrnW2=st->starty;
st->vspeed=0;
vektorprodukt(st->x,st->y,st->v);
viewpoint(st/*m,v*/);
setink (BlackPixelOfScreen(st->xgwa.screen));
XFillRectangle (st->dpy, st->window, st->gc, 0, 0, st->scrnWidth, st->scrnHeight);
XQueryPointer (st->dpy, st->window, &st->junk_win, &st->junk_win, &st->junk, &st->junk,
&st->px, &st->py, &st->kb);
return st;
}
static void detectorToSegment(SpaceWindow *window, SpinSegment *segdt,
SpinSegment *seg)
{
int i,j;
Pixel black;
Screen *screen;
screen = XtScreen(window->shell);
black = BlackPixelOfScreen(screen);
seg->pixel = black;
seg->x1 = window->currentLongToTr * segdt->x1;
seg->y1 = window->currentLongToTr * segdt->y1;
seg->z1 = segdt->z1;
seg->x2 = window->currentLongToTr * segdt->x2;
seg->y2 = window->currentLongToTr * segdt->y2;
seg->z2 = segdt->z2;
/*
** Now translate
*/
seg->x1 = seg->x1 +
window->currentLongToTr * window->currentTransl[0];
seg->y1 = seg->y1 +
window->currentLongToTr * window->currentTransl[1];
seg->z1 = seg->z1 +
window->currentTransl[2];
seg->x2 = seg->x2 +
window->currentLongToTr * window->currentTransl[0];
seg->y2 = seg->y2 +
window->currentLongToTr * window->currentTransl[1];
seg->z2 = seg->z2 +
window->currentTransl[2];
return;
}
static void
InitPointerBlank(Widget w)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
DtTermPrimData tpd = tw->term.tpd;
XColor fg = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 };
XColor bg = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 };
Pixmap noPointerBitmap;
/*
** set a pointer motion handler...
*/
tpd->pointerTimeoutID = 0 ;
tpd->pointerFrozen = True ;
fg.pixel = bg.pixel = BlackPixelOfScreen(XtScreen(w));
noPointerBitmap = XCreateBitmapFromData(XtDisplay(w),XtWindow(tw),
whiteBits, whiteW, whiteH);
tpd->noPointer = XCreatePixmapCursor(XtDisplay(tw),
noPointerBitmap, /* source bitmap */
noPointerBitmap, /* mask bitmap */
&fg, &bg, /* Do not care */
0, 0); /* hotspot */
XFreePixmap(XtDisplay(w), noPointerBitmap);
XtAddEventHandler((Widget)tw, PointerMotionMask, FALSE, PointerMoved,
(XtPointer)NULL);
tpd->pointerFirst = False ;
}
static void *
distort_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
long gcflags;
st->dpy = dpy;
st->window = window;
distort_reset (st);
st->black_pixel = BlackPixelOfScreen( st->xgwa.screen );
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcflags = GCFunction;
if (use_subwindow_mode_p(st->xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
st->gc = XCreateGC (st->dpy, st->window, gcflags, &gcv);
/* On MacOS X11, XGetImage on a Window often gets an inexplicable BadMatch,
possibly due to the window manager having occluded something? It seems
nondeterministic. Loading the image into a pixmap instead fixes it. */
if (st->pm) XFreePixmap (st->dpy, st->pm);
st->pm = XCreatePixmap (st->dpy, st->window,
st->xgwa.width, st->xgwa.height, st->xgwa.depth);
st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
st->pm, 0, 0);
st->start_time = time ((time_t *) 0);
return st;
}
static Pixmap
ConvertPixmap(char *file_name, int depth)
#endif
{
XrmValue fg_from,
fg_to,
bg_from,
bg_to;
Pixel fg,
bg;
fg_from.size = strlen(XtDefaultForeground);
fg_from.addr = XtDefaultForeground;
fg_to.addr = (XPointer) & fg;
bg_from.size = strlen(XtDefaultBackground);
bg_from.addr = XtDefaultBackground;
bg_to.addr = (XPointer) & bg;
if (!XtConvertAndStore
(UxTopLevel, XtRString, &bg_from, XtRPixel, &bg_to)
|| !XtConvertAndStore
(UxTopLevel, XtRString, &fg_from, XtRPixel, &fg_to)
|| (fg == bg)) {
fg = WhitePixelOfScreen(XtScreen(UxTopLevel));
bg = BlackPixelOfScreen(XtScreen(UxTopLevel));
}
if (depth)
return (XmGetPixmapByDepth
(XtScreen(UxTopLevel), file_name, fg, bg, depth));
else
return (XmGetPixmap(XtScreen(UxTopLevel), file_name, fg, bg));
}
/**
@pre display is valid, themes is valid, cursors is valid.
@pre all widgets are zero'd.
@pre themes is valid and has loaded at least a background for the popup_menu_parent.
@post Menu with borders and background but no items is created but not mapped.
@brief This function is used to create a blank and generic menu. Items must be added by caller.
@return void
**/
void
create_popup_menu(Display *display, struct Popup_menu *menu, struct Themes *themes, struct Cursors *cursors) {
XSetWindowAttributes set_attributes;
Window root = DefaultRootWindow(display);
Screen* screen = DefaultScreenOfDisplay(display);
int black = BlackPixelOfScreen(screen);
const int width = menu->inner_width + themes->popup_menu[popup_l_edge].w + themes->popup_menu[popup_r_edge].w;
const int height = menu->inner_height + themes->popup_menu[popup_t_edge].h + themes->popup_menu[popup_b_edge].h;
menu->widgets[popup_menu_parent].widget = XCreateSimpleWindow(display, root
, 0, 0
, width, height, 0, black, black);
XDefineCursor(display, menu->widgets[popup_menu_parent].widget, cursors->normal);
XSetWindowBackgroundPixmap(display, menu->widgets[popup_menu_parent].widget
, themes->popup_menu[popup_menu_parent].state_p[normal]);
//Currently, this is the "base" of the popup menu.
//A similar loop will be needed for the actual menu items but not in this function
for(int i = popup_t_edge; i < popup_menu_parent; i++) { //popup_menu_parent already done
int x = themes->popup_menu[i].x;
int y = themes->popup_menu[i].y;
int w = themes->popup_menu[i].w;
int h = themes->popup_menu[i].h;
if(x < 0) x += width;
if(y < 0) y += height;
if(w <= 0) w += width;
if(h <= 0) h += height;
menu->widgets[i].widget = XCreateSimpleWindow(display
, menu->widgets[popup_menu_parent].widget
, x, y, w, h, 0, black, black);
if(themes->popup_menu[i].w <= 0) w = XWidthOfScreen(screen);
if(themes->popup_menu[i].h <= 0) h = XWidthOfScreen(screen);
for(int j = 0; j <= inactive; j++) {
if(themes->popup_menu[i].state_p[j]) {
menu->widgets[i].state[j] = XCreateSimpleWindow(display, menu->widgets[i].widget
, 0, 0, w, h, 0, black, black);
XSetWindowBackgroundPixmap(display, menu->widgets[i].state[j]
, themes->popup_menu[i].state_p[j]);
if(j == normal) XMapWindow(display, menu->widgets[i].state[j]);
}
}
XMapWindow(display, menu->widgets[i].widget);
}
set_attributes.override_redirect = True;
XChangeWindowAttributes(display, menu->widgets[popup_menu_parent].widget, CWOverrideRedirect, &set_attributes);
// XMapWindow(display, menu->widgets[popup_menu_parent].widget);
XFlush(display);
}
Pixmap XbrGfxLoadBitmap(Widget w, char *bits, int width, int height, int inherit)
{
XGCValues vals;
Pixmap pixmap;
GC gc;
Display *display = XtDisplay(w);
Screen *screen = XtScreen(w);
Window root = RootWindowOfScreen(screen);
/* Get the foreground and background colours of the widget */
if(inherit) {
XtVaGetValues(w, XmNforeground, &vals.foreground, XmNbackground,
&vals.background, NULL);
} else {
vals.foreground = BlackPixelOfScreen(screen);
vals.background = WhitePixelOfScreen(screen);
}
/* Create a GC for drawing the pixmap */
gc = XCreateGC(display, root, GCForeground|GCBackground, &vals);
/* Change the bitmap to a pixmap */
pixmap = XbrGfxReadBitmap(display, screen, gc, bits, width, height);
/* Free GC we have finished with */
XFreeGC(display, gc);
/* Return the pixmap */
return(pixmap);
}
Cursor _Delay::hourglass_cursor()
{
if (hourglass_cache != 0)
return hourglass_cache;
Display *display = XtDisplay(widget);
#if SMALL_HOURGLASS_CURSOR || LARGE_HORGLASS_CURSOR
Screen *screen = XtScreen(widget);
Window rootWindow = RootWindowOfScreen(screen);
unsigned char *cursor_bits = time16_bits;
unsigned char *cursor_mask_bits = time16m_bits;
unsigned int cursor_width = time16_width;
unsigned int cursor_height = time16_height;
unsigned int cursor_x_hot = time16_x_hot;
unsigned int cursor_y_hot = time16_y_hot;
#if LARGE_HOURGLASS_CURSOR
// Fetch cursor shape
unsigned int width, height;
XQueryBestCursor(display, rootWindow, 32, 32, &width, &height);
Boolean largeCursors = (width >= 32 && height >= 32);
if (largeCursors)
{
cursor_bits = time32_bits;
cursor_mask_bits = time32m_bits;
cursor_width = time32_width;
cursor_height = time32_height;
cursor_x_hot = time32_x_hot;
cursor_y_hot = time32_y_hot;
}
#endif
Pixmap cursor_pixmap =
XCreateBitmapFromData(display, rootWindow, (char *)cursor_bits,
cursor_width, cursor_height);
Pixmap cursor_mask_pixmap =
XCreateBitmapFromData(display, rootWindow, (char *)cursor_mask_bits,
cursor_width, cursor_height);
XColor cursor_colors[2];
cursor_colors[0].pixel = BlackPixelOfScreen(screen);
cursor_colors[1].pixel = WhitePixelOfScreen(screen);
XQueryColors(display, DefaultColormapOfScreen(screen),
cursor_colors, 2);
hourglass_cache =
XCreatePixmapCursor(display, cursor_pixmap, cursor_mask_pixmap,
cursor_colors, cursor_colors + 1,
cursor_x_hot, cursor_y_hot);
#else // Watch cursor
hourglass_cache =
XCreateFontCursor(display, XC_watch);
#endif
return hourglass_cache;
}
/* drawing setup- colors, lines, etc*/
void CreateDrawTools ( Widget parent )
{
MainCanvas = parent;
gcv.foreground = BlackPixelOfScreen (XtScreen (MainCanvas));
gc = XCreateGC (XtDisplay (MainCanvas), RootWindowOfScreen (XtScreen (MainCanvas)), GCForeground, &gcv);
XtVaSetValues (MainCanvas, XmNuserData, gc, NULL);
}
static void
monoColormap(Screen * scr, ScreenInfo * si, char *foreground, char *background)
{
si->black_pixel = BlackPixelOfScreen(scr);
si->white_pixel = WhitePixelOfScreen(scr);
if (strcmp(foreground, "White") == 0 || strcmp(foreground, "white") == 0 ||
strcmp(background, "Black") == 0 || strcmp(background, "black") == 0) {
si->fg_pixel = WhitePixelOfScreen(scr);
si->bg_pixel = BlackPixelOfScreen(scr);
} else {
si->fg_pixel = BlackPixelOfScreen(scr);
si->bg_pixel = WhitePixelOfScreen(scr);
}
si->pixels[0] = WhitePixelOfScreen(scr);
si->pixels[1] = BlackPixelOfScreen(scr);
si->npixels = 2;
}
static void
create_gc(Widget w)
{
XGCValues values;
XmFontList fontlist;
XFontStruct *font, **font_struct_list;
XFontSet fontset;
char **font_name_list, *tag;
XtPointer t;
XmFontContext context;
XmFontListEntry first_entry, entry;
XmFontType font_type;
int font_count;
if (gc)
return;
/* Assume parent is Shell or BulletinBoard */
XtVaGetValues(XtParent(w), XmNlabelFontList, &fontlist, NULL);
if (fontlist)
if (XmFontListInitFontContext(&context, fontlist)) {
/* Get first entry */
entry = XmFontListNextEntry(context);
first_entry = entry;
/* Walk down list looking for "Drawing" */
while (entry) {
tag = XmFontListEntryGetTag(entry);
if (strcmp(tag, "Drawing") == 0) {
XtFree(tag);
break;
}
XtFree(tag);
entry = XmFontListNextEntry(context);
}
XmFontListFreeFontContext(context);
/* If we didn't find it use first entry */
if (!entry)
entry = first_entry;
/* Get the font */
t = XmFontListEntryGetFont(entry, &font_type);
if (font_type == XmFONT_IS_FONT)
font = (XFontStruct *) t;
else {
/*
* It's a font set - use the first one in the
* set
*/
fontset = (XFontSet) t;
font_count = XFontsOfFontSet(fontset, &font_struct_list,
&font_name_list);
font = font_struct_list[0];
}
values.font = font->fid;
values.foreground = BlackPixelOfScreen(XtScreen(w));
gc = XCreateGC(XtDisplay(w), XtWindow(w),
GCFont | GCForeground, &values);
}
}
// Convert String to Pixmap (using XmGetPixmap)
// A Pixmap will be read in as bitmap file
// 1 and 0 values are set according to the widget's
// foreground/background colors.
static Boolean CvtStringToPixmap(Display *display,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *)
{
// Default parameters
Screen *screen = DefaultScreenOfDisplay(display);
Pixel background = WhitePixelOfScreen(screen);
Pixel foreground = BlackPixelOfScreen(screen);
if (*num_args >= 1)
{
// convert first arg into widget
Widget w = *(Widget *) args[0].addr;
background = w->core.background_pixel;
screen = XtScreen(w);
if (XtIsWidget(w) && XmIsPrimitive(w))
{
// Get foreground color from widget
foreground = XmPrimitiveWidget(w)->primitive.foreground;
}
else
{
// Ask Motif for a default foreground color
Pixel newfg, newtop, newbot, newselect;
XmGetColors(screen, w->core.colormap, background,
&newfg, &newtop, &newbot, &newselect);
foreground = newfg;
}
}
// Get pixmap
Pixmap p = XmUNSPECIFIED_PIXMAP;
string value = str(fromVal, false);
// Some Motif versions use `unspecified_pixmap' and `unspecified pixmap'
// as values for XmUNSPECIFIED_PIXMAP. Check for this.
string v = downcase(value);
v.gsub(" ", "_");
if (v.contains("xm", 0))
v = v.after("xm");
if (v != "unspecified_pixmap")
{
p = XmGetPixmap(screen, XMST(value.chars()), foreground, background);
if (p == XmUNSPECIFIED_PIXMAP)
{
XtDisplayStringConversionWarning(display, fromVal->addr,
XmRPixmap);
return False;
}
}
done(Pixmap, p);
}
int initXconnection()
{
x11Display = XOpenDisplay(NULL);
if (x11Display != 0L)
{
XSetIOErrorHandler(xio_errhandler);
XCreateSimpleWindow(x11Display, DefaultRootWindow(x11Display),
0, 0, 1, 1, 0,
BlackPixelOfScreen(DefaultScreenOfDisplay(x11Display)),
BlackPixelOfScreen(DefaultScreenOfDisplay(x11Display)));
return XConnectionNumber(x11Display);
} else
{
kdWarning(1205) << "Can't connect to the X Server.\n";
kdWarning(1205) << "Might not terminate at end of session.\n";
return -1;
}
}
int main(int argc, char *argv[])
{
theDisplay = XOpenDisplay(NULL);
XSynchronize(theDisplay, True);
theScreen = DefaultScreenOfDisplay(theDisplay);
theWindow = XCreateSimpleWindow(theDisplay, RootWindowOfScreen(theScreen),
0, 0,
WINDOW_SIZE, WINDOW_SIZE, 0,
BlackPixelOfScreen(theScreen),
WhitePixelOfScreen(theScreen));
theGC = XCreateGC(theDisplay, theWindow, 0L, NULL);
XSetForeground(theDisplay, theGC, BlackPixelOfScreen(theScreen));
XMapWindow(theDisplay, theWindow);
/* more stuff to come here... */
tortoise_reset();
gh_enter(argc, argv, inner_main);
return 0; /* never reached */
}
void MAOpenGLInitCb(
Widget w,
XtPointer clientData,
XtPointer callData)
{
static String xFontStr = "-*-courier-*-*-*-*-14-*-*-*-*-*-*-*";
Font xFont;
WlzDVertex3 tVtx, orgVtx;
Display *dpy = XtDisplay( w );
(void )HGUglwCreateCanvasGlxContext(w, NULL);
HGUglwCanvasGlxMakeCurrent(w, NULL);
xFont = XLoadFont(XtDisplay(w), xFontStr);
if(xFont)
{
threeDFont = HGUglTextFontCreate(xFont);
}
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
if( globals.toplDepth == 24 ){
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_FOG);
glFogf(GL_FOG_MODE, GL_LINEAR);
}
else {
glClearIndex( (GLfloat) BlackPixelOfScreen(XtScreen(w)) );
}
/* set the initial transform - should be from resources */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotated( (GLdouble) 90.0, (GLdouble) 1.0, (GLdouble) 0.0, (GLdouble) 0.0);
glRotated((GLdouble) -40.0, (GLdouble) 0.0, (GLdouble) 0.0, (GLdouble) 1.0);
glRotated( (GLdouble) 20.0, (GLdouble) 0.6, (GLdouble) 0.4, (GLdouble) 0.0);
glGetDoublev(GL_MODELVIEW_MATRIX, &initial_rot[0][0]);
/* create the default 3D display DisplayList */
globals.ref_display_list = glGenLists( (GLsizei) 1 );
glNewList( globals.ref_display_list, GL_COMPILE );
WLZ_VTX_3_SET(tVtx, 10.0, 10.0, 10.0);
WLZ_VTX_3_SET(orgVtx, 5.0, 5.0, 5.0);
if( globals.toplDepth == 24 ){
glColor3d((GLdouble) 1.0, (GLdouble) 1.0, (GLdouble) 1.0);
}
else {
glIndexi( HGU_XGetColorPixel(dpy, globals.cmap, 1.0, 1.0, 1.0) );
}
HGUglShapeWireCube(tVtx, orgVtx);
glEndList();
WLZ_VTX_3_SET(globals.bbox_vtx, -2.0, -2.0, -2.0);
WLZ_VTX_3_SET(globals.bbox_size, 14.0, 14.0, 14.0);
return;
}
/* Loads an image into the Drawable, returning once the image is loaded.
*/
static void
load_random_image_android (Screen *screen, Window window, Drawable drawable,
void (*callback) (Screen *, Window, Drawable,
const char *name,
XRectangle *geom, void *closure),
void *closure)
{
Display *dpy = DisplayOfScreen (screen);
XWindowAttributes xgwa;
XRectangle geom;
char *name = 0;
char *data = 0;
int width = 0;
int height = 0;
if (!drawable) abort();
XGetWindowAttributes (dpy, window, &xgwa);
{
Window r;
int x, y;
unsigned int w, h, bbw, d;
XGetGeometry (dpy, drawable, &r, &x, &y, &w, &h, &bbw, &d);
xgwa.width = w;
xgwa.height = h;
}
geom.x = 0;
geom.y = 0;
geom.width = xgwa.width;
geom.height = xgwa.height;
data = jwxyz_load_random_image (dpy, &width, &height, &name);
if (! data)
draw_colorbars (screen, xgwa.visual, drawable, xgwa.colormap,
0, 0, xgwa.width, xgwa.height);
else
{
XImage *img = XCreateImage (dpy, xgwa.visual, 32,
ZPixmap, 0, data, width, height, 0, 0);
XGCValues gcv;
GC gc;
gcv.foreground = BlackPixelOfScreen (screen);
gc = XCreateGC (dpy, drawable, GCForeground, &gcv);
XFillRectangle (dpy, drawable, gc, 0, 0, xgwa.width, xgwa.height);
XPutImage (dpy, drawable, gc, img, 0, 0,
(xgwa.width - width) / 2,
(xgwa.height - height) / 2,
width, height);
XDestroyImage (img);
XFreeGC (dpy, gc);
}
callback (screen, window, drawable, name, &geom, closure);
if (name) free (name);
}
void xf_create_window(xfContext* xfc)
{
XEvent xevent;
int width, height;
char* windowTitle;
ZeroMemory(&xevent, sizeof(xevent));
width = xfc->width;
height = xfc->height;
if (!xfc->remote_app)
{
xfc->attribs.background_pixel = BlackPixelOfScreen(xfc->screen);
xfc->attribs.border_pixel = WhitePixelOfScreen(xfc->screen);
xfc->attribs.backing_store = xfc->primary ? NotUseful : Always;
xfc->attribs.override_redirect = xfc->grab_keyboard ? xfc->fullscreen : False;
xfc->attribs.colormap = xfc->colormap;
xfc->attribs.bit_gravity = NorthWestGravity;
xfc->attribs.win_gravity = NorthWestGravity;
if (xfc->instance->settings->WindowTitle)
{
windowTitle = _strdup(xfc->instance->settings->WindowTitle);
}
else if (xfc->instance->settings->ServerPort == 3389)
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(xfc->instance->settings->ServerHostname));
sprintf(windowTitle, "FreeRDP: %s", xfc->instance->settings->ServerHostname);
}
else
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(xfc->instance->settings->ServerHostname) + sizeof(":00000"));
sprintf(windowTitle, "FreeRDP: %s:%i", xfc->instance->settings->ServerHostname, xfc->instance->settings->ServerPort);
}
printf ("xfc->settings->Decorations=%d\n", xfc->settings->Decorations);
xfc->window = xf_CreateDesktopWindow(xfc, windowTitle, width, height, xfc->settings->Decorations);
free(windowTitle);
if (xfc->fullscreen)
xf_SetWindowFullscreen(xfc, xfc->window, xfc->fullscreen);
xfc->unobscured = (xevent.xvisibility.state == VisibilityUnobscured);
XSetWMProtocols(xfc->display, xfc->window->handle, &(xfc->WM_DELETE_WINDOW), 1);
xfc->drawable = xfc->window->handle;
}
else
{
xfc->drawable = DefaultRootWindow(xfc->display);
}
}
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)));
}
/**
@brief Creates the mode menu which can be used by all windows in all workspaces. The main even loop uses the windows and events to determine if a mode menu item was clicked or interacted with in some way.
@return void
**/
void
create_mode_menu(Display *display, struct Mode_menu *mode_menu
, struct Themes *themes, struct Cursors *cursors) {
Screen* screen = DefaultScreenOfDisplay(display);
int black = BlackPixelOfScreen(screen);
mode_menu->menu.inner_width = DEFAULT_MENU_ITEM_WIDTH;
mode_menu->menu.inner_height = themes->popup_menu[menu_item_mid].h * (hidden + 1);
create_popup_menu(display, &mode_menu->menu, themes, cursors);
//Create the menu items
for(int i = 0; i <= hidden; i++) {
mode_menu->items[i].item = XCreateSimpleWindow(display, mode_menu->menu.widgets[popup_menu_parent].widget
, themes->popup_menu[popup_l_edge].w, themes->popup_menu[popup_t_edge].h + themes->popup_menu[menu_item_mid].h * i
, mode_menu->menu.inner_width, themes->popup_menu[menu_item_mid].h, 0, black, black);
XSelectInput(display, mode_menu->items[i].item, ButtonReleaseMask | EnterWindowMask | LeaveWindowMask);
for(int j = 0; j <= inactive; j++) {
if(themes->popup_menu[i].state_p[j]) {
char *label = NULL;
char Floating[] = "Floating";
char Tiling[] = "Tiling";
char Hidden[] = "Hidden";
char Desktop[] = "Desktop";
switch(i) {
case floating: label = Floating;
break;
case tiling: label = Tiling;
break;
case hidden: label = Hidden;
break;
case desktop: label = Desktop;
break;
}
mode_menu->items[i].state[j] = XCreateSimpleWindow(display, mode_menu->items[i].item
, 0, 0, mode_menu->menu.inner_width, themes->popup_menu[menu_item_mid].h, 0, black, black);
create_text_background(display, mode_menu->items[i].state[j], label, &themes->font_theme[j]
, themes->popup_menu[menu_item_mid].state_p[j]
, themes->popup_menu[menu_item_mid].w, themes->popup_menu[menu_item_mid].h);
XMapWindow(display, mode_menu->items[i].state[j]);
}
// else printf("Warning: Skipping state pixmap\n");
}
XMapWindow(display, mode_menu->items[i].item);
}
}
void xf_create_window(xfInfo* xfi)
{
XEvent xevent;
char* win_title;
int width, height;
width = xfi->width;
height = xfi->height;
xfi->attribs.background_pixel = BlackPixelOfScreen(xfi->screen);
xfi->attribs.border_pixel = WhitePixelOfScreen(xfi->screen);
xfi->attribs.backing_store = xfi->primary ? NotUseful : Always;
xfi->attribs.override_redirect = xfi->fullscreen;
xfi->attribs.colormap = xfi->colormap;
xfi->attribs.bit_gravity = ForgetGravity;
xfi->attribs.win_gravity = StaticGravity;
if (xfi->instance->settings->window_title != NULL)
{
win_title = xstrdup(xfi->instance->settings->window_title);
}
else if (xfi->instance->settings->port == 3389)
{
win_title = xmalloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname));
sprintf(win_title, "FreeRDP: %s", xfi->instance->settings->hostname);
}
else
{
win_title = xmalloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname) + sizeof(":00000"));
sprintf(win_title, "FreeRDP: %s:%i", xfi->instance->settings->hostname, xfi->instance->settings->port);
}
xfi->window = xf_CreateDesktopWindow(xfi, win_title, width, height, xfi->decorations);
xfree(win_title);
if (xfi->parent_window)
XReparentWindow(xfi->display, xfi->window->handle, xfi->parent_window, 0, 0);
if (xfi->fullscreen)
xf_SetWindowFullscreen(xfi, xfi->window, xfi->fullscreen);
/* wait for VisibilityNotify */
do
{
XMaskEvent(xfi->display, VisibilityChangeMask, &xevent);
}
while (xevent.type != VisibilityNotify);
xfi->unobscured = (xevent.xvisibility.state == VisibilityUnobscured);
XSetWMProtocols(xfi->display, xfi->window->handle, &(xfi->WM_DELETE_WINDOW), 1);
xfi->drawable = xfi->window->handle;
}
/* 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;
}
