FontInfoPtr
SuckGlyphsFromServer(Display * dpy, Font font)
{
  Pixmap offscreen;
  XFontStruct *fontinfo;
  XImage *image;
  GC xgc;
  XGCValues values;
  int numchars;
  int width, height, pixwidth;
  int i, j;
  XCharStruct *charinfo;
  XChar2b character;
  unsigned char *bitmapData;
  int x, y;
  int spanLength;
  int charWidth, charHeight, maxSpanLength;
  int grabList[MAX_GLYPHS_PER_GRAB];
  int glyphsPerGrab = MAX_GLYPHS_PER_GRAB;
  int numToGrab, thisglyph;
  FontInfoPtr myfontinfo;

  fontinfo = XQueryFont(dpy, font);
  if (!fontinfo)
    return NULL;

  numchars = fontinfo->max_char_or_byte2 - fontinfo->min_char_or_byte2 + 1;
  if (numchars < 1)
    return NULL;

  myfontinfo = (FontInfoPtr) malloc(sizeof(FontInfo) + (numchars - 1) * sizeof(PerGlyphInfo));
  if (!myfontinfo)
    return NULL;

  myfontinfo->min_char = fontinfo->min_char_or_byte2;
  myfontinfo->max_char = fontinfo->max_char_or_byte2;
  myfontinfo->max_ascent = fontinfo->max_bounds.ascent;
  myfontinfo->max_descent = fontinfo->max_bounds.descent;

  width = fontinfo->max_bounds.rbearing - fontinfo->min_bounds.lbearing;
  height = fontinfo->max_bounds.ascent + fontinfo->max_bounds.descent;

  maxSpanLength = (width + 7) / 8;
  /* Be careful determining the width of the pixmap; the X protocol allows
     pixmaps of width 2^16-1 (unsigned short size) but drawing coordinates
     max out at 2^15-1 (signed short size).  If the width is too large, we
     need to limit the glyphs per grab.  */
  if ((glyphsPerGrab * 8 * maxSpanLength) >= (1 << 15)) {
    glyphsPerGrab = (1 << 15) / (8 * maxSpanLength);
  }
  pixwidth = glyphsPerGrab * 8 * maxSpanLength;
  offscreen = XCreatePixmap(dpy, RootWindow(dpy, DefaultScreen(dpy)),
    pixwidth, height, 1);

  values.font = font;
  values.background = 0;
  values.foreground = 0;
  xgc = XCreateGC(dpy, offscreen, GCFont | GCBackground | GCForeground, &values);

  XFillRectangle(dpy, offscreen, xgc, 0, 0, 8 * maxSpanLength * glyphsPerGrab, height);
  XSetForeground(dpy, xgc, 1);

  numToGrab = 0;
  if (fontinfo->per_char == NULL) {
    charinfo = &(fontinfo->min_bounds);
    charWidth = charinfo->rbearing - charinfo->lbearing;
    charHeight = charinfo->ascent + charinfo->descent;
    spanLength = (charWidth + 7) / 8;
  }
  for (i = 0; i < numchars; i++) {
    if (fontinfo->per_char != NULL) {
      charinfo = &(fontinfo->per_char[i]);
      charWidth = charinfo->rbearing - charinfo->lbearing;
      charHeight = charinfo->ascent + charinfo->descent;
      if (charWidth == 0 || charHeight == 0) {
        /* Still must move raster pos even if empty character */
        myfontinfo->glyph[i].width = 0;
        myfontinfo->glyph[i].height = 0;
        myfontinfo->glyph[i].xoffset = 0;
        myfontinfo->glyph[i].yoffset = 0;
        myfontinfo->glyph[i].advance = charinfo->width;
        myfontinfo->glyph[i].bitmap = NULL;
        goto PossiblyDoGrab;
      }
    }
    grabList[numToGrab] = i;

    /* XXX is this right for large fonts? */
    character.byte2 = (i + fontinfo->min_char_or_byte2) & 255;
    character.byte1 = (i + fontinfo->min_char_or_byte2) >> 8;

    /* XXX we could use XDrawImageString16 which would also paint the backing

       rectangle but X server bugs in some scalable font rasterizers makes it

       more effective to do XFillRectangles to clear the pixmap and
       XDrawImage16 for the text.  */
    XDrawString16(dpy, offscreen, xgc,
      -charinfo->lbearing + 8 * maxSpanLength * numToGrab,
      charinfo->ascent, &character, 1);

    numToGrab++;

  PossiblyDoGrab:

    if (numToGrab >= glyphsPerGrab || i == numchars - 1) {
      image = XGetImage(dpy, offscreen,
        0, 0, pixwidth, height, 1, XYPixmap);
      for (j = 0; j < numToGrab; j++) {
        thisglyph = grabList[j];
        if (fontinfo->per_char != NULL) {
          charinfo = &(fontinfo->per_char[thisglyph]);
          charWidth = charinfo->rbearing - charinfo->lbearing;
          charHeight = charinfo->ascent + charinfo->descent;
          spanLength = (charWidth + 7) / 8;
        }
        bitmapData = (unsigned char *)calloc(height * spanLength, sizeof(char));
        if (!bitmapData)
          goto FreeFontAndReturn;
        DEBUG_GLYPH4("index %d, glyph %d (%d by %d)\n",
          j, thisglyph + fontinfo->min_char_or_byte2, charWidth, charHeight);
        for (y = 0; y < charHeight; y++) {
          for (x = 0; x < charWidth; x++) {
            /* XXX The algorithm used to suck across the font ensures that
               each glyph begins on a byte boundary.  In theory this would
               make it convienent to copy the glyph into a byte oriented
               bitmap.  We actually use the XGetPixel function to extract
               each pixel from the image which is not that efficient.  We
               could either do tighter packing in the pixmap or more
               efficient extraction from the image.  Oh well.  */
            if (XGetPixel(image, j * maxSpanLength * 8 + x, charHeight - 1 - y)) {
              DEBUG_GLYPH("x");
              bitmapData[y * spanLength + x / 8] |= (1 << (x & 7));
            } else {
              DEBUG_GLYPH(" ");
            }
          }
          DEBUG_GLYPH("\n");
        }
        myfontinfo->glyph[thisglyph].width = charWidth;
        myfontinfo->glyph[thisglyph].height = charHeight;
        myfontinfo->glyph[thisglyph].xoffset = charinfo->lbearing;
        myfontinfo->glyph[thisglyph].yoffset = -charinfo->descent;
        myfontinfo->glyph[thisglyph].advance = charinfo->width;
        myfontinfo->glyph[thisglyph].bitmap = bitmapData;
      }
      XDestroyImage(image);
      numToGrab = 0;
      /* do we need to clear the offscreen pixmap to get more? */
      if (i < numchars - 1) {
        XSetForeground(dpy, xgc, 0);
        XFillRectangle(dpy, offscreen, xgc, 0, 0, 8 * maxSpanLength * glyphsPerGrab, height);
        XSetForeground(dpy, xgc, 1);
      }
    }
  }
  XFreeGC(dpy, xgc);
  XFreePixmap(dpy, offscreen);
  return myfontinfo;

FreeFontAndReturn:
  XDestroyImage(image);
  XFreeGC(dpy, xgc);
  XFreePixmap(dpy, offscreen);
  for (j = i - 1; j >= 0; j--) {
    if (myfontinfo->glyph[j].bitmap)
      free(myfontinfo->glyph[j].bitmap);
  }
  free(myfontinfo);
  return NULL;
}
Exemple #2
0
void
xDrawLegendBox (Display *dpy, Window win,
	int x, int y, int width, int height,
	float bclip, float wclip, char *units, char *legendfont,
	char *labelfont, char *title, char *titlefont,
	char *axescolor, char *titlecolor, char *gridcolor,
	int style)
/*****************************************************************************
draw a labeled axes box
******************************************************************************
Input:
dpy		display pointer
win		window
x		x coordinate of upper left corner of box
y		y coordinate of upper left corner of box
width		width of box
height		height of box
units		label for legend
legendfont	name of font to use for legend labels
labelfont	name of font to use for axes labels
title		axes box title
titlefont	name of font to use for title
axescolor	name of color to use for axes
titlecolor	name of color to use for title
gridcolor	name of color to use for grid
int style	NORMAL (axis 1 on bottom, axis 2 on left)
		SEISMIC (axis 1 on left, axis 2 on top)
******************************************************************************
Notes:
xDrawLegendBox will determine the numbered tic incremenet and first
numbered tic automatically, if the specified increment is zero.

Pad values must be specified in the same units as the corresponding
axes values.  These pads are useful when the contents of the axes box
requires more space than implied by the axes values.  For example,
the first and last seismic wiggle traces plotted inside an axes box
will typically extend beyond the axes values corresponding to the
first and last traces.  However, all tics will lie within the limits
specified in the axes values (x1beg, x1end, x2beg, x2end).
******************************************************************************
Author:		Dave Hale, Colorado School of Mines, 01/27/90
Author:		Berend Scheffers , TNO Delft, 06/11/92
*****************************************************************************/
{
	GC gca,gct,gcg;
	XGCValues *values=NULL;
	XColor scolor,ecolor;
	XFontStruct *fa,*ft;
	XWindowAttributes wa;
	Colormap cmap;
	int labelca,labelcd,labelch,labelcw,titleca,titlecd,titlech,titlecw,
		xa,ya,tw,ticsize,ticb,numb,lstr,scr;
	float dnum=EPS,amin,amax,base,anum,azero;
	char str[256];

	/* get screen */
	scr = DefaultScreen(dpy);

	/* create graphics contexts */
	gca = XCreateGC(dpy,win,0,values);
	gct = XCreateGC(dpy,win,0,values);
	gcg = XCreateGC(dpy,win,0,values);

	/* get and set fonts and determine character dimensions */
	fa = XLoadQueryFont(dpy,legendfont);
	if (fa==NULL) fa = XLoadQueryFont(dpy,"fixed");
	if (fa==NULL) {
		fprintf(stderr,"Cannot load/query legendfont=%s\n",legendfont);
		exit(-1);
	}
	XSetFont(dpy,gca,fa->fid);
	labelca = fa->max_bounds.ascent;
	labelcd = fa->max_bounds.descent;
	labelch = fa->max_bounds.ascent+fa->max_bounds.descent;
	labelcw = fa->max_bounds.lbearing+fa->max_bounds.rbearing;
	ft = XLoadQueryFont(dpy,titlefont);
	if (ft==NULL) ft = XLoadQueryFont(dpy,"fixed");
	if (ft==NULL) {
		fprintf(stderr,"Cannot load/query titlefont=%s\n",titlefont);
		exit(-1);
	}
	XSetFont(dpy,gct,ft->fid);
	titleca = ft->max_bounds.ascent;
	titlecd = ft->max_bounds.descent;
	titlech = ft->max_bounds.ascent+ft->max_bounds.descent;
	titlecw = ft->max_bounds.lbearing+ft->max_bounds.rbearing;

	/* determine window's current colormap */
	XGetWindowAttributes(dpy,win,&wa);
	cmap = wa.colormap;

	/* get and set colors */
	if (XAllocNamedColor(dpy,cmap,axescolor,&scolor,&ecolor))
		XSetForeground(dpy,gca,ecolor.pixel);
	else
		XSetForeground(dpy,gca,1L);
	if (XAllocNamedColor(dpy,cmap,titlecolor,&scolor,&ecolor))
		XSetForeground(dpy,gct,ecolor.pixel);
	else
		XSetForeground(dpy,gct,1L);
	if (XAllocNamedColor(dpy,cmap,gridcolor,&scolor,&ecolor))
		XSetForeground(dpy,gcg,ecolor.pixel);
	else
		XSetForeground(dpy,gcg,1L);

	/* determine tic size */
	ticsize = labelcw;

	/* draw vertical axis */
	amin = wclip;
	amax = bclip;

	/* trap for cases when bclip=wclip */
	if ((bclip - wclip)!=0) dnum = (bclip-wclip)/4;

	base = y;

	ticb = -ticsize;
	numb = ticb-ticsize/4;

	azero = 0.0001*(amax-amin);

	xa = x+1.25*width;
	ya = y;
	for (anum=amax; anum>=amin; anum-=dnum) {
		if (anum<amin) continue;
		XDrawLine(dpy,win,gca,x,ya,x+width,ya);
		XDrawLine(dpy,win,gca,x+width,ya,xa,ya);
		sprintf(str,"%1.4g",anum);
		lstr = strlen(str);
		tw = XTextWidth(fa,str,lstr);
		XDrawString(dpy,win,gca,xa+width/4,ya+labelca/2,str,lstr);
		ya += height/4;
	}

	xa = x+width/8;
	ya = y+height+labelch;
	sprintf(str,units);
	lstr = strlen(str);
	tw = XTextWidth(fa,str,lstr);
	XDrawString(dpy,win,gca,xa,ya,str,lstr);


	/* draw axes box */
	XDrawRectangle(dpy,win,gca,x,y,width,height);

	/* free resources before returning */
	XFreeGC(dpy,gca);
	XFreeGC(dpy,gct);
	XFreeGC(dpy,gcg);
}
Exemple #3
0
int main(int argc, char**argv) {
    char **missing_charset_list;
    int missing_charset_count;
    XGCValues xgcv;
    unsigned long mask;
    Display* dpy;
    int scr;
    Window w, root;
    XSetWindowAttributes set_attr;
    int i;
    XIMStyle *style;
    static char buf[128];
    KeySym keysym = 0;
    Status status;
    XWMHints wm_hints;
    XClassHint class_hints;
    XIMStyle input_style = 0;
    char **font_name_list;
    char *def_string;
    XFontStruct **font_struct_list;
    char **font_encoding_list;
    int nb_font;
    int len = 0;
    int no_xim = 0;
    char **missing_charset_list_return;
    int missing_charset_count_return;
    char *def_string_return;

    if (!setlocale(LC_ALL, ""))
        puts("locale not supported by C library, locale unchanged");

    if (!XSetLocaleModifiers(""))
        puts("X locale modifiers not supported, using default");

    dpy = XOpenDisplay(0);
    scr = DefaultScreen(dpy);
    root = RootWindow(dpy, scr);
    set_attr.event_mask = KeyPressMask|FocusChangeMask;
    set_attr.background_pixel = WhitePixel(dpy, DefaultScreen(dpy));
    set_attr.border_pixel = BlackPixel(dpy, DefaultScreen(dpy));
    w = XCreateWindow(dpy, root, 10,10,200,100,0,
                      DefaultDepth(dpy, DefaultScreen(dpy)),
                      InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)),
                      CWEventMask | CWBackPixel | CWBorderPixel, &set_attr);

    class_hints.res_name = "test";
    class_hints.res_class = "Test";
    wm_hints.input = True;
    wm_hints.flags = InputHint;

    XmbSetWMProperties(dpy, w, "test", "test", NULL, 0,
                       NULL, &wm_hints, &class_hints);

    XMapWindow(dpy, w);
    xim_im = XOpenIM(dpy, NULL, "test", "Test");
    XGetIMValues(xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL);
    for (i = 0, style = xim_styles->supported_styles;
            i < xim_styles->count_styles; i++, style++) {
        if (*style == (XIMStatusNone|XIMPreeditNone)) {
            printf("this is not a XIM server !!!\n");
            no_xim = 1;
        }
        printf("input style : 0x%X\n", *style);
    }
    XFree(xim_styles);

    xim_ic = XCreateIC(xim_im,
                       XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
                       XNClientWindow, w,
                       XNFocusWindow, w,
                       NULL);
    XSetICFocus(xim_ic);

    /***************************************************************
     *  I don't recommend to use a font base name list similar
     *  to the following one in a real application ;-)
     ***************************************************************/
    fontset = XCreateFontSet(dpy,
                             "-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */
                             "-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-6,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-8,"
                             "-*-symbol-*-*-*-*-*-*-*-*-*-*-adobe-fontspecific,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-2,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0208.1983-0,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0212.1990-0,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-big5-0,"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0201.1976-0,"
                             "-*-unifont-*-*-*-*-*-*-*-*-*-*-iso10646-1[0x300 0x400_0x500],"
                             "-*-*-*-*-*-*-*-*-*-*-*-*-*-*",
                             &missing_charset_list_return,
                             &missing_charset_count_return,
                             &def_string_return);
    mask = (GCForeground | GCBackground);
    xgcv.foreground = BlackPixel(dpy, DefaultScreen(dpy));
    xgcv.background = WhitePixel(dpy, DefaultScreen(dpy));

    gc = XCreateGC(dpy, w, mask, &xgcv);

    /***************************************************************/
    while (1) {
        int filtered;
        static XEvent xevent;
        static XVaNestedList list1 = 0;
        int r;

        XNextEvent(dpy, &xevent);
        if (xevent.type == KeyPress) {
            XKeyEvent *e = (XKeyEvent*) &xevent;
            printf ("0x%X %d\n", e->state, e->keycode);
        }
        filtered = XFilterEvent(&xevent, w);
        if (xevent.type == FocusOut) XUnsetICFocus(xim_ic);
        if (xevent.type == FocusIn) XSetICFocus(xim_ic);

        if (xevent.type == KeyPress && !filtered) {
            len = Xutf8LookupString(xim_ic, &xevent.xkey, buf, 127, &keysym, &status);
            Xutf8DrawImageString(dpy, w, fontset, gc, x, y, buf, len);
            Xutf8DrawString(dpy, w, fontset, gc, 0, 20, jp_txt, strlen(jp_txt));
            Xutf8DrawString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt));
            buf[len] = 0;
            printf("'%s' %d\n", buf, keysym);
            buf[0] = 0;
            XCloseIM(xim_im);
        }
        if (filtered) {
            printf("Dead key\n");
        }
    }
    XFreeFontSet(dpy, fontset);
    return 0;
}
Exemple #4
0
static void winopen(void)
{
	XWMHints *wmhints;
	XClassHint *classhint;

	xdpy = XOpenDisplay(NULL);
	if (!xdpy)
		winerror(&gapp, fz_throw("cannot open display"));

	XA_TARGETS = XInternAtom(xdpy, "TARGETS", False);
	XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False);
	XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False);
	WM_DELETE_WINDOW = XInternAtom(xdpy, "WM_DELETE_WINDOW", False);

	xscr = DefaultScreen(xdpy);

	ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr));

	xcarrow = XCreateFontCursor(xdpy, XC_left_ptr);
	xchand = XCreateFontCursor(xdpy, XC_hand2);
	xcwait = XCreateFontCursor(xdpy, XC_watch);

	xbgcolor.red = 0x7000;
	xbgcolor.green = 0x7000;
	xbgcolor.blue = 0x7000;

	xshcolor.red = 0x4000;
	xshcolor.green = 0x4000;
	xshcolor.blue = 0x4000;

	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor);
	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor);

	xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy),
		10, 10, 200, 100, 1,
		ximage_get_depth(),
		InputOutput,
		ximage_get_visual(),
		0,
		NULL);
	if (xwin == None)
		winerror(&gapp, fz_throw("cannot create window"));

	XSetWindowColormap(xdpy, xwin, ximage_get_colormap());
	XSelectInput(xdpy, xwin,
		StructureNotifyMask | ExposureMask | KeyPressMask |
		PointerMotionMask | ButtonPressMask | ButtonReleaseMask);

	mapped = 0;

	xgc = XCreateGC(xdpy, xwin, 0, NULL);

	XDefineCursor(xdpy, xwin, xcarrow);

	wmhints = XAllocWMHints();
	if (wmhints)
	{
		wmhints->flags = IconPixmapHint | IconMaskHint;
		xicon = XCreateBitmapFromData(xdpy, xwin,
			(char*)mupdf_icon_bitmap_16_bits,
			mupdf_icon_bitmap_16_width,
			mupdf_icon_bitmap_16_height);
		xmask = XCreateBitmapFromData(xdpy, xwin,
			(char*)mupdf_icon_bitmap_16_mask_bits,
			mupdf_icon_bitmap_16_mask_width,
			mupdf_icon_bitmap_16_mask_height);
		if (xicon && xmask)
		{
			wmhints->icon_pixmap = xicon;
			wmhints->icon_mask = xmask;
			XSetWMHints(xdpy, xwin, wmhints);
		}
		XFree(wmhints);
	}

	classhint = XAllocClassHint();
	if (classhint)
	{
		classhint->res_name = "mupdf";
		classhint->res_class = "MuPDF";
		XSetClassHint(xdpy, xwin, classhint);
		XFree(classhint);
	}

	XSetWMProtocols(xdpy, xwin, &WM_DELETE_WINDOW, 1);

	x11fd = ConnectionNumber(xdpy);
}
Exemple #5
0
int x11_shadow_xshm_init(x11ShadowSubsystem* subsystem)
{
	Bool pixmaps;
	int major, minor;
	XGCValues values;

	if (!XShmQueryExtension(subsystem->display))
		return -1;

	if (!XShmQueryVersion(subsystem->display, &major, &minor, &pixmaps))
		return -1;

	if (!pixmaps)
		return -1;

	subsystem->fb_shm_info.shmid = -1;
	subsystem->fb_shm_info.shmaddr = (char*) -1;
	subsystem->fb_shm_info.readOnly = False;

	subsystem->fb_image = XShmCreateImage(subsystem->display, subsystem->visual, subsystem->depth,
			ZPixmap, NULL, &(subsystem->fb_shm_info), subsystem->width, subsystem->height);

	if (!subsystem->fb_image)
	{
		WLog_ERR(TAG, "XShmCreateImage failed");
		return -1;
	}

	subsystem->fb_shm_info.shmid = shmget(IPC_PRIVATE,
			subsystem->fb_image->bytes_per_line * subsystem->fb_image->height, IPC_CREAT | 0600);

	if (subsystem->fb_shm_info.shmid == -1)
	{
		WLog_ERR(TAG, "shmget failed");
		return -1;
	}

	subsystem->fb_shm_info.shmaddr = shmat(subsystem->fb_shm_info.shmid, 0, 0);
	subsystem->fb_image->data = subsystem->fb_shm_info.shmaddr;

	if (subsystem->fb_shm_info.shmaddr == ((char*) -1))
	{
		WLog_ERR(TAG, "shmat failed");
		return -1;
	}

	if (!XShmAttach(subsystem->display, &(subsystem->fb_shm_info)))
		return -1;

	XSync(subsystem->display, False);

	shmctl(subsystem->fb_shm_info.shmid, IPC_RMID, 0);

	subsystem->fb_pixmap = XShmCreatePixmap(subsystem->display,
			subsystem->root_window, subsystem->fb_image->data, &(subsystem->fb_shm_info),
			subsystem->fb_image->width, subsystem->fb_image->height, subsystem->fb_image->depth);

	XSync(subsystem->display, False);

	if (!subsystem->fb_pixmap)
		return -1;

	values.subwindow_mode = IncludeInferiors;
	values.graphics_exposures = False;

	subsystem->xshm_gc = XCreateGC(subsystem->display, subsystem->root_window,
			GCSubwindowMode | GCGraphicsExposures, &values);

	XSetFunction(subsystem->display, subsystem->xshm_gc, GXcopy);
	XSync(subsystem->display, False);

	return 1;
}
Exemple #6
0
ENTRYPOINT void
init_strange(ModeInfo * mi)
{
	Display    *display = MI_DISPLAY(mi);
	Window      window = MI_WINDOW(mi);
#ifndef NO_DBUF
	GC          gc = MI_GC(mi);
#endif
	ATTRACTOR  *Attractor;

#ifdef POINTS_HISTORY
	startedClearing=0;
	oldPointsIndex=0;
#endif

	if (Root == NULL) {
		if ((Root = (ATTRACTOR *) calloc(MI_NUM_SCREENS(mi),
				sizeof (ATTRACTOR))) == NULL)
			return;
	}
	Attractor = &Root[MI_SCREEN(mi)];

	if (Attractor->Fold == NULL) {
		int         i;

		if ((Attractor->Fold = (PRM *) calloc(UNIT2 + 1,
				sizeof (PRM))) == NULL) {
			free_strange(display, Attractor);
			return;
		}
		for (i = 0; i <= UNIT2; ++i) {
			DBL         x;

			/* x = ( DBL )(i)/UNIT2; */
			/* x = sin( M_PI/2.0*x ); */
			/* x = sqrt( x ); */
			/* x = x*x; */
			/* x = x*(1.0-x)*4.0; */
			x = (DBL) (i) / UNIT;
			x = sin(x);
			Attractor->Fold[i] = DBL_To_PRM(x);
		}
	}

	Attractor->Max_Pt = points;

	if (Attractor->Buffer1 == NULL)
		if ((Attractor->Buffer1 = (XPoint *) calloc(Attractor->Max_Pt,
				sizeof (XPoint))) == NULL) {
			free_strange(display, Attractor);
			return;
		}
	if (Attractor->Buffer2 == NULL)
		if ((Attractor->Buffer2 = (XPoint *) calloc(Attractor->Max_Pt,
				sizeof (XPoint))) == NULL) {
			free_strange(display, Attractor);
			return;
		}

	Attractor->Width = MI_WIDTH(mi);
	Attractor->Height = MI_HEIGHT(mi);
	Attractor->Cur_Pt = 0;
	Attractor->Count = 0;
	Attractor->Col = NRAND(MI_NPIXELS(mi));
	Attractor->Speed = 4;

	Attractor->Iterate = Funcs[NRAND(2)];
	Random_Prm(Attractor->Prm1);
	Random_Prm(Attractor->Prm2);
#ifndef NO_DBUF
	if (Attractor->dbuf != None)
		XFreePixmap(display, Attractor->dbuf);
#ifdef useAccumulator
#define colorDepth ( useAccumulator ? MI_DEPTH(mi) : 1 )
#else
#define colorDepth 1
#endif
	Attractor->dbuf = XCreatePixmap(display, window,
	     Attractor->Width, Attractor->Height, colorDepth);
	/* Allocation checked */
	if (Attractor->dbuf != None) {
		XGCValues   gcv;

		gcv.foreground = 0;
		gcv.background = 0;
#ifndef HAVE_COCOA
		gcv.graphics_exposures = False;
#endif /* HAVE_COCOA */
		gcv.function = GXcopy;

		if (Attractor->dbuf_gc != None)
			XFreeGC(display, Attractor->dbuf_gc);

		if ((Attractor->dbuf_gc = XCreateGC(display, Attractor->dbuf,
#ifndef HAVE_COCOA
				GCGraphicsExposures |
#endif /* HAVE_COCOA */
                               GCFunction | GCForeground | GCBackground,
				&gcv)) == None) {
			XFreePixmap(display, Attractor->dbuf);
			Attractor->dbuf = None;
		} else {
			XFillRectangle(display, Attractor->dbuf, Attractor->dbuf_gc,
				0, 0, Attractor->Width, Attractor->Height);
			XSetBackground(display, gc, MI_BLACK_PIXEL(mi));
			XSetFunction(display, gc, GXcopy);
		}
	}
#endif


#ifdef useAccumulator
	#define A Attractor
	if (useAccumulator) {
		XWindowAttributes xgwa;
		int i,j;
		XGetWindowAttributes (display, window, &xgwa);
		/* cmap = xgwa.colormap; */
		/* cmap = XCreateColormap(display, window, MI_VISUAL(mi), AllocAll); */
		Attractor->accMap = (int**)calloc(Attractor->Width,sizeof(int*));
		for (i=0;i<Attractor->Width;i++) {
			Attractor->accMap[i] = (int*)calloc(Attractor->Height,sizeof(int));
			for (j=0;j<Attractor->Height;j++) {
				Attractor->accMap[i][j] = 0;
			}
		}
#ifdef POINTS_HISTORY
		numOldPoints = A->Max_Pt * MERGE_FRAMES;
		oldPointsX = (int*)calloc(numOldPoints,sizeof(int));
		oldPointsY = (int*)calloc(numOldPoints,sizeof(int));
#endif
		cols = (XColor*)calloc(NUM_COLS,sizeof(XColor));
		for (i=0;i<NUM_COLS;i++) {
			float li;
			#define MINBLUE 1
			#define FULLBLUE 128
			li = MINBLUE + (255.0-MINBLUE) * log(1.0 + ACC_GAMMA*(float)i/NUM_COLS) / log(1.0 + ACC_GAMMA);
			if (li<FULLBLUE) {
				cols[i].red = 0;
				cols[i].green = 0;
				cols[i].blue = 65536*li/FULLBLUE;
			} else {
				cols[i].red = 65536*(li-FULLBLUE)/(256-FULLBLUE);
				cols[i].green = 65536*(li-FULLBLUE)/(256-FULLBLUE);
				cols[i].blue = 65535;
			}
			XAllocColor (display, xgwa.colormap, &cols[i]);
			/*
			if (!XAllocColor(MI_DISPLAY(mi), cmap, &cols[i])) {
			if (!XAllocColor(display, cmap, &cols[i])) {
				cols[i].pixel = WhitePixel (display, DefaultScreen (display));
				cols[i].red = cols[i].green = cols[i].blue = 0xFFFF;
			}
			*/
		}
		/*
		XSetWindowColormap(display, window, cmap);
		(void) XSetWMColormapWindows(display, window, &window, 1);
		XInstallColormap(display, cmap);
		XStoreColors(display, cmap, cols, 256);
		*/
	}
	#undef A
#endif
	MI_CLEARWINDOW(mi);

	/* Do not want any exposure events from XCopyPlane */
	XSetGraphicsExposures(display, MI_GC(mi), False);
}
Exemple #7
0
stk_widget *stk_text_new(stk_widget *parent_win, int x, int y, uint w, uint h,
                                                        char *label, int type)
{
    stk_widget *new_txt  = (stk_widget*) malloc(sizeof(stk_widget));
    stk_text *txt = (stk_text*) malloc(sizeof(stk_text));
    int screen;

    XGCValues gcval;
    long fg, bg;
    XSetWindowAttributes setwinattr;
    
    memset(new_txt, 0, sizeof(stk_widget));
    memset(txt->text, 0, sizeof(stk_text));
    
    new_txt->dsp = display;
    new_txt->fontname = STK_FONT_SIZE_7x13;

    screen = DefaultScreen(new_txt->dsp);
    fg = BlackPixel(new_txt->dsp, screen);
    bg = WhitePixel(new_txt->dsp, screen);
    
    gcval.foreground = fg;
    gcval.background = bg;
    new_txt->gc2 = XCreateGC(new_txt->dsp, parent_win->win, GCForeground |
                                                  GCBackground, &gcval);

    setwinattr.backing_store = Always;

    new_txt->font_info = XLoadQueryFont(new_txt->dsp, new_txt->fontname);

    if(new_txt->fontname != NULL)
        XSetFont(display, new_txt->gc2, new_txt->font_info->fid);
    else
      perror("XLoadQueryFont");

    if(new_txt->dsp)
    {
        new_txt->win = XCreateSimpleWindow(new_txt->dsp, parent_win->win, x, y, w,
                                                                  h, 1, fg, bg);

        if(type == STK_TEXT_INPUT)
        {
            new_txt->mask =  ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
                             EnterWindowMask | LeaveWindowMask |
                             FocusChangeMask | StructureNotifyMask | PropertyChangeMask | VisibilityChangeMask;
        }
        else
        {
            new_txt->mask =  ExposureMask| EnterWindowMask | LeaveWindowMask |
                             FocusChangeMask | StructureNotifyMask | PropertyChangeMask | VisibilityChangeMask;       
        }

        XChangeWindowAttributes(new_txt->dsp, new_txt->win, CWBackingStore,
                                                              &setwinattr);
        
        XSelectInput(new_txt->dsp, new_txt->win, new_txt->mask);
        XMapWindow(new_txt->dsp, new_txt->win);


        new_txt->x = x;
        new_txt->y = y;
        new_txt->w = w;
        new_txt->h = h;
        new_txt->handler = &stk_text_handle;
        new_txt->ext_struct = (void*)txt;

        if(label)
            strcpy(txt->text, label);


        stk_widget_insert((void*)new_txt); 

        return new_txt;
    }
    else
        return NULL;
}
Exemple #8
0
void pxWindowNative::runEventLoop()
{
    displayRef d;
        
    exitFlag = false;

    double lastAnimationTime = pxMilliseconds();
    while(!exitFlag)
    {
	
        XEvent e;
        if (XPending(d.getDisplay()))
        {
	    XNextEvent(d.getDisplay(), &e);
	    XAnyEvent* ae = (XAnyEvent*)&e;
	    
	    pxWindowNative* w = getPXWindowFromX11Window(ae->window);
	    if (w)
	    {
		switch(ae->type)
		{
		case Expose:
		{
		    if(e.xexpose.count<1)
		    {
		    
			GC gc=XCreateGC(ae->display, ae->window, 0, NULL);
			
			pxSurfaceNativeDesc d;
			d.display = ae->display;
			d.drawable = ae->window;
			d.gc = gc;
			
			w->onDraw(&d);
			
			XFreeGC(ae->display, gc);
		    }
		}
		break;
		
		case ButtonPress:
		{
		    
		    XGrabPointer(ae->display, ae->window, true, 
				 ButtonPressMask|ButtonReleaseMask|
				 PointerMotionMask,
				 GrabModeAsync, GrabModeAsync, None, None, 
				 CurrentTime);
		    
		    XButtonEvent *be = (XButtonEvent*)ae;
		    unsigned long flags;
		    switch(be->button)
		    {
		    case Button2: flags = PX_MIDDLEBUTTON;
			break;
		    case Button3: flags = PX_RIGHTBUTTON;
			break;
		    default: flags = PX_LEFTBUTTON;
			break;
		    }
		    flags |= (be->state & ShiftMask)?PX_MOD_SHIFT:0;
		    flags |= (be->state & ControlMask)?PX_MOD_CONTROL:0;
		    flags |= (be->state & Mod1Mask)?PX_MOD_ALT:0;
		    
		    w->onMouseDown(be->x, be->y, flags);
		}
		break;

		case ButtonRelease:
		{
		    XUngrabPointer(ae->display, CurrentTime);
		    
		    XButtonEvent *be = (XButtonEvent*)ae;
		    unsigned long flags;
		    switch(be->button)
		    {
		    case Button2: flags = PX_MIDDLEBUTTON;
			break;
		    case Button3: flags = PX_RIGHTBUTTON;
			break;
		    default: flags = PX_LEFTBUTTON;
			break;
		    }
		    flags |= (be->state & ShiftMask)?PX_MOD_SHIFT:0;
		    flags |= (be->state & ControlMask)?PX_MOD_CONTROL:0;
		    flags |= (be->state & Mod1Mask)?PX_MOD_ALT:0;
		    
		    w->onMouseUp(be->x, be->y, flags);
		}
		break;

		case KeyPress:
		{		
		    XKeyEvent* ke = (XKeyEvent*)ae;
		    KeySym keySym = ::XKeycodeToKeysym(ae->display, 
						       e.xkey.keycode, 
						       0);
		    if (keySym >= 'a' && keySym <= 'z')
			keySym = (keySym-'a')+'A';
		    else if (keySym == XK_Shift_R)
			keySym = XK_Shift_L;
		    else if (keySym == XK_Control_R)
			keySym = XK_Control_L;
		    else if (keySym == XK_Alt_R)
			keySym = XK_Alt_L;
		    
		    unsigned long flags = 0;
		    flags |= (ke->state & ShiftMask)?PX_MOD_SHIFT:0;
		    flags |= (ke->state & ControlMask)?PX_MOD_CONTROL:0;
		    flags |= (ke->state & Mod1Mask)?PX_MOD_ALT:0;
		    w->onKeyDown(keySym, flags);
		}
		break;

		case MotionNotify:
		{
		    XMotionEvent *me = (XMotionEvent*)ae;
		    w->onMouseMove(me->x, me->y);
		}
		break;

		case KeyRelease:
		{
		    XKeyEvent* ke = (XKeyEvent*)ae;
		    KeySym keySym = ::XKeycodeToKeysym(ae->display, 
						       e.xkey.keycode, 
						       0);
		    
		    if (keySym >= 'a' && keySym <= 'z')
			keySym = (keySym-'a')+'A';
		    else if (keySym == XK_Shift_R)
			keySym = XK_Shift_L;
		    else if (keySym == XK_Control_R)
			keySym = XK_Control_L;
		    else if (keySym == XK_Alt_R)
			keySym = XK_Alt_L;
		    
		    unsigned long flags = 0;
		    flags |= (ke->state & ShiftMask)?PX_MOD_SHIFT:0;
		    flags |= (ke->state & ControlMask)?PX_MOD_CONTROL:0;
		    flags |= (ke->state & Mod1Mask)?PX_MOD_ALT:0;
		    w->onKeyUp(keySym, flags);
		}
		break;

		case ConfigureNotify:
		{
		    // We defer the onSize message after some
		    // time
		    if (w->lastWidth != e.xconfigure.width ||
			w->lastHeight != e.xconfigure.height)
		    {
			w->resizeFlag = true;
			w->lastWidth = e.xconfigure.width;
			w->lastHeight = e.xconfigure.height;
		    }
		}
		break;

		case ClientMessage:
		{
		    
		    if((e.xclient.format == 32) &&
		       (e.xclient.data.l[0] == int(w->closeatom)))
		    {
			w->onCloseRequest();
		    }
		}
		break;

		case DestroyNotify:
		{
		    w->onClose();
		    unregisterWindow(ae->window);
		}
		break;
		case LeaveNotify:
		  {
		    w->onMouseLeave();
		  }
		  break;
		}
	    }
        }
        else
        {
	    // The animation/resize handling under x11 needs some serious
	    // rework
	    
            double currentAnimationTime = pxMilliseconds();
	    
	    vector<windowDesc>::iterator i;
	    for (i = mWindowMap.begin(); i < mWindowMap.end(); i++)
	    {
		pxWindowNative* w = (*i).p;

		double animationDelta = currentAnimationTime-lastAnimationTime;
		if (w->resizeFlag)
		{
		    w->resizeFlag = false;
		    w->onSize((*i).p->lastWidth, (*i).p->lastHeight);
		    w->invalidateRectInternal(NULL);
		}
		
		if (w->mTimerFPS)
		{
		    animationDelta = currentAnimationTime-
			w->mLastAnimationTime;

		    if (animationDelta > (1000/w->mTimerFPS))
		    {
			w->onAnimationTimerInternal();
			w->mLastAnimationTime = currentAnimationTime;
		    }
		}
	    }

	    pxSleepMS(10); // Breath
        }
    }
}
Exemple #9
0
Fichier : menuq.c Projet : calint/a
int main(){
//	puts(APP);
	Display*dpy=XOpenDisplay(NULL);
	if(!dpy){
		//fprintf(stderr, "!!! could not open display\n");
		return 1;
	}
	const int scr=DefaultScreen(dpy);
	const int screen_width=DisplayWidth(dpy,scr);
	const int win_height=23;
	const Window win=XCreateSimpleWindow(dpy,RootWindow(dpy,scr),-BORDER_WIDTH,0,screen_width,win_height,0,BlackPixel(dpy,scr),BlackPixel(dpy,scr));
//	XSelectInput(dpy,win,ExposureMask|KeyPressMask);
	XSelectInput(dpy,win,KeyPressMask);
	XMapWindow(dpy,win);
	const GC gc=XCreateGC(dpy,win,0,NULL);
	const int x_init=(screen_width>>1)-(screen_width>>2)+(screen_width>>3);
	int x=x_init;
	const int y_init=(win_height>>1)+(win_height>>2);
	int y=y_init;
	const char cursor_str[1]="_";
	XSetForeground(dpy,gc,WhitePixel(dpy,scr));
	XDrawString(dpy,win,gc,x,y,cursor_str,1);
	char buf[32];
	int bufi=0;
	char*bufp=buf;
	*bufp=0;
	const int char_width=7;
	const int char_y_wiggle=3;
	const int char_y_wiggle_up=-1;
	const int options_start_x=640;
	int go=1;
	XEvent e;
	while(go){
		XNextEvent(dpy,&e);
		switch(e.type){
		default:
			break;
		case Expose:
//			XSetForeground(dpy,gc,BlackPixel(dpy,scr));
//			XFillRectangle(dpy,win,gc,0,0,screen_width,win_height);
//			XSetForeground(dpy,gc,WhitePixel(dpy,scr));
//			const int buflen=strlen(buf);
//			printf("%d   [%s]\n",buflen,buf);
//			XDrawString(dpy,win,gc,x_init,y_init,buf,buflen);
//			x=x_init+char_width*buflen;
//			XDrawString(dpy,win,gc,x,y,cursor_str,1);
			break;
		case DestroyNotify:
			go=0;
			break;
		case KeyPress:{
			int keycode=0;
			//printf("KeyPress %d %d\n",e.xbutton.button,e.xbutton.state);
			keycode=e.xkey.keycode;
			if(keycode==9){//esc
				go=0;
				bufp=buf;
				*bufp=0;
				break;
			}
			keycode=e.xkey.keycode;
			if(keycode==36){//return
				go=0;
				*bufp=0;
				break;
			}
			if(keycode==22){//backspace
				if(bufi==0)
					break;
				x-=char_width;
				XSetForeground(dpy,gc,BlackPixel(dpy,scr));
				XFillRectangle(dpy,win,gc,x,0,char_width<<1,win_height);
				XSetForeground(dpy,gc,WhitePixel(dpy,scr));
				XDrawString(dpy,win,gc,x,y,"_",1);
				bufi--;
				bufp--;
				*bufp=0;
			}else{
				// clear cursor
				XSetForeground(dpy,gc,BlackPixel(dpy,scr));
				XFillRectangle(dpy,win,gc,x,0,char_width,win_height);
				XSetForeground(dpy,gc,WhitePixel(dpy,scr));
				// get printable character
				char buffer[4];
				KeySym keysym;
				XLookupString(&e.xkey,buffer,sizeof buffer,&keysym,NULL);
				if(!buffer[0])// printable character ?
					break;
				XDrawString(dpy,win,gc,x,y,buffer,1);
				x+=char_width;
				*bufp++=buffer[0];
				bufi++;
				if((bufi+1)>=(int)sizeof buf)// buffer full ?
					go=0;
				y+=char_y_wiggle_up+rand()%char_y_wiggle;
				XDrawString(dpy,win,gc,x,y,cursor_str,1);
			}
			XFillRectangle(dpy,win,gc,options_start_x,0,screen_width-options_start_x-1,win_height-1);
			break;
			}
		}
	}
	XFreeGC(dpy,gc);
	XCloseDisplay(dpy);
	if(!*buf)return 0;//empty string
	strcat(buf,"&");
	return system(buf);
}
Exemple #10
0
int xf_AppWindowInit(xfContext* xfc, xfAppWindow* appWindow)
{
	XGCValues gcv;
	int input_mask;
	XWMHints* InputModeHint;
	XClassHint* class_hints;
	xf_FixWindowCoordinates(xfc, &appWindow->x, &appWindow->y, &appWindow->width,
	                        &appWindow->height);
	appWindow->decorations = FALSE;
	appWindow->fullscreen = FALSE;
	appWindow->local_move.state = LMS_NOT_ACTIVE;
	appWindow->is_mapped = FALSE;
	appWindow->is_transient = FALSE;
	appWindow->rail_state = 0;
	appWindow->rail_ignore_configure = FALSE;
	appWindow->handle = XCreateWindow(xfc->display, RootWindowOfScreen(xfc->screen),
	                                  appWindow->x, appWindow->y, appWindow->width, appWindow->height,
	                                  0, xfc->depth, InputOutput, xfc->visual, 0, &xfc->attribs);

	if (!appWindow->handle)
		return -1;

	ZeroMemory(&gcv, sizeof(gcv));
	appWindow->gc = XCreateGC(xfc->display, appWindow->handle, GCGraphicsExposures,
	                          &gcv);
	class_hints = XAllocClassHint();

	if (class_hints)
	{
		char* class = NULL;

		if (xfc->context.settings->WmClass)
		{
			class_hints->res_class = xfc->context.settings->WmClass;
		}
		else
		{
			class = malloc(sizeof("RAIL:00000000"));
			sprintf_s(class, sizeof("RAIL:00000000"), "RAIL:%08"PRIX32"", appWindow->windowId);
			class_hints->res_class = class;
		}

		class_hints->res_name = "RAIL";
		XSetClassHint(xfc->display, appWindow->handle, class_hints);
		XFree(class_hints);
		free(class);
	}

	/* Set the input mode hint for the WM */
	InputModeHint = XAllocWMHints();
	InputModeHint->flags = (1L << 0);
	InputModeHint->input = True;
	XSetWMHints(xfc->display, appWindow->handle, InputModeHint);
	XFree(InputModeHint);
	XSetWMProtocols(xfc->display, appWindow->handle, &(xfc->WM_DELETE_WINDOW), 1);
	input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
	             ButtonReleaseMask | EnterWindowMask | LeaveWindowMask |
	             PointerMotionMask | Button1MotionMask | Button2MotionMask |
	             Button3MotionMask | Button4MotionMask | Button5MotionMask |
	             ButtonMotionMask | KeymapStateMask | ExposureMask |
	             VisibilityChangeMask | StructureNotifyMask | SubstructureNotifyMask |
	             SubstructureRedirectMask | FocusChangeMask | PropertyChangeMask |
	             ColormapChangeMask | OwnerGrabButtonMask;
	XSelectInput(xfc->display, appWindow->handle, input_mask);
	xf_SetWindowDecorations(xfc, appWindow->handle, appWindow->decorations);
	xf_SetWindowStyle(xfc, appWindow, appWindow->dwStyle, appWindow->dwExStyle);
	xf_SetWindowPID(xfc, appWindow->handle, 0);
	xf_ShowWindow(xfc, appWindow, WINDOW_SHOW);
	XClearWindow(xfc->display, appWindow->handle);
	XMapWindow(xfc->display, appWindow->handle);
	/* Move doesn't seem to work until window is mapped. */
	xf_MoveWindow(xfc, appWindow, appWindow->x, appWindow->y, appWindow->width,
	              appWindow->height);
	xf_SetWindowText(xfc, appWindow, appWindow->title);
	return 1;
}
Exemple #11
0
/**
**	X11 initialize.
*/
global void CloneInitDisplay(void)
{
    int i;
    Window window;
    XGCValues gcvalue;
    XSizeHints hints;
    XWMHints wmhints;
    XClassHint classhint;
    XSetWindowAttributes attributes;
    int shm_major,shm_minor;
    Bool pixmap_support;
    XShmSegmentInfo shminfo;
    XVisualInfo xvi;
    XPixmapFormatValues *xpfv;

    if( !(TheDisplay=XOpenDisplay(NULL)) ) {
	fprintf(stderr,"Cannot connect to X-Server.\n");
	exit(-1);
    }

    TheScreen=DefaultScreen(TheDisplay);

    //	I need shared memory pixmap extension.

    if( !XShmQueryVersion(TheDisplay,&shm_major,&shm_minor,&pixmap_support) ) {
	fprintf(stderr,"SHM-Extensions required.\n");
	exit(-1);
    }
    if( !pixmap_support ) {
	fprintf(stderr,"SHM-Extensions with pixmap supported required.\n");
	exit(-1);
    }

    //  Look for a nice visual
#ifdef USE_HICOLOR
    if(XMatchVisualInfo(TheDisplay, TheScreen, 16, TrueColor, &xvi))
	goto foundvisual;
    if(XMatchVisualInfo(TheDisplay, TheScreen, 15, TrueColor, &xvi))
	goto foundvisual;
    fprintf(stderr,"Sorry, this version is for 15/16-bit displays only.\n");
#else
    if(XMatchVisualInfo(TheDisplay, TheScreen, 8, PseudoColor, &xvi))
	goto foundvisual;
    fprintf(stderr,"Sorry, this version is for 8-bit displays only.\n");
#endif
#if 0
    if(XMatchVisualInfo(TheDisplay, TheScreen, 24, TrueColor, &xvi))
	goto foundvisual;
#endif
    exit(-1);
foundvisual:

    xpfv=XListPixmapFormats(TheDisplay, &i);
    for(i--;i>=0;i--)  if(xpfv[i].depth==xvi.depth) break;
    if(i<0)  {
	fprintf(stderr,"No Pixmap format for visual depth?\n");
	exit(-1);
    }
    VideoDepth=xvi.depth;

    VideoWidth = 640;
    VideoHeight = 480;
    MapWidth = 14;			// FIXME: Not the correct way
    MapHeight = 14;
    shminfo.shmid=shmget(IPC_PRIVATE,
	(VideoWidth*xpfv[i].bits_per_pixel+xpfv[i].scanline_pad-1) /
	xpfv[i].scanline_pad * xpfv[i].scanline_pad * VideoHeight / 8,
	IPC_CREAT|0777);

    XFree(xpfv);

    if( !shminfo.shmid==-1 ) {
	fprintf(stderr,"shmget failed.\n");
	exit(-1);
    }
    VideoMemory=(VMemType*)shminfo.shmaddr=shmat(shminfo.shmid,0,0);
    if( shminfo.shmaddr==(void*)-1 ) {
	shmctl(shminfo.shmid,IPC_RMID,0);
	fprintf(stderr,"shmat failed.\n");
	exit(-1);
    }
    shminfo.readOnly=False;

    if( !XShmAttach(TheDisplay,&shminfo) ) {
	shmctl(shminfo.shmid,IPC_RMID,0);
	fprintf(stderr,"XShmAttach failed.\n");
	exit(-1);
    }
    // Mark segment as deleted as soon as both clone and the X server have
    // attached to it.  The POSIX spec says that a segment marked as deleted
    // can no longer have addition processes attach to it, but Linux will let
    // them anyway.
    shmctl(shminfo.shmid,IPC_RMID,0);

    TheMainDrawable=attributes.background_pixmap=
	    XShmCreatePixmap(TheDisplay,DefaultRootWindow(TheDisplay)
		,shminfo.shmaddr,&shminfo
		,VideoWidth,VideoHeight
		,xvi.depth);
    attributes.cursor = XCreateFontCursor(TheDisplay,XC_tcross-1);
    attributes.backing_store = NotUseful;
    attributes.save_under = False;
    attributes.event_mask = KeyPressMask|KeyReleaseMask|/*ExposureMask|*/
	FocusChangeMask|ButtonPressMask|PointerMotionMask|ButtonReleaseMask;
    i = CWBackPixmap|CWBackingStore|CWSaveUnder|CWEventMask|CWCursor;

    if(xvi.class==PseudoColor)  {
	i|=CWColormap;
	attributes.colormap =
	    XCreateColormap( TheDisplay, xvi.screen, xvi.visual, AllocNone);
	// FIXME:  Really should fill in the colormap right now
    }
    window=XCreateWindow(TheDisplay,DefaultRootWindow(TheDisplay)
	    ,0,0,VideoWidth,VideoHeight,3
	    ,xvi.depth,InputOutput,xvi.visual ,i,&attributes);
    TheMainWindow=window;

    gcvalue.graphics_exposures=False;
    GcLine=XCreateGC(TheDisplay,window,GCGraphicsExposures,&gcvalue);

    //
    //	Clear initial window.
    //
    XSetForeground(TheDisplay,GcLine,BlackPixel(TheDisplay,TheScreen));
    XFillRectangle(TheDisplay,TheMainDrawable,GcLine,0,0
	    ,VideoWidth,VideoHeight);

    WmDeleteWindowAtom=XInternAtom(TheDisplay,"WM_DELETE_WINDOW",False);

    //
    //	Set some usefull min/max sizes as well as a 1.3 aspect
    //
#if 0
    if( geometry ) {
	hints.flags=0;
	f=XParseGeometry(geometry
		,&hints.x,&hints.y,&hints.width,&hints.height);

	if( f&XValue ) {
	    if( f&XNegative ) {
		hints.x+=DisplayWidth-hints.width;
	    }
	    hints.flags|=USPosition;
	    // FIXME: win gravity
	}
	if( f&YValue ) {
	    if( f&YNegative ) {
		hints.y+=DisplayHeight-hints.height;
	    }
	    hints.flags|=USPosition;
	    // FIXME: win gravity
	}
	if( f&WidthValue ) {
	    hints.flags|=USSize;
	}
	if( f&HeightValue ) {
	    hints.flags|=USSize;
	}
    } else {
#endif
	hints.width=VideoWidth;
	hints.height=VideoHeight;
	hints.flags=PSize;
#if 0
    }
#endif
    hints.min_width=VideoWidth;
    hints.min_height=VideoHeight;
    hints.max_width=VideoWidth;
    hints.max_height=VideoHeight;
    hints.min_aspect.x=4;
    hints.min_aspect.y=3;

    hints.max_aspect.x=4;
    hints.max_aspect.y=3;
    hints.width_inc=4;
    hints.height_inc=3;

    hints.flags|=PMinSize|PMaxSize|PAspect|PResizeInc;

    wmhints.input=True;
    wmhints.initial_state=NormalState;
    wmhints.window_group=window;
    wmhints.flags=InputHint|StateHint|WindowGroupHint;

    classhint.res_name="aleclone";
    classhint.res_class="AleClone";

    XSetStandardProperties(TheDisplay,window
	,"ALE Clone","ALE Clone",None,(char**)0,0,&hints);
    XSetClassHint(TheDisplay,window,&classhint);
    XSetWMHints(TheDisplay,window,&wmhints);

    XSetWMProtocols(TheDisplay,window,&WmDeleteWindowAtom,1);

    XMapWindow(TheDisplay,window);

    //
    //	Input handling.
    //
    XAddConnectionWatch(TheDisplay,MyConnectionWatch,NULL);
}
Exemple #12
0
WMcursor *X11_CreateWMCursor(_THIS,
		Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y)
{
	WMcursor *cursor;
	XGCValues GCvalues;
	GC        GCcursor;
	XImage *data_image, *mask_image;
	Pixmap  data_pixmap, mask_pixmap;
	int       clen, i;
	char     *x_data, *x_mask;
	static XColor black = {  0,  0,  0,  0 };
	static XColor white = { 0xffff, 0xffff, 0xffff, 0xffff };

	/* Allocate the cursor memory */
	cursor = (WMcursor *)SDL_malloc(sizeof(WMcursor));
	if ( cursor == NULL ) {
		SDL_OutOfMemory();
		return(NULL);
	}

	/* Mix the mask and the data */
	clen = (w/8)*h;
	x_data = (char *)SDL_malloc(clen);
	if ( x_data == NULL ) {
		SDL_free(cursor);
		SDL_OutOfMemory();
		return(NULL);
	}
	x_mask = (char *)SDL_malloc(clen);
	if ( x_mask == NULL ) {
		SDL_free(cursor);
		SDL_free(x_data);
		SDL_OutOfMemory();
		return(NULL);
	}
	for ( i=0; i<clen; ++i ) {
		/* The mask is OR'd with the data to turn inverted color
		   pixels black since inverted color cursors aren't supported
		   under X11.
		 */
		x_mask[i] = data[i] | mask[i];
		x_data[i] = data[i];
	}

	/* Prevent the event thread from running while we use the X server */
	SDL_Lock_EventThread();

	/* Create the data image */
	data_image = XCreateImage(SDL_Display, 
			DefaultVisual(SDL_Display, SDL_Screen),
					1, XYBitmap, 0, x_data, w, h, 8, w/8);
	data_image->byte_order = MSBFirst;
	data_image->bitmap_bit_order = MSBFirst;
	data_pixmap = XCreatePixmap(SDL_Display, SDL_Root, w, h, 1);

	/* Create the data mask */
	mask_image = XCreateImage(SDL_Display, 
			DefaultVisual(SDL_Display, SDL_Screen),
					1, XYBitmap, 0, x_mask, w, h, 8, w/8);
	mask_image->byte_order = MSBFirst;
	mask_image->bitmap_bit_order = MSBFirst;
	mask_pixmap = XCreatePixmap(SDL_Display, SDL_Root, w, h, 1);

	/* Create the graphics context */
	GCvalues.function = GXcopy;
	GCvalues.foreground = ~0;
	GCvalues.background =  0;
	GCvalues.plane_mask = AllPlanes;
	GCcursor = XCreateGC(SDL_Display, data_pixmap,
			(GCFunction|GCForeground|GCBackground|GCPlaneMask),
								&GCvalues);

	/* Blit the images to the pixmaps */
	XPutImage(SDL_Display, data_pixmap, GCcursor, data_image,
							0, 0, 0, 0, w, h);
	XPutImage(SDL_Display, mask_pixmap, GCcursor, mask_image,
							0, 0, 0, 0, w, h);
	XFreeGC(SDL_Display, GCcursor);
	/* These free the x_data and x_mask memory pointers */
	XDestroyImage(data_image);
	XDestroyImage(mask_image);

	/* Create the cursor */
	cursor->x_cursor = XCreatePixmapCursor(SDL_Display, data_pixmap,
				mask_pixmap, &black, &white, hot_x, hot_y);
	XFreePixmap(SDL_Display, data_pixmap);
	XFreePixmap(SDL_Display, mask_pixmap);

	/* Release the event thread */
	XSync(SDL_Display, False);
	SDL_Unlock_EventThread();

	return(cursor);
}
Exemple #13
0
static void *
halo_init (Display *dpy, Window window)
{
  struct state *st = (struct state *) calloc (1, sizeof(*st));
  XGCValues gcv;
  XWindowAttributes xgwa;
  char *mode_str = 0;
  st->dpy = dpy;
  st->window = window;
  XGetWindowAttributes (st->dpy, st->window, &xgwa);
  st->cmap = xgwa.colormap;
  st->global_count = get_integer_resource (st->dpy, "count", "Integer");
  if (st->global_count < 0) st->global_count = 0;
  st->global_inc = get_integer_resource (st->dpy, "increment", "Integer");
  if (st->global_inc < 0) st->global_inc = 0;
  st->anim_p = get_boolean_resource (st->dpy, "animate", "Boolean");
  st->delay = get_integer_resource (st->dpy, "delay", "Integer");
  st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer") * 1000000;
  mode_str = get_string_resource (st->dpy, "colorMode", "ColorMode");
  if (! mode_str) cmode = random_mode;
  else if (!strcmp (mode_str, "seuss"))  cmode = seuss_mode;
  else if (!strcmp (mode_str, "ramp"))   cmode = ramp_mode;
  else if (!strcmp (mode_str, "random")) cmode = random_mode;
  else {
    fprintf (stderr,
	     "%s: colorMode must be seuss, ramp, or random, not \"%s\"\n",
	     progname, mode_str);
    exit (1);
  }
  if (mode_str) free (mode_str);

  if (mono_p) cmode = seuss_mode;
  if (cmode == random_mode)
    cmode = ((random()&3) == 1) ? ramp_mode : seuss_mode;

  if (cmode == ramp_mode)
    st->anim_p = False;    /* This combo doesn't work right... */

  st->ncolors = get_integer_resource (st->dpy, "colors", "Colors");
  if (st->ncolors < 2) st->ncolors = 2;
  if (st->ncolors <= 2) mono_p = True;

  if (mono_p)
    st->colors  = 0;
  else
    st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));


  if (mono_p)
    ;
  else if (random() % (cmode == seuss_mode ? 2 : 10))
    make_uniform_colormap (xgwa.screen, xgwa.visual, st->cmap,
                           st->colors, &st->ncolors,
			   True, 0, True);
  else
    make_smooth_colormap (xgwa.screen, xgwa.visual, st->cmap,
                          st->colors, &st->ncolors,
			  True, 0, True);

  if (st->ncolors <= 2) mono_p = True;
  if (mono_p) cmode = seuss_mode;

  if (mono_p)
    {
      st->fg_pixel = get_pixel_resource (st->dpy, st->cmap, "foreground", "Foreground");
      st->bg_pixel = get_pixel_resource (st->dpy, st->cmap, "background", "Background");
    }
  else
    {
      st->fg_index = 0;
      st->bg_index = st->ncolors / 4;
      if (st->fg_index == st->bg_index) st->bg_index++;
      st->fg_pixel = st->colors[st->fg_index].pixel;
      st->bg_pixel = st->colors[st->bg_index].pixel;
    }

  st->width = max (50, xgwa.width);
  st->height = max (50, xgwa.height);

#ifdef DEBUG
  st->width/=2; st->height/=2;
#endif

  st->pixmap = XCreatePixmap (st->dpy, st->window, st->width, st->height, 1);
  if (cmode == seuss_mode)
    st->buffer = XCreatePixmap (st->dpy, st->window, st->width, st->height, 1);
  else
    st->buffer = 0;

  gcv.foreground = 1;
  gcv.background = 0;
  st->draw_gc = XCreateGC (st->dpy, st->pixmap, GCForeground | GCBackground, &gcv);
  gcv.foreground = 0;
  st->erase_gc = XCreateGC (st->dpy, st->pixmap, GCForeground, &gcv);
  gcv.foreground = st->fg_pixel;
  gcv.background = st->bg_pixel;
  st->copy_gc = XCreateGC (st->dpy, st->window, GCForeground | GCBackground, &gcv);

#ifdef HAVE_JWXYZ
  jwxyz_XSetAntiAliasing (dpy, st->draw_gc,  False);
  jwxyz_XSetAntiAliasing (dpy, st->erase_gc, False);
  jwxyz_XSetAntiAliasing (dpy, st->copy_gc,  False);
#endif

  if (cmode == seuss_mode)
    {
      gcv.foreground = 1;
      gcv.background = 0;
      gcv.function = GXxor;
      st->merge_gc = XCreateGC (st->dpy, st->pixmap,
			    GCForeground | GCBackground | GCFunction, &gcv);
    }
  else
    {
      gcv.foreground = st->fg_pixel;
      gcv.background = st->bg_pixel;
      gcv.function = GXcopy;
      st->merge_gc = XCreateGC (st->dpy, st->window,
			    GCForeground | GCBackground | GCFunction, &gcv);
    }

  init_circles_1 (st);
  XClearWindow (st->dpy, st->window);
  if (st->buffer) XFillRectangle (st->dpy, st->buffer, st->erase_gc, 0, 0, st->width, st->height);
  return st;
}
Exemple #14
0
int main(int argc, char**argv)
{
	char **missing_charset_list;
	int missing_charset_count;
	XGCValues xgcv;
	unsigned long mask;
	Display* dpy;
	int scr;
	Window w, root;
	XSetWindowAttributes set_attr;
	int i;
	XIMStyle *style;
        static char buf[128];
        KeySym keysym = 0;
        Status status;
	XWMHints wm_hints;
    	XClassHint class_hints;
	XIMStyle input_style = 0;
	char **font_name_list;
	char *def_string;
	XFontStruct **font_struct_list;
	char **font_encoding_list;
	int nb_font;
	int len = 0;
	int no_xim = 0;

	printf ("A -> %c \n", XUtf8Tolower('A'));
    	if (!setlocale(LC_ALL, ""))
        	puts("locale not supported by C library, locale unchanged");

    	if (!XSetLocaleModifiers(""))
        	puts("X locale modifiers not supported, using default");
	
	dpy = XOpenDisplay(0);
	if (!dpy) { puts("cannot open display.\n"); exit(-1); }
	scr = DefaultScreen(dpy);
	root = RootWindow(dpy, scr);
	set_attr.event_mask = KeyPressMask|FocusChangeMask;
	set_attr.background_pixel = WhitePixel(dpy, DefaultScreen(dpy));
	set_attr.border_pixel = BlackPixel(dpy, DefaultScreen(dpy));
	w = XCreateWindow(dpy, root, 10,10,200,100,0, 
		DefaultDepth(dpy, DefaultScreen(dpy)),
		InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)),
		CWEventMask | CWBackPixel | CWBorderPixel, &set_attr);
	if (!w) { puts("cannot creat window.\n"); exit(-1); }

	class_hints.res_name = "test";
    	class_hints.res_class = "Test";
	wm_hints.input = True;
    	wm_hints.flags = InputHint;

    	XmbSetWMProperties(dpy, w, "test", "test", NULL, 0,
                       NULL, &wm_hints, &class_hints);

	XMapWindow(dpy, w);
	xim_im = XOpenIM(dpy, NULL, "test", "Test");
	if (!xim_im) { 
		puts("cannot Open Input Manager: Try default.\n"); 
		XSetLocaleModifiers("@im=");
		xim_im = XOpenIM(dpy, NULL, "test", "Test");
		if (!xim_im) { puts("Failed exiting.\n"); exit(-1); }
	}
	XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL);
    	for (i = 0, style = xim_styles->supported_styles;
         	i < xim_styles->count_styles; i++, style++)
	{
		if (i == 0 && *style == (XIMStatusNone|XIMPreeditNone)) {
			printf("this is not a XIM server !!!\n");
			no_xim = 1;
		}
        	printf("input style : 0x%X\n", *style);
	}

	xim_ic = XCreateIC(xim_im,
                        XNInputStyle, 
			(XIMPreeditNothing | XIMStatusNothing),
                        XNClientWindow, w,
			XNFocusWindow, w,
                        NULL);
	if (!xim_ic) { puts("cannot create Input Context.\n"); exit(-1);}
    	XFree(xim_styles);
	XSetICFocus(xim_ic);

	/***************************************************************/
	/** I don't recommand to use a font base name list similar 
	 *  to the following one in a real application ;-) 
	 *  You should use an iso8859-1 font, plus a single font for 
	 *  your language. */
	/***************************************************************/
        fontset = XCreateUtf8FontStruct(dpy, 
		"-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */
		"-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-6,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-8,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-ksc5601.1987-0,"
		"-*-symbol-*-*-*-*-*-*-*-*-*-*-adobe-fontspecific," 
		"-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-2,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-jisx0208.1983-0,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-jisx0212.1990-0,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-big5-0,"
		"-*-*-*-*-*-*-*-*-*-*-*-*-jisx0201.1976-0,"
		"-*-unifont-*-*-*-*-*-*-*-*-*-*-iso10646-1[0x300 0x400_0x500],"
		"-*-*-*-*-*-*-*-*-*-*-*-*-*-*"); 

	/* THIS PART IS NOT REQUIERED */
	nb_font = fontset->nb_font;

        while (nb_font > 0) {
                nb_font--;
		if (fontset->fonts[nb_font]) {
               		printf("encoding=\"\" fid=%d \n  %s\n", 
			//	fontset->encodings[nb_font],
                        	fontset->fonts[nb_font]->fid,
				fontset->font_name_list[nb_font]);
		}
        }
	/* END OF NOT REQUIERED PART*/

	mask = (GCForeground | GCBackground);
	xgcv.foreground = BlackPixel(dpy, DefaultScreen(dpy));
    	xgcv.background = WhitePixel(dpy, DefaultScreen(dpy));

        gc = XCreateGC(dpy, w, mask, &xgcv);
	if (!gc) { puts("cannot create Graphic Context.\n"); exit(-1);}


	/***************************************************************/
	while (1) {
		int filtered;
	 	static XEvent xevent;
		static XVaNestedList list1 = 0;
		int r;

               	XNextEvent(dpy, &xevent);
		if (xevent.type == KeyPress) {
			XKeyEvent *e = (XKeyEvent*) &xevent;
			printf ("0x%X %d\n", e->state, e->keycode);
		}
		if (xevent.type == DestroyNotify) {
			/* XIM server has crashed */
			no_xim = 1;
			XSetLocaleModifiers("@im=");
			xim_im = XOpenIM(dpy, NULL, "test", "Test");
			if (xim_im) {
			   xim_ic = XCreateIC(xim_im,
                        	XNInputStyle, (XIMPreeditNothing | 
					XIMStatusNothing),
                        	XNClientWindow, w,
				XNFocusWindow, w,
                        	NULL);
   			} else {
				xim_ic = NULL;
			}
			if (!xim_ic) {
			 	puts("Crash recovery failed. exiting.\n");
				exit(-1);
			}
		}
		if (xevent.type != DestroyNotify) {
			filtered = XFilterEvent(&xevent, 0);
		}
		if (xevent.type == FocusOut && xim_ic) XUnsetICFocus(xim_ic);
		if (xevent.type == FocusIn && xim_ic) XSetICFocus(xim_ic);

		if (xevent.type == KeyPress && !filtered) {
 			len = XUtf8LookupString(xim_ic, &xevent.xkey, 
					buf, 127, &keysym, &status);

			if (len == 1 && buf[0] == '\b') {
				x -= XUtf8TextWidth(fontset, buf, len);
				XUtf8DrawImageString(dpy, w, fontset, gc, 
					x, y, buf, len);
			} else if (len == 1 && buf[0] == '\r') {
				y += fontset->ascent + fontset->descent;
				x = 0;
				XCloseIM(xim_im);
			} else {
				XUtf8DrawImageString(dpy, w, fontset, gc, 
					x, y, buf, len);
				x += XUtf8TextWidth(fontset, buf, len);
			}


			XUtf8DrawString(dpy, w, fontset, gc, 0, 20, 
				jp_txt, strlen(jp_txt));
	
			XUtf8DrawString(dpy, w, fontset, gc, 50, 90,
				rtl_txt, strlen(rtl_txt));
			XUtf8DrawRtlString(dpy, w, fontset, gc, 
				50, 90, rtl_txt, strlen(rtl_txt));
			buf[len] = 0;
			printf("'%s' %d %x\n", buf, keysym, keysym);
			buf[0] = 0;

                }
		if (filtered) {
			printf("Dead key\n");
		}
	}
	XFreeUtf8FontStruct(dpy, fontset);
	return 0;
}
Pixmap GLXConfigurator::CreateBackdrop(Window rootWindow, int depth) {
    int bpl;
    /* Find out number of bytes per pixel */
    switch(depth) {
    default:
        LogManager::getSingleton().logMessage("GLX backdrop: Unsupported bit depth");
        /* Unsupported bit depth */
        return 0;
    case 15:
    case 16:
        bpl = 2;
        break;
    case 24:
    case 32:
        bpl = 4;
        break;
    }
    /* Create background pixmap */
    unsigned char *data = 0; // Must be allocated with malloc

    try {
        String imgType = "png";
        Image img;
        MemoryDataStream *imgStream;
        DataStreamPtr imgStreamPtr;

        // Load backdrop image using OGRE
        imgStream = new MemoryDataStream((void*)GLX_backdrop_data, sizeof(GLX_backdrop_data), false);
        imgStreamPtr = DataStreamPtr(imgStream);
        img.load(imgStreamPtr, imgType);

        PixelBox src = img.getPixelBox(0, 0);

        // Convert and copy image
        data = (unsigned char*)malloc(mWidth * mHeight * bpl); // Must be allocated with malloc

        PixelBox dst(src, bpl == 2 ? PF_B5G6R5 : PF_A8R8G8B8, data );

        PixelUtil::bulkPixelConversion(src, dst);
    } catch(Exception &e) {
        // Could not find image; never mind
        LogManager::getSingleton().logMessage("WARNING: Can not load backdrop for config dialog. " + e.getDescription(), LML_TRIVIAL);
        return 0;
    }

    GC context = XCreateGC (mDisplay, rootWindow, 0, NULL);

    /* put my pixmap data into the client side X image data structure */
    XImage *image = XCreateImage (mDisplay, NULL, depth, ZPixmap, 0,
                                  (char*)data,
                                  mWidth, mHeight, 8,
                                  mWidth*bpl);
#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
    image->byte_order = MSBFirst;
#else
    image->byte_order = LSBFirst;
#endif

    /* tell server to start managing my pixmap */
    Pixmap rv = XCreatePixmap(mDisplay, rootWindow, mWidth,
                              mHeight, depth);

    /* copy from client to server */
    XPutImage(mDisplay, rv, context, image, 0, 0, 0, 0,
              mWidth, mHeight);

    /* free up the client side pixmap data area */
    XDestroyImage(image); // also cleans data
    XFreeGC(mDisplay, context);

    return rv;
}
/*****************************************************************************
  FUNCTION : o_createOszi

  PURPOSE  : creates the  window GRAPH
  RETURNS  : void
  NOTES    :

  UPDATE   : 08.03.95
******************************************************************************/
void o_createOszi (void)
{
    Widget       menu,mItem,form,w1,w2,printlab;
    Widget       Done_oszi, clear_oszi, print_oszi;
    Arg          arg[5];
    Cardinal     n;
    char         buf[40];
    Colormap     o_graph_col;
    unsigned long foreground,background;
    int          curr_unit,test_unit,
    count_unit = 0;


    o_graph_error_scale = GRAPH_SSE;

    /* test whether there are output units defined. Since no error can be 
       computed in the opposit case, the graph tool can not be used */
    curr_unit  = krui_getCurrentUnit();
    test_unit  = krui_getFirstUnit();
    do{
	n=krui_getUnitTType(test_unit);
	if( (n == 2) || (n == 7) ) count_unit = 1;
    }while((test_unit  = krui_getNextUnit()) && (count_unit == 0));
    curr_unit  = krui_setCurrentUnit(curr_unit);
 
    if(count_unit == 0){
	ui_confirmOk("No Output units defined!\nAn error can neither be\ncomputed nor displayed!");
	return;
    }


    if(o_open) {
	XRaiseWindow (XtDisplay (o_displayMainWidget), 
		      XtWindow (o_displayMainWidget));
	return;
    }
	
    o_open = 1; 
    o_init();
    
    sprintf (buf, "SNNS graph");
    n = 0;  

    XtSetArg(arg[n],XtNminWidth,460); n++;  
    XtSetArg(arg[n],XtNminHeight,200); n++;
    XtSetArg(arg[n],XtNheight,o_WindowHeight+58); n++;
    XtSetArg(arg[n],XtNwidth,o_WindowWidth+10); n++;
    XtSetArg(arg[n],XtNborderWidth,1); n++;
    
    o_displayMainWidget = XtCreatePopupShell(buf, topLevelShellWidgetClass,
					     ui_toplevel, arg, n); 
    n = 0;  
    form = XtCreateManagedWidget ("form", formWidgetClass, 
				  o_displayMainWidget, arg, n);

    grid_oszi = ui_xCreateToggleItem ("grid",form,NULL,NULL,NULL);
    ui_xSetToggleState (grid_oszi, FALSE) ; 
    XtAddCallback (grid_oszi, XtNcallback, (XtCallbackProc) o_gridProc, NULL);

    print_oszi = ui_xCreateButtonItem ("print",form,grid_oszi,NULL);
    XtAddCallback(print_oszi, XtNcallback, (XtCallbackProc) o_printProc, NULL);

    if(strlen(o_printfile) == 0)sprintf(o_printfile,"./graph.ps");
    printlab = ui_xCreateLabelItem("Print to file:",form,14*8,print_oszi,NULL); 
    o_printW = ui_xCreateDialogItem ("o_printW",form,o_printfile,0,
				     printlab,NULL);

    Done_oszi = ui_xCreateButtonItem ("done",form,NULL,grid_oszi);
    XtAddCallback(Done_oszi,XtNcallback,(XtCallbackProc) o_DoneProc,NULL);

    clear_oszi = ui_xCreateButtonItem ("clear",form,Done_oszi,grid_oszi);
    XtAddCallback(clear_oszi,XtNcallback,(XtCallbackProc) o_clearProc,NULL);

    w1 = ui_xCreateLabelItem ("Scale X:",form,7*8,print_oszi,grid_oszi); 
    w2 = ui_xCreateButtonItem ("prev",form,w1,grid_oszi);
    XtAddCallback(w2,XtNcallback,(XtCallbackProc) o_XForwardProc,NULL);
    w1 = ui_xCreateButtonItem ("next",form,w2,grid_oszi);
    XtAddCallback(w1,XtNcallback,(XtCallbackProc) o_XBackProc,NULL);

    w2 = ui_xCreateLabelItem ("  Scale Y:",form,9*8,w1,grid_oszi); 
    w1 = ui_xCreateButtonItem ("prev",form,w2,grid_oszi); 
    XtAddCallback(w1,XtNcallback,(XtCallbackProc) o_YBackProc,NULL);
    w2 = ui_xCreateButtonItem ("next",form,w1,grid_oszi);
    XtAddCallback(w2,XtNcallback,(XtCallbackProc) o_YForwardProc,NULL);

    w1 = ui_xCreateLabelItem ("  Display:",form,9*8,w2,grid_oszi); 
    o_scaleWidget = ui_xCreateMenuButtonItem("   SSE  ",form,w1,grid_oszi);
    menu  = XtCreatePopupShell("menu",simpleMenuWidgetClass,o_scaleWidget,
			       NULL,ZERO);
    mItem = XtCreateManagedWidget("  SSE",smeBSBObjectClass,menu,NULL,ZERO);
    XtAddCallback(mItem,XtNcallback,(XtCallbackProc)o_set_err_scale,(caddr_t)1);
    mItem = XtCreateManagedWidget("  MSE",smeBSBObjectClass,menu,NULL,ZERO);
    XtAddCallback(mItem,XtNcallback,(XtCallbackProc)o_set_err_scale,(caddr_t)2);
    mItem = XtCreateManagedWidget("SSE/#out", smeBSBObjectClass,menu,NULL,ZERO);
    XtAddCallback(mItem,XtNcallback,(XtCallbackProc)o_set_err_scale,(caddr_t)3);

    o_DisplayWidget = o_xCreateScreenItem("screen",form,o_WindowWidth,
					  o_WindowHeight,NULL,clear_oszi);
    XtAddEventHandler(o_DisplayWidget,StructureNotifyMask | ExposureMask, 
		      FALSE,(XtEventHandler) o_eventProc,o_display);

    XtAddEventHandler(form,KeyPressMask,FALSE,
		      (XtEventHandler)ui_key_control,(Cardinal *) 0);

    ui_checkWindowPosition(o_displayMainWidget);
    XtPopup (o_displayMainWidget, XtGrabNone);

    o_display = XtDisplay (o_DisplayWidget); 
    o_window = XtWindow (o_DisplayWidget);
    o_fontStruct = XLoadQueryFont(o_display, "6x12");

    o_gc[label_gc] = XCreateGC (o_display, o_window, ZERO, NULL);
    o_gc[train_gc] = XCreateGC (o_display, o_window, ZERO, NULL);
    o_gc[test_gc] = XCreateGC (o_display, o_window, ZERO, NULL);
    XSetFont(o_display,o_gc[label_gc],(*o_fontStruct).fid);
    o_screen = DefaultScreen (o_display);
    o_depth = DisplayPlanes(o_display,o_screen);
    o_graph_col = DefaultColormap(o_display, o_screen);

    if(ui_col_monochromeMode == FALSE){
	/* settings for black learning curve */
	fg.red = 0; fg.green = 0; fg.blue = 0; 
	fg2.red = 65535; fg2.green = 0; fg2.blue = 0;

    }else{
	XSetLineAttributes(o_display, o_gc[test_gc],1,LineDoubleDash,
			   CapButt,JoinMiter);
	fg.red = 0; fg.green = 0; fg.blue = 0;
	fg2.red = 0; fg2.green = 0; fg2.blue = 0;
    }
    background = WhitePixel (o_display, o_screen);
    XSetBackground (o_display, o_gc[train_gc], background);
    XSetBackground (o_display, o_gc[test_gc],  background);
    XSetBackground (o_display, o_gc[label_gc], background);
    XAllocColor(o_display,o_graph_col,&fg);
    XAllocColor(o_display,o_graph_col,&fg2);
    foreground = BlackPixel (o_display, o_screen); 
    XSetForeground (o_display, o_gc[train_gc], fg.pixel); 
    XSetForeground (o_display, o_gc[test_gc],  fg2.pixel); 
    XSetForeground (o_display, o_gc[label_gc], foreground); 

    XSetGraphicsExposures(o_display,o_gc[label_gc],0);
    XSetGraphicsExposures(o_display,o_gc[train_gc],0);
    XSetGraphicsExposures(o_display,o_gc[test_gc],0);

    o_Pixmap = XCreatePixmap(o_display,o_window, (unsigned int) o_PixmapWidth, 
			     (unsigned int) o_PixmapHeight, 
			     (unsigned int) o_depth);
    o_ClearPixmap(o_display,o_Pixmap,o_gc[train_gc],fg.pixel,o_screen,0,0,
		  o_PixmapWidth,o_PixmapHeight); 
    o_ClearPixmap(o_display,o_Pixmap,o_gc[test_gc],fg2.pixel,o_screen,0,0,
		  o_PixmapWidth,o_PixmapHeight); 
    XClearArea(o_display,o_window,o_OsziXPos,o_OsziYPos, 
	       (unsigned int) o_OsziWidth-1, (unsigned int) o_OsziHeight,1);
    o_PressPossible = 1;
}
Exemple #17
0
// Creates the event addon
void* FcitxTabletCreate(FcitxInstance* instance) {
	FcitxTablet* tablet = fcitx_utils_new(FcitxTablet);
	FcitxTabletLoadConfig(&tablet->config);
	// TODO select driver from config, currently using lxbi

	{ // Initialise the driver
		switch(tablet->config.Driver) {
		case DRIVER_LXBI:
			tablet->driverInstance = &lxbi;
		break;
		// add other drivers here
		}
		tablet->driverData = tablet->driverInstance->Create();
		tablet->driverPacket = (char*) malloc(tablet->driverInstance->packet_size);
	}

	{ // Initialise the X display
		if(NULL == (tablet->xDisplay = FcitxX11GetDisplay(instance)))  {
			FcitxLog(ERROR, "Unable to open X display");
			return NULL;
		}
		// get dimensions
		int screen = DefaultScreen(tablet->xDisplay);
		tablet->xWidth = tablet->config.Width;
		tablet->xHeight = tablet->config.Height;
		int x = tablet->config.XPos > 0 ? tablet->config.XPos : XDisplayWidth(tablet->xDisplay, screen) - tablet->xWidth + tablet->config.XPos;
		int y = tablet->config.YPos > 0 ? tablet->config.YPos : XDisplayHeight(tablet->xDisplay, screen) - tablet->xHeight + tablet->config.YPos;
		// create colours
		XColor back;
		XColor fore;
		{
			char colourString[32];
			{
				int r = (255*tablet->config.BackgroundColour.r);
				int g = (255*tablet->config.BackgroundColour.g);
				int b = (255*tablet->config.BackgroundColour.b);
				sprintf(colourString,"rgb:%x/%x/%x",r,g,b);
			}
			Colormap defaultCMap = DefaultColormap(tablet->xDisplay, screen);
			XParseColor(tablet->xDisplay, defaultCMap, colourString, &back);
			XAllocColor(tablet->xDisplay, defaultCMap, &back);
			{
				int r = (255*tablet->config.StrokeColour.r);
				int g = (255*tablet->config.StrokeColour.g);
				int b = (255*tablet->config.StrokeColour.b);
				sprintf(colourString,"rgb:%x/%x/%x",r,g,b);
			}
			XParseColor(tablet->xDisplay, defaultCMap, colourString, &fore);
			XAllocColor(tablet->xDisplay, defaultCMap, &fore);
		}
		// set window attributes and create window
		XSetWindowAttributes attrs;
		attrs.override_redirect = True;
		attrs.background_pixel = back.pixel;
		tablet->xWindow = XCreateWindow(tablet->xDisplay, DefaultRootWindow(tablet->xDisplay),
			 x, y, tablet->xWidth, tablet->xHeight, tablet->config.BorderWidth, CopyFromParent,
			 InputOutput, CopyFromParent, CWBackPixel | CWOverrideRedirect, &attrs);
		// set up the foreground line (stroke) style
		XGCValues gcv;
		gcv.function = GXcopy;
		gcv.subwindow_mode = IncludeInferiors;
		gcv.line_width = 3;
		gcv.cap_style = CapRound;
		gcv.join_style = JoinRound;
		tablet->xGC = XCreateGC(tablet->xDisplay, tablet->xWindow, GCFunction | GCSubwindowMode | GCLineWidth | GCCapStyle | GCJoinStyle, &gcv);
		XSetForeground(tablet->xDisplay, tablet->xGC, fore.pixel);
		// prevent the window from getting focus or input
		XRectangle rect = {0,0,0,0};
		XserverRegion region = XFixesCreateRegion(tablet->xDisplay,&rect, 1);
		XFixesSetWindowShapeRegion(tablet->xDisplay, tablet->xWindow, ShapeInput, 0, 0, region);
		XFixesDestroyRegion(tablet->xDisplay, region);
	}

	{ // Initialise the stroke buffer
		tablet->strokesBufferSize = 2048; // should be heaps. Will get automatically enlarged if required
		tablet->strokesBuffer = (pt_t*) malloc(sizeof(pt_t) * tablet->strokesBufferSize);
		tablet->strokesPtr = tablet->strokesBuffer;
	}

	{ // instantiate the engine
		switch(tablet->config.Engine) {
		case ENGINE_ZINNIA:
			tablet->engineInstance = &engZinnia;
			break;
		case ENGINE_FORK:
			tablet->engineInstance = &engFork;
			break;
		// add other engines here
		}
		tablet->engineData = tablet->engineInstance->Create(&tablet->config);
	}

	{ // set up the timerfd
		tablet->timeoutFd = timerfd_create(CLOCK_MONOTONIC, 0);
		tablet->delay.it_interval.tv_sec = 0;
		tablet->delay.it_interval.tv_nsec = 0;
		tablet->delay.it_value.tv_sec = tablet->config.CommitCharMs / 1000;
		tablet->delay.it_value.tv_nsec = (tablet->config.CommitCharMs % 1000) * 1000000;
		tablet->timeoutCommitPending = 0;
	}

	tablet->fcitx = instance;
	return tablet;
}
Exemple #18
0
void
xrectsel(unsigned *x_sel, unsigned *y_sel, unsigned *w_sel, unsigned *h_sel)
{
    Display *dpy = XOpenDisplay(NULL);
    if (!dpy)
        return;

    Window root = DefaultRootWindow(dpy);

    XEvent ev;

    GC sel_gc;
    XGCValues sel_gv;

    int btn_pressed = 0;
    int x = 0, y = 0;
    unsigned int width = 0, height = 0;
    int start_x = 0, start_y = 0;

    Cursor cursor;
    cursor = XCreateFontCursor(dpy, XC_crosshair);

    /* Grab pointer for these events */
    XGrabPointer(dpy, root, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
            GrabModeAsync, GrabModeAsync, None, cursor, CurrentTime);

    sel_gv.function = GXinvert;
    sel_gv.subwindow_mode = IncludeInferiors;
    sel_gv.line_width = 1;
    sel_gc = XCreateGC(dpy, root, GCFunction | GCSubwindowMode | GCLineWidth, &sel_gv);

    for (;;) {
        XNextEvent(dpy, &ev);

        if (ev.type == ButtonPress) {
            btn_pressed = 1;
            x = start_x = ev.xbutton.x_root;
            y = start_y = ev.xbutton.y_root;
            width = height = 0;

        } else if (ev.type == MotionNotify) {
            if (!btn_pressed)
                continue; /* Draw only if button is pressed */

            /* Re-draw last Rectangle to clear it */
            XDrawRectangle(dpy, root, sel_gc, x, y, width, height);

            x = ev.xbutton.x_root;
            y = ev.xbutton.y_root;

            if (x > start_x) {
                width = x - start_x;
                x = start_x;
            } else {
                width = start_x - x;
            }

            if (y > start_y) {
                height = y - start_y;
                y = start_y;
            } else {
                height = start_y - y;
            }

            /* Draw Rectangle */
            XDrawRectangle(dpy, root, sel_gc, x, y, width, height);
            XFlush(dpy);

        } else if (ev.type == ButtonRelease)
            break;
    }

    /* Re-draw last Rectangle to clear it */
    XDrawRectangle(dpy, root, sel_gc, x, y, width, height);
    XFlush(dpy);

    XUngrabPointer(dpy, CurrentTime);
    XFreeCursor(dpy, cursor);
    XFreeGC(dpy, sel_gc);
    XSync(dpy, 1);

    *x_sel = x;
    *y_sel = y;
    *w_sel = width;
    *h_sel = height;

    XCloseDisplay(dpy);
}
Exemple #19
0
static void
ShowAlert(const char *title,
	  const char *ignore, const char *restart, const char *quit,
	  const char *fmt, va_list args)
{
   char                text[4096], buf1[64], buf2[64], buf3[64];
   Window              win, b1 = 0, b2 = 0, b3 = 0, root;
   Display            *dd;
   int                 wid, hih, w, h, i, k, mask;
   XGCValues           gcv;
   GC                  gc;
   unsigned int        len;
   XEvent              ev;
   XSetWindowAttributes att;
   XRectangle          rect1, rect2;
   char                colorful;
   unsigned long       cols[5];
   XColor              xcl;
   Colormap            cmap;
   int                 cnum, fh, x, y, ww, hh, bw, bh;
   char               *str1, *str2, *str3, *p;
   KeyCode             keycode;
   int                 button;
   char              **missing_charset_list_return, *def_string_return;
   int                 missing_charset_count_return;
   XFontStruct       **font_struct_list_return;
   char              **font_name_list_return;

#if 0
   /* Don't play sound here (maybe if not forked/in signal handler - later) */
   SoundPlay(SOUND_ALERT);
#endif

   if (!fmt)
      return;

   Evsnprintf(text, sizeof(text), fmt, args);

   /*
    * We may get here from obscure places like an X-error or signal handler
    * and things seem to work properly only if we do a new XOpenDisplay().
    */
   dd = XOpenDisplay(NULL);
   if (!dd)
     {
	fprintf(stderr, "%s\n", text);
	fflush(stderr);
	return;
     }

   button = 0;

   if (!title)
      title = _("Enlightenment Error");
   str1 = AlertButtonText(1, buf1, sizeof(buf1), ignore);
   str2 = AlertButtonText(2, buf2, sizeof(buf2), restart);
   str3 = AlertButtonText(3, buf3, sizeof(buf3), quit);

   cnum = 0;
   colorful = 0;
   cols[0] = cols[1] = cols[2] = cols[3] = cols[4] = 0;
   cmap = DefaultColormap(dd, DefaultScreen(dd));
   if (DefaultDepth(dd, DefaultScreen(dd)) > 4)
     {
	ExSetColor(&xcl, 220, 220, 220);
	if (!XAllocColor(dd, cmap, &xcl))
	   goto CN;
	cols[cnum++] = xcl.pixel;
	ExSetColor(&xcl, 160, 160, 160);
	if (!XAllocColor(dd, cmap, &xcl))
	   goto CN;
	cols[cnum++] = xcl.pixel;
	ExSetColor(&xcl, 100, 100, 100);
	if (!XAllocColor(dd, cmap, &xcl))
	   goto CN;
	cols[cnum++] = xcl.pixel;
	ExSetColor(&xcl, 0, 0, 0);
	if (!XAllocColor(dd, cmap, &xcl))
	   goto CN;
	cols[cnum++] = xcl.pixel;
	ExSetColor(&xcl, 255, 255, 255);
	if (!XAllocColor(dd, cmap, &xcl))
	   goto CN;
	cols[cnum++] = xcl.pixel;
	colorful = 1;
     }
 CN:

   if (colorful)
      att.background_pixel = cols[1];
   else
      att.background_pixel = BlackPixel(dd, DefaultScreen(dd));
   if (colorful)
      att.border_pixel = cols[3];
   else
      att.border_pixel = WhitePixel(dd, DefaultScreen(dd));
   att.backing_store = Always;
   att.save_under = True;
   att.override_redirect = True;
   mask = CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWSaveUnder |
      CWBackingStore;

#if USE_COMPOSITE_OVERLAY_WINDOW
   /*
    * Intended workings:
    * Composite extension not enabled (or COW not available?)
    * - fall back to root
    * Composite extension enabled
    * - use COW whether or not compositing is enabled, window mode too
    */
   root = XCompositeGetOverlayWindow(dd, DefaultRootWindow(dd));
   if (root == None)
#endif
     {
	root = DefaultRootWindow(dd);
     }
   win = XCreateWindow(dd, root, -100, -100, 1, 1, 0,
		       CopyFromParent, InputOutput, CopyFromParent, mask, &att);

   gc = XCreateGC(dd, win, 0, &gcv);
   if (colorful)
      XSetForeground(dd, gc, cols[3]);
   else
      XSetForeground(dd, gc, att.border_pixel);

   xfs = XCreateFontSet(dd, "fixed",
			&missing_charset_list_return,
			&missing_charset_count_return, &def_string_return);
   if (!xfs)
      goto done;

   if (missing_charset_list_return)
      XFreeStringList(missing_charset_list_return);

   k = XFontsOfFontSet(xfs, &font_struct_list_return, &font_name_list_return);
   fh = 0;
   for (i = 0; i < k; i++)
     {
	h = font_struct_list_return[i]->ascent +
	   font_struct_list_return[i]->descent;
	if (fh < h)
	   fh = h;
     }

   XSelectInput(dd, win, ExposureMask);
   XMapWindow(dd, win);

   XGrabServer(dd);

   XGrabPointer(dd, win, False, ButtonPressMask | ButtonReleaseMask,
		GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
   XGrabKeyboard(dd, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
   XSetInputFocus(dd, win, RevertToPointerRoot, CurrentTime);

   XSync(dd, False);

   wid = DisplayWidth(dd, DefaultScreen(dd));
   hih = DisplayHeight(dd, DefaultScreen(dd));
   ww = (wid >= 600) ? 600 : (wid / 40) * 40;
   hh = (hih >= 440) ? 440 : (hih / 40) * 40;

   for (i = 40; i < ww; i += 40)
     {
	w = i;
	h = (i * hh) / ww;
	x = (wid - w) >> 1;
	y = (hih - h) >> 1;
	XMoveResizeWindow(dd, win, x, y, w, h);
	DRAW_BOX_OUT(dd, gc, win, 0, 0, w, h);
	XSync(dd, False);
	SleepUs(20000);
     }
   x = (wid - ww) >> 1;
   y = (hih - hh) >> 1;
   XMoveResizeWindow(dd, win, x, y, ww, hh);
   XSync(dd, False);

   bw = 0;
   if (str1)
     {
	ExTextExtents(xfs, str1, strlen(str1), &rect1, &rect2);
	bw = (rect2.width > bw) ? rect2.width : bw;
     }
   if (str2)
     {
	ExTextExtents(xfs, str2, strlen(str2), &rect1, &rect2);
	bw = (rect2.width > bw) ? rect2.width : bw;
     }
   if (str3)
     {
	ExTextExtents(xfs, str3, strlen(str3), &rect1, &rect2);
	bw = (rect2.width > bw) ? rect2.width : bw;
     }
   bw += 20;
   bh = fh + 10;

#define BX(i) (5 + (((ww - bw - 10) * (i)) / 2))
#define BY    (hh - bh - 5)

   if (str1)
     {
	b1 = XCreateWindow(dd, win, BX(0), BY, bw, bh, 0, CopyFromParent,
			   InputOutput, CopyFromParent, mask, &att);
	XMapWindow(dd, b1);
     }
   if (str2)
     {
	b2 = XCreateWindow(dd, win, BX(1), BY, bw, bh, 0, CopyFromParent,
			   InputOutput, CopyFromParent, mask, &att);
	XMapWindow(dd, b2);
     }
   if (str3)
     {
	b3 = XCreateWindow(dd, win, BX(2), BY, bw, bh, 0, CopyFromParent,
			   InputOutput, CopyFromParent, mask, &att);
	XMapWindow(dd, b3);
     }
   XSync(dd, False);

   button = 0;
   for (; button == 0;)
     {
	XNextEvent(dd, &ev);
	switch (ev.type)
	  {
	  case KeyPress:
	     keycode = XKeysymToKeycode(dd, XK_F1);
	     if (keycode == ev.xkey.keycode)
	       {
		  DRAW_BOX_IN(dd, gc, b1, 0, 0, bw, bh);
		  XSync(dd, False);
		  SleepUs(500000);
		  DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
		  button = 1;
		  goto do_sync;
	       }
	     keycode = XKeysymToKeycode(dd, XK_F2);
	     if (keycode == ev.xkey.keycode)
	       {
		  DRAW_BOX_IN(dd, gc, b2, 0, 0, bw, bh);
		  XSync(dd, False);
		  SleepUs(500000);
		  DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
		  button = 2;
		  goto do_sync;
	       }
	     keycode = XKeysymToKeycode(dd, XK_F3);
	     if (keycode == ev.xkey.keycode)
	       {
		  DRAW_BOX_IN(dd, gc, b3, 0, 0, bw, bh);
		  XSync(dd, False);
		  SleepUs(500000);
		  DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
		  button = 3;
		  goto do_sync;
	       }
	     break;

	  case ButtonPress:
	     if (!(ev.xbutton.y >= BY && ev.xbutton.y < BY + bh))
		break;

	     x = BX(0);
	     if (b1 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_IN(dd, gc, b1, 0, 0, bw, bh);
		  goto do_sync;
	       }
	     x = BX(1);
	     if (b2 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_IN(dd, gc, b2, 0, 0, bw, bh);
		  goto do_sync;
	       }
	     x = BX(2);
	     if (b3 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_IN(dd, gc, b3, 0, 0, bw, bh);
		  goto do_sync;
	       }
	     break;

	  case ButtonRelease:
	     if (!(ev.xbutton.y >= BY && ev.xbutton.y < BY + bh))
		break;

	     x = BX(0);
	     if (b1 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
		  button = 1;
		  goto do_sync;
	       }
	     x = BX(1);
	     if (b2 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
		  button = 2;
		  goto do_sync;
	       }
	     x = BX(2);
	     if (b3 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
	       {
		  DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
		  button = 3;
		  goto do_sync;
	       }
	     break;

	  case Expose:
	     /* Flush all other Expose events */
	     while (XCheckTypedWindowEvent(dd, ev.xexpose.window, Expose, &ev))
		;

	     ExTextExtents(xfs, title, strlen(title), &rect1, &rect2);
	     w = rect2.width;

	     DRAW_HEADER(dd, gc, win, (ww - w) / 2, 5 - rect2.y, title);
	     DRAW_BOX_OUT(dd, gc, win, 0, 0, ww, bh);
	     DRAW_BOX_OUT(dd, gc, win, 0, bh - 1, ww, hh - fh - fh - 30 + 2);
	     DRAW_BOX_OUT(dd, gc, win, 0, hh - fh - 20, ww, fh + 20);
	     k = bh;
	     for (p = text;; p += len + 1)
	       {
		  len = strcspn(p, "\n");
		  DRAW_STRING(dd, gc, win, 6, 6 + k + fh, p, len);
		  k += fh + 2;
		  if (p[len] == '\0')
		     break;
	       }
	     if (str1)
	       {
		  ExTextExtents(xfs, str1, strlen(str1), &rect1, &rect2);
		  w = rect2.width;
		  DRAW_HEADER(dd, gc, b1, (bw - w) / 2, 5 - rect2.y, str1);
		  DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
		  DRAW_THIN_BOX_IN(dd, gc, win,
				   BX(0) - 2, BY - 2, bw + 4, bh + 4);
	       }
	     if (str2)
	       {
		  ExTextExtents(xfs, str2, strlen(str2), &rect1, &rect2);
		  w = rect2.width;
		  DRAW_HEADER(dd, gc, b2, (bw - w) / 2, 5 - rect2.y, str2);
		  DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
		  DRAW_THIN_BOX_IN(dd, gc, win,
				   BX(1) - 2, BY - 2, bw + 4, bh + 4);
	       }
	     if (str3)
	       {
		  ExTextExtents(xfs, str3, strlen(str3), &rect1, &rect2);
		  w = rect2.width;
		  DRAW_HEADER(dd, gc, b3, (bw - w) / 2, 5 - rect2.y, str3);
		  DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
		  DRAW_THIN_BOX_IN(dd, gc, win,
				   BX(2) - 2, BY - 2, bw + 4, bh + 4);
	       }
	   do_sync:
	     XSync(dd, False);
	     break;

	  default:
	     break;
	  }
     }

   XFreeFontSet(dd, xfs);
 done:
   XUngrabServer(dd);
   XDestroyWindow(dd, win);
   XFreeGC(dd, gc);
   if (cnum > 0)
      XFreeColors(dd, cmap, cols, cnum, 0);
   XCloseDisplay(dd);

   switch (button)
     {
     default:
     case 1:
	break;
     case 2:
	SessionExit(EEXIT_RESTART, NULL);
	break;
     case 3:
	SessionExit(EEXIT_EXIT, NULL);
	break;
     }
}
Exemple #20
0
void
msg_win_create(MBPanel             *panel,
	       MBPanelMessageQueue *msg)
{
  int msg_win_x = 0, msg_win_y = 0, msg_win_w = 0, msg_win_h = 0,
    box_x_offset = 0, box_y_offset = 0, arrow_offset = 0, cnt = 0,
    box_w, box_h;
  
  int x, y, txt_v_offset;
  unsigned char r, g, b, fr, fg, fb;
  
  MBPixbufImage       *img_backing = NULL;
  MBDrawable          *tmp_drw;

  Pixmap               mask;
  GC                   mask_gc;
  XSetWindowAttributes attr;
  XWindowAttributes    root_attr;
  XWMHints            *wm_hints;
  long                 winmask;
  MBLayout            *layout;

  /*
#ifdef USE_XFT
  XftDraw             *xftdraw;
  XftColor             txt_xftcol;
  XRenderColor         colortmp;
#endif
  */

  layout = msg_calc_win_size(panel, msg, &msg_win_w, &msg_win_h);
  
  msg_win_h += (2*MSG_WIN_Y_PAD);
  
  box_w = msg_win_w; box_h = msg_win_h;

  XGetWindowAttributes(panel->dpy, panel->win_root, &root_attr);
  
#define ARROW_SIZE 4
#define MSG_TEXT_MARGIN 10

  switch (panel->orientation)
    {
    case East:
      msg_win_w    += ARROW_SIZE;
      msg_win_x     = panel->x - msg_win_w - 5;	     
      break;
    case West:
      msg_win_w    += ARROW_SIZE;
      box_x_offset += ARROW_SIZE;
      msg_win_x     = panel->x + panel->w + 5;
      break;
    case South:
      msg_win_h    += ARROW_SIZE;
      msg_win_y     = panel->y - msg_win_h - 5;
      break;
    case North:
      msg_win_h    += ARROW_SIZE;
      box_y_offset += ARROW_SIZE;
      msg_win_y     = panel->y + panel->h + 5;
      break;
    }

  if (PANEL_IS_VERTICAL(panel))
    {
      arrow_offset = msg_win_h / 2; 
      msg_win_y    = panel->y + msg->sender->y + (msg->sender->h/2) - arrow_offset;
      
      if (msg_win_y < 0)
	{
	  msg_win_y    = 5; 	/* a little margin to display top */
	  arrow_offset = msg->sender->y + (msg->sender->h/2);
	}
      
      if (msg_win_y + msg_win_h > panel->y + panel->h)
	{
	   /* reposition with a bit of margin - 5px */
	  msg_win_y = (panel->y + panel->h) - msg_win_h - 5;
	  arrow_offset = panel->y + msg->sender->y - msg_win_y + (msg->sender->h/2);
	}
    } 
  else
    {
      arrow_offset = msg_win_w / 2; 
      msg_win_x    = panel->x + msg->sender->x + (msg->sender->w/2) - arrow_offset;
      
      if (msg_win_x < 0)
	{
	  msg_win_x    = 5;
	  arrow_offset = msg->sender->x + (msg->sender->w/2);
	}
      
      if (msg_win_x + msg_win_w > panel->x + panel->w)
	{
	  msg_win_x = (panel->x + panel->w) - msg_win_w - 5;
	  arrow_offset = panel->x + msg->sender->x - msg_win_x + (msg->sender->w/2);
	}
    }
  
  attr.event_mask            = ButtonPressMask|ButtonReleaseMask|ExposureMask;
  attr.background_pixel      = BlackPixel(panel->dpy, panel->screen);
  attr.do_not_propagate_mask = ButtonPressMask|ButtonReleaseMask;
  winmask                    = CWBackPixel|CWEventMask|CWDontPropagate;

  if (panel->use_overide_wins)
    {
      winmask |= CWOverrideRedirect;
      attr.override_redirect = True;
    }
  
  panel->msg_win = XCreateWindow(panel->dpy, panel->win_root,
				 msg_win_x,
				 msg_win_y, 
				 msg_win_w, 
				 msg_win_h, 0,
				 CopyFromParent,
				 CopyFromParent,
				 CopyFromParent,
				 winmask,
				 &attr);
  
  XChangeProperty(panel->dpy, panel->msg_win, 
		  panel->atoms[ATOM_WM_WINDOW_TYPE],
		  XA_ATOM, 32,  PropModeReplace,
		  (unsigned char *)
		  &panel->atoms[ATOM_WM_WINDOW_TYPE_SPLASH], 1);
  
  wm_hints = XAllocWMHints();
  wm_hints->input = False;
  wm_hints->flags = InputHint;
  XSetWMHints(panel->dpy, panel->msg_win, wm_hints);
  
  tmp_drw = mb_drawable_new(panel->pb, msg_win_w, msg_win_h);
  
  img_backing = mb_pixbuf_img_rgba_new(panel->pb, msg_win_w, msg_win_h);
  
  mask = XCreatePixmap(panel->dpy, panel->win_root, msg_win_w, msg_win_h, 1 );
  mask_gc = XCreateGC(panel->dpy, mask, 0, 0 );

  XSetForeground(panel->dpy, mask_gc, WhitePixel( panel->dpy, panel->screen ));
  XFillRectangle(panel->dpy, mask, mask_gc, 0, 0, msg_win_w, msg_win_h );
  XSetForeground(panel->dpy, mask_gc, BlackPixel( panel->dpy, panel->screen ));
  
  /* 
   *  - fill entire block with forground color 
   *  - alpha clear part
   *  - draw arrow part
   *  - curve corners ? 
   */
  
  r = mb_col_red(panel->msg_col);
  g = mb_col_green(panel->msg_col);
  b = mb_col_blue(panel->msg_col);

  fr = mb_col_red(panel->msg_fg_col);
  fg = mb_col_green(panel->msg_fg_col);
  fb = mb_col_blue(panel->msg_fg_col);

  mb_pixbuf_img_fill (panel->pb, img_backing, r, g, b, 255);

  /* border */

  /* top/bottom */
  for (x = box_x_offset; x < box_x_offset + box_w; x++)
    {
      mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, box_y_offset,
			       fr, fg, fb);
      mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, 
			       box_h + box_y_offset - 1,
			       fr, fg, fb);
    }
  
  /* sides */
  for (y = box_y_offset; y < box_y_offset + box_h; y++)
    {
      mb_pixbuf_img_plot_pixel(panel->pb, img_backing, box_x_offset, y, 
			       fr, fg, fb);
      mb_pixbuf_img_plot_pixel(panel->pb, img_backing, 
			       box_w + box_x_offset - 1, y,
			       fr, fg, fb);
    }

  /* arrow */
   
  switch (panel->orientation)
    {
    case East:
      
      for (x= box_w; x < msg_win_w; x++)
	for (y=0; y < box_h; y++)
	  XDrawPoint(panel->dpy, mask, mask_gc, x, y);
      
      XSetForeground( panel->dpy, mask_gc, 
		      WhitePixel( panel->dpy, panel->screen ));
      
      for (x= msg_win_w - 1; x > msg_win_w - ARROW_SIZE - 2 ; x--)
	{
	  for (y = arrow_offset - cnt; y <= arrow_offset + cnt; y++)
	    {
	      XDrawPoint(panel->dpy, mask, mask_gc, x, y);
	      if ( y == (arrow_offset - cnt) || y == (arrow_offset + cnt) )
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, 
					 fr, fg, fb);
	      else
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, r,g,b);
	    }
	  cnt++;
	}
      
      break;
      
    case West:

      for (x=0; x<ARROW_SIZE; x++)
	for (y=0; y < msg_win_h; y++)
	  XDrawPoint(panel->dpy, mask, mask_gc, x, y);
      
      XSetForeground( panel->dpy, mask_gc, 
		      WhitePixel( panel->dpy, panel->screen ));
      
      for (x=0; x<ARROW_SIZE + 1; x++)
	{
	  for (y = arrow_offset - cnt; y <= arrow_offset + cnt; y++)
	    {
	      XDrawPoint(panel->dpy, mask, mask_gc, x, y);
	      if ( y == (arrow_offset - cnt) || y == (arrow_offset + cnt) )
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, 
					 fr, fg, fb);
	      else
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, r,g,b);
	    }
	  cnt++;
	}
      
      break;
      
    case South:

      for (y=msg_win_h-ARROW_SIZE; y < msg_win_h; y++)
	for (x=0; x < msg_win_w; x++)
	  XDrawPoint(panel->dpy, mask, mask_gc, x, y);
      
      XSetForeground( panel->dpy, mask_gc, 
		      WhitePixel( panel->dpy, panel->screen ));
      
      for (y=msg_win_h; y >= msg_win_h - ARROW_SIZE - 1; y--)
	{
	  for (x = arrow_offset - cnt; x <= arrow_offset + cnt; x++)
	    {
	      XDrawPoint(panel->dpy, mask, mask_gc, x, y);
	      if ( x == (arrow_offset - cnt) || x == (arrow_offset + cnt) )
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, 
					 fr, fg, fb);
	      else
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, r,g,b);
	    }
	  cnt++;
	}
      
      break;

    case North:

      for (y=0; y < ARROW_SIZE; y++)
	for (x=0; x < msg_win_w; x++)
	  XDrawPoint(panel->dpy, mask, mask_gc, x, y);

      XSetForeground( panel->dpy, mask_gc, 
		      WhitePixel( panel->dpy, panel->screen ));
      
      for (y=0; y < ARROW_SIZE + 1; y++)
	{
	  for (x = arrow_offset - cnt; x <= arrow_offset + cnt; x++)
	    {
	      XDrawPoint(panel->dpy, mask, mask_gc, x, y);

	      if ( x == (arrow_offset - cnt) || x == (arrow_offset + cnt) )
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, 
					 fr, fg, fb);
	      else
		mb_pixbuf_img_plot_pixel(panel->pb, img_backing, x, y, r,g,b);
	    }

	  cnt++;
	}
      
      break;
      
    }
  
  /* Render picture to pixmap  */
  mb_pixbuf_img_render_to_drawable(panel->pb, img_backing, 
				   mb_drawable_pixmap(tmp_drw),
				   0, 0);
  
  
  mb_font_set_color(panel->msg_font, panel->msg_fg_col);

  txt_v_offset = MSG_WIN_Y_PAD + box_y_offset;
  
  /*
  i = strlen(msg->sender->name);
  while (_get_text_length(panel, msg->sender->name, i) > ( box_w + ( 2 * MSG_TEXT_MARGIN )) 
	 && i > 0)
    i--;
  */

  /* Title */

  XSetForeground(panel->dpy, panel->msg_gc, mb_col_xpixel(panel->msg_fg_col));
		
  mb_font_render_simple (panel->msg_font,
			 tmp_drw,
			 MSG_TEXT_MARGIN + box_x_offset, 
			 txt_v_offset,
			 box_w, /* XXX - TEXT_MARGIN ? */
			 (unsigned char *)msg->sender->name,
			 MB_ENCODING_UTF8,
			 0);

  /* close box */
  
  XDrawRectangle(panel->dpy, mb_drawable_pixmap(tmp_drw), panel->msg_gc, 
		 box_x_offset + box_w - MSG_TEXT_MARGIN - mb_font_get_height(panel->msg_font),   
		 txt_v_offset, 
		 mb_font_get_height(panel->msg_font), 
		 mb_font_get_height(panel->msg_font) );

  XDrawLine(panel->dpy, mb_drawable_pixmap(tmp_drw), panel->msg_gc, 
	    box_x_offset + box_w - MSG_TEXT_MARGIN - mb_font_get_height(panel->msg_font),   
	    txt_v_offset ,
	    box_x_offset + box_w - MSG_TEXT_MARGIN, 
	    txt_v_offset + mb_font_get_height(panel->msg_font));

  XDrawLine(panel->dpy, mb_drawable_pixmap(tmp_drw), panel->msg_gc, 
	    box_x_offset + box_w - MSG_TEXT_MARGIN - mb_font_get_height(panel->msg_font),   
	    txt_v_offset + mb_font_get_height(panel->msg_font),
	    box_x_offset + box_w - MSG_TEXT_MARGIN, 
	    txt_v_offset );

  /* Title underline */

  XDrawLine(panel->dpy, mb_drawable_pixmap(tmp_drw), panel->msg_gc,
	    box_x_offset + MSG_TEXT_MARGIN / 2 , 
	    txt_v_offset + mb_font_get_height(panel->msg_font) + ( MSG_LINE_SPC / 2 ), 
	    box_x_offset + box_w - (MSG_TEXT_MARGIN / 2), 
	    txt_v_offset + mb_font_get_height(panel->msg_font) + ( MSG_LINE_SPC / 2 ) );

  /* Forward render postion on */
  txt_v_offset += mb_font_get_height(panel->msg_font) + MSG_LINE_SPC;

  /* render msg text */
  mb_layout_render (layout, tmp_drw, MSG_TEXT_MARGIN + box_x_offset, txt_v_offset, 0);

  txt_v_offset += mb_layout_height(layout);

  /* Context button, if applicable */
   if (msg->extra_context_data)
     {
       int context_width = mb_font_get_txt_width ( panel->msg_font,  
						   msg->extra_context_data, 
						   strlen((char*)msg->extra_context_data),
						   MB_ENCODING_UTF8);

       XSetForeground( panel->dpy, panel->msg_gc, mb_col_xpixel(panel->msg_link_col));

       panel->msg_context_y1 = txt_v_offset;
       panel->msg_context_y2 = txt_v_offset + mb_font_get_height(panel->msg_font);

       mb_font_set_color(panel->msg_font, panel->msg_link_col);

       mb_font_render_simple (panel->msg_font,
			      tmp_drw,
			      MSG_TEXT_MARGIN + box_x_offset, 
			      txt_v_offset,
			      box_w,
			      (unsigned char *)msg->extra_context_data,
			      MB_ENCODING_UTF8,
			      0);

      /* underline */

      XDrawLine(panel->dpy, mb_drawable_pixmap(tmp_drw), panel->msg_gc, 
		MSG_TEXT_MARGIN + box_x_offset,
		txt_v_offset + mb_font_get_height(panel->msg_font),
		MSG_TEXT_MARGIN + box_x_offset + context_width,
		txt_v_offset + mb_font_get_height(panel->msg_font));
     }

  
  XSetWindowBackgroundPixmap(panel->dpy, panel->msg_win, 
			     mb_drawable_pixmap(tmp_drw));


  mb_drawable_unref(tmp_drw);		
  
  XShapeCombineMask( panel->dpy, panel->msg_win, ShapeBounding, 0, 0, mask, ShapeSet);	 

  XMapWindow(panel->dpy, panel->msg_win);
  XFree(wm_hints);
  
  mb_pixbuf_img_free(panel->pb, img_backing);
  XFreePixmap(panel->dpy, mask);
}
Exemple #21
0
static void
init_map (struct state *st)
{
  XGCValues gcv;

  XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
  st->cmap = st->xgwa.colormap;

  st->flip_x  = (random() % 2);
  st->flip_xy = (random() % 2);

  if (mono_p)
    st->flip_xy = 0;
  else if (st->colors)
    free_colors (st->xgwa.screen, st->cmap, st->colors, st->ncolors);
  st->colors = 0;

  st->ncolors = get_integer_resource (st->dpy, "ncolors", "Integer");
  st->delay = get_integer_resource (st->dpy, "delay", "Integer");
  st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer");
  st->iterations = get_integer_resource (st->dpy, "iterations", "Integer");
  if (st->iterations < 0) st->iterations = 0;
  else if (st->iterations > 7) st->iterations = 7;

  if (st->ncolors <= 2) st->ncolors = 0;
  if (st->ncolors == 0) mono_p = True;
  if (st->ncolors > 255) st->ncolors = 255;  /* too many look bad */

  if (!st->gc)  st->gc  = XCreateGC (st->dpy, st->window, 0, &gcv);
  if (!st->gc2) st->gc2 = XCreateGC (st->dpy, st->window, 0, &gcv);

  if (mono_p)
    st->extra_krinkly_p = !(random() % 15);
  else
    st->extra_krinkly_p = !(random() % 5);

  if (!mono_p)
    {
      st->colors = (XColor *) malloc (st->ncolors * sizeof(*st->colors));

      make_smooth_colormap (st->xgwa.screen, st->xgwa.visual, st->cmap,
                            st->colors, &st->ncolors,
                            True, 0, False);
      if (st->ncolors <= 2)
	mono_p = 1;
    }

  if (mono_p)
    {
      int i;
      unsigned long fg_pixel = 
        get_pixel_resource (st->dpy, st->xgwa.colormap, 
                            "foreground", "Foreground");
      unsigned long bg_pixel = 
        get_pixel_resource (st->dpy, st->xgwa.colormap, 
                            "background", "Background");
      if (!st->colors)
        {
          st->ncolors = 50;
          st->colors = (XColor *) calloc (st->ncolors, sizeof(*st->colors));
        }
      st->colors[0].pixel = fg_pixel;
      for (i = 1; i < st->ncolors; i++)
        st->colors[i].pixel = bg_pixel;
    }

  XSetForeground (st->dpy, st->gc, st->colors[1].pixel);
  XFillRectangle (st->dpy, st->window, st->gc, 0, 0, 
                  st->xgwa.width, st->xgwa.height);

  if (st->flip_xy)
    {
      st->xmax = st->xgwa.height;
      st->ymax = st->xgwa.width;
    }
  else
    {
      st->xmax = st->xgwa.width;
      st->ymax = st->xgwa.height;
    }

  if (st->cell) free (st->cell);
  st->cell = (signed char *) calloc (st->xmax * st->ymax, 1);

  CELL (0, 0) = 0;
  st->xstep = COUNT;
  st->ystep = COUNT;

  st->iteration = 0;
  st->cx = 0;
}
void winopen(void)
{
	XWMHints *hints;

	xdpy = XOpenDisplay(nil);
	if (!xdpy)
		winerror(&gapp, "could not open display.");

	XA_TARGETS = XInternAtom(xdpy, "TARGETS", False);
	XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False);
	XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False);

	xscr = DefaultScreen(xdpy);

	ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr));

	xcarrow = XCreateFontCursor(xdpy, XC_left_ptr);
	xchand = XCreateFontCursor(xdpy, XC_hand2);
	xcwait = XCreateFontCursor(xdpy, XC_watch);

	xbgcolor.red = 0x7000;
	xbgcolor.green = 0x7000;
	xbgcolor.blue = 0x7000;

	xshcolor.red = 0x4000;
	xshcolor.green = 0x4000;
	xshcolor.blue = 0x4000;

	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor);
	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor);

	xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy),
			10, 10, 200, 100, 1,
			ximage_get_depth(),
			InputOutput,
			ximage_get_visual(),
			0,
			nil);

	XSetWindowColormap(xdpy, xwin, ximage_get_colormap());
	XSelectInput(xdpy, xwin,
			StructureNotifyMask | ExposureMask | KeyPressMask |
			PointerMotionMask | ButtonPressMask | ButtonReleaseMask);

	mapped = 0;

	xgc = XCreateGC(xdpy, xwin, 0, nil);

	XDefineCursor(xdpy, xwin, xcarrow);

	hints = XAllocWMHints();
	if (hints)
	{
		hints->flags = IconPixmapHint;
		hints->icon_pixmap = XCreateBitmapFromData(xdpy, xwin,
				gs_l_xbm_bits, gs_l_xbm_width, gs_l_xbm_height);
		if (hints->icon_pixmap)
		{
			XSetWMHints(xdpy, xwin, hints);
		}
		XFree(hints);
	}
}
Exemple #23
0
bool CWinSystemX11::CreateIconPixmap()
{
  int depth;
  XImage *img = NULL;
  Visual *vis;
  XWindowAttributes wndattribs;
  XVisualInfo visInfo;
  double rRatio;
  double gRatio;
  double bRatio;
  int outIndex = 0;
  unsigned int i,j;
  unsigned char *buf;
  uint32_t *newBuf = 0;
  size_t numNewBufBytes;

  // Get visual Info
  XGetWindowAttributes(m_dpy, m_glWindow, &wndattribs);
  visInfo.visualid = wndattribs.visual->visualid;
  int nvisuals = 0;
  XVisualInfo* visuals = XGetVisualInfo(m_dpy, VisualIDMask, &visInfo, &nvisuals);
  if (nvisuals != 1)
  {
    CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - could not find visual");
    return false;
  }
  visInfo = visuals[0];
  XFree(visuals);

  depth = visInfo.depth;
  vis = visInfo.visual;

  if (depth < 15)
  {
    CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - no suitable depth");
    return false;
  }

  rRatio = vis->red_mask / 255.0;
  gRatio = vis->green_mask / 255.0;
  bRatio = vis->blue_mask / 255.0;

  CBaseTexture *iconTexture = CBaseTexture::LoadFromFile("special://xbmc/media/icon256x256.png");

  if (!iconTexture)
    return false;

  buf = iconTexture->GetPixels();

  if (depth>=24)
    numNewBufBytes = (4 * (iconTexture->GetWidth() * iconTexture->GetHeight()));
  else
    numNewBufBytes = (2 * (iconTexture->GetWidth() * iconTexture->GetHeight()));

  newBuf = (uint32_t*)malloc(numNewBufBytes);
  if (!newBuf)
  {
    CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - malloc failed");
    return false;
  }

  for (i=0; i<iconTexture->GetHeight();++i)
  {
    for (j=0; j<iconTexture->GetWidth();++j)
    {
      unsigned int pos = i*iconTexture->GetPitch()+j*4;
      unsigned int r, g, b;
      r = (buf[pos+2] * rRatio);
      g = (buf[pos+1] * gRatio);
      b = (buf[pos+0] * bRatio);
      r &= vis->red_mask;
      g &= vis->green_mask;
      b &= vis->blue_mask;
      newBuf[outIndex] = r | g | b;
      ++outIndex;
    }
  }
  img = XCreateImage(m_dpy, vis, depth,ZPixmap, 0, (char *)newBuf,
                     iconTexture->GetWidth(), iconTexture->GetHeight(),
                     (depth>=24)?32:16, 0);
  if (!img)
  {
    CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - could not create image");
    free(newBuf);
    return false;
  }
  if (!XInitImage(img))
  {
    CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - init image failed");
    XDestroyImage(img);
    return false;
  }

  // set byte order
  union
  {
    char c[sizeof(short)];
    short s;
  } order;
  order.s = 1;
  if ((1 == order.c[0]))
  {
    img->byte_order = LSBFirst;
  }
  else
  {
    img->byte_order = MSBFirst;
  }

  // create icon pixmap from image
  m_icon = XCreatePixmap(m_dpy, m_glWindow, img->width, img->height, depth);
  GC gc = XCreateGC(m_dpy, m_glWindow, 0, NULL);
  XPutImage(m_dpy, m_icon, gc, img, 0, 0, 0, 0, img->width, img->height);
  XFreeGC(m_dpy, gc);
  XDestroyImage(img); // this also frees newBuf

  delete iconTexture;

  return true;
}
Exemple #24
0
BOOL InitPixelFormat(SCREENSAVER *ss)
{
    ModeInfo *mi;
    int i;

    ss->modeinfo.gc = XCreateGC(ss->hdc, 0, 0, NULL);
    assert(ss->modeinfo.gc != NULL);

    if (hack_ncolors <= 0)
        hack_ncolors = 64;
    else if (hack_ncolors > MAX_COLORCELLS)
        hack_ncolors = MAX_COLORCELLS;

    mi = &ss->modeinfo;

	mi->install_p = fChildPreview;

    mi->writable_p = True;

    mi->black_pixel = 0;
    mi->white_pixel = 255;
    mi->npixels = hack_ncolors;
    mi->colors = NULL;
    mi->pixels = NULL;

    mi->threed = False;
    mi->threed_delta = 1.5;
	mi->threed_right_color = load_color(NULL, 0, "red");
    mi->threed_left_color = load_color(NULL, 0, "blue");
    mi->threed_both_color = load_color(NULL, 0, "magenta");
    mi->threed_none_color = load_color(NULL, 0, "black");

    if (hack_ncolors_enabled)
    {
        mi->colors = (XColor *) calloc(mi->npixels, sizeof(*mi->colors));
        if (mi->colors == NULL)
            return FALSE;

        switch (hack_color_scheme)
        {
        case color_scheme_uniform:
            make_uniform_colormap(mi->xgwa.screen, mi->xgwa.visual,
                mi->xgwa.colormap,
                mi->colors, &mi->npixels,
                True, &mi->writable_p, True);
            break;

        case color_scheme_smooth:
            make_smooth_colormap(mi->xgwa.screen, mi->xgwa.visual,
                mi->xgwa.colormap,
                mi->colors, &mi->npixels,
                True, &mi->writable_p, True);
            break;

        case color_scheme_bright:
        case color_scheme_default:
            make_random_colormap(mi->xgwa.screen, mi->xgwa.visual,
                mi->xgwa.colormap,
                mi->colors, &mi->npixels,
                (hack_color_scheme == color_scheme_bright),
                True, &mi->writable_p, True);
            break;

        default:
            fprintf(stderr, "Bad color scheme\n");
            abort();
        }

        mi->pixels = (unsigned long *)calloc(mi->npixels, sizeof(*mi->pixels));
        if (mi->pixels == NULL)
        {
            free(mi->colors);
            return FALSE;
        }

        for (i = 0; i < mi->npixels; i++)
            mi->pixels[i] = mi->colors[i].pixel;
    }

    return TRUE;
}
Exemple #25
0
int main() {
	XTextProperty title;
	XEvent event; 
	XSizeHints *hints;
	XWMHints *wm_hints;
	KeySym key;

	Pixmap pix;

	pthread_t thread;
	
	/* grepare toPlot function */
	spline_init();

	/* visual routines */
	int pressed_1[3] = {0, 0, 0};	// pressed state of button1: condition and coordinates

	char *caption = "Interpolation";
	char *dpy_str = getenv("DISPLAY");

	fprintf(stderr, "Connecting to %s\t ", dpy_str);
	dpy = XOpenDisplay(dpy_str);
	if( !dpy ) {
		fprintf(stderr, "Unable to connect\n");
		exit(EXIT_FAILURE);
	} else {
		fprintf(stderr, "OK\n");
	}

	scr = DefaultScreen(dpy);
	getColors();

	width = 2 * DisplayWidth(dpy, scr) / 3;
	height = 2 * DisplayHeight(dpy, scr) / 3;

	win = XCreateSimpleWindow(dpy,
			RootWindow(dpy, scr),
			0, 0,
			width, height,
			0,
			black, white
			);

	XStringListToTextProperty(&caption, 1, &title);
	XSetWMName(dpy, win, &title);
	XSetWMIconName(dpy, win, &title);


	cont = XCreateGC(dpy, win, 0, NULL);

	if( cont<0 ) {
		fprintf(stderr, "XCReateGC: unable to set GC");
		exit(EXIT_FAILURE);
	}

	/* making window unresizeable */
	hints = XAllocSizeHints();
	if( !hints ) {
		fprintf(stderr, "XAllocSizeHints: out of memory");
		exit(EXIT_FAILURE);
	}
	hints->flags = PMaxSize | PMinSize;
	hints->min_width = width;
	hints->min_height = height;
	hints->max_width = width;
	hints->max_height = height;
	XSetWMNormalHints(dpy, win, hints);
	XFree(hints);

	/* setting icon */
	pix = XCreateBitmapFromData(dpy, win, icon_bits, icon_width, icon_height);
	if( !pix ) {
		fprintf(stderr, "XCreateBitmapFromData: cannot create icon");
		exit(EXIT_FAILURE);
	}

	wm_hints = XAllocWMHints(); 
	if( !wm_hints ) {
		fprintf(stderr, "XAllocWMHints: out of memory");
		exit(EXIT_FAILURE);
	}
	wm_hints->flags = IconPixmapHint | StateHint | IconPositionHint;
	wm_hints->icon_pixmap = pix;
	wm_hints->initial_state = IconicState;
	wm_hints->icon_x = 0;
	wm_hints->icon_y = 0;

	XSetWMHints(dpy, win, wm_hints);
	XFree(wm_hints);
	

	/* making window visible */
	XMapWindow(dpy, win);
	draw(2,1);

	XSelectInput(dpy, win, ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask);

	while( 1 ) {
		XNextEvent(dpy, &event);
		switch( event.type ) {
			case Expose:
				if( event.xexpose.count>0 )
					break;
				draw(0,1);
				XFlush(dpy);
				break;
			case KeyPress:
				XLookupString((XKeyEvent*) &event, NULL, 0, &key, NULL);
				/* moving window */
				switch( key ) {
					case XK_Down:
						pthread_create(&thread, NULL, dec, (void*)&shift_y);
						break;
					case XK_Up:
						pthread_create(&thread, NULL, inc, (void*)&shift_y);
						break;
					case XK_Right:
						pthread_create(&thread, NULL, dec, (void*)&shift_x);
						break;
					case XK_Left:
						pthread_create(&thread, NULL, inc, (void*)&shift_x);
						break;
					case XK_plus:
						pthread_create(&thread, NULL, inc, (void*)&shift_pix);
						break;
					case XK_minus:
						pthread_create(&thread, NULL, dec, (void*)&shift_pix);
						break;
					case XK_equal:
						pthread_create(&thread, NULL, def, (void*)NULL);
						break;
					case XK_Escape:
						XCloseDisplay(dpy);
						exit(EXIT_SUCCESS);
					default:
						break;
				}
				break;
			case ButtonPress:
				switch( event.xbutton.button ) {
					case Button1:
						pressed_1[0]=1;
						pressed_1[1]=event.xmotion.x;
						pressed_1[2]=event.xmotion.y;
						break;
					default:
						break;
				}
				break;
			case ButtonRelease:
				switch( event.xbutton.button ) {
					case Button1:
						pressed_1[0]=0;
						break;
					default:
						break;
				}
				break;

			case MotionNotify:
				if( pressed_1[0] ) {
					/* if button_1 is pressed while moving */
					draw(1,0);
					shift_x-=pressed_1[1]-event.xmotion.x;
					shift_y-=pressed_1[2]-event.xmotion.y;
					pressed_1[1]=event.xmotion.x;
					pressed_1[2]=event.xmotion.y;
					draw(1,1);
				}
				pos_x=event.xmotion.x;
				pos_y=event.xmotion.y;
				drawInfo();

				break;
			default:
				break;
		} /* switch(event.type) */
	} /* endless loop */

	XCloseDisplay(dpy);
	return EXIT_SUCCESS;
}
Exemple #26
0
int main(int argc, char **argv){
	Display *dpy;
	Window w, quit, clearButton, drawButton;
	Window root;
    struct timespec wait;
	int    screen;
	unsigned long black, white;
	GC       gc;
	XEvent   e;
    float t;
    int isDraw;
    int pointNum;
    int i;
    XPoint usrPoints[20];
    XPoint bufPoints[20];
    XPoint selectedPoints[20];

    //*************************************init****
    
	dpy = XOpenDisplay("");
    
	root = DefaultRootWindow (dpy);
	screen = DefaultScreen (dpy);
	white = WhitePixel (dpy, screen);
	black = BlackPixel (dpy, screen);
    
	w = XCreateSimpleWindow(dpy, root, 100, 100, WIDTH, HEIGHT, BORDER, black, white);
    
    /* Make Buttons */
	quit = XCreateSimpleWindow(dpy, w, 10, 3, 30, 12, BORDER, black, white);
    clearButton = XCreateSimpleWindow(dpy, w, 52, 3, 37, 12, BORDER, black, white);
    drawButton = XCreateSimpleWindow(dpy, w, 100, 3, 35, 12, BORDER, black, white);

	gc = XCreateGC(dpy, w, 0, NULL);
    
    pointNum = 0;
    isDraw = 0;
    t = 0;
    wait.tv_sec = 0;
    wait.tv_nsec = NANOTIME;
    
    for (i = 0; i < 20; i++) {
        usrPoints[i].x = 0;
        usrPoints[i].y = 0;
        bufPoints[i].x = 0;
        bufPoints[i].y = 0;
    }
    
    //*********************************************
    
	XSelectInput(dpy, w, ButtonPressMask | ExposureMask);
    XSelectInput(dpy, quit, ButtonPressMask);
    XSelectInput(dpy, clearButton, ButtonPressMask);
    XSelectInput(dpy, drawButton, ButtonPressMask);

    
	XMapWindow(dpy, w);
	XMapSubwindows(dpy, w);
    XSetForeground(dpy, gc, white);
	XSetForeground(dpy, gc, black);

    //*************************************loop****
	while(1){
        if(XEventsQueued(dpy, QueuedAfterReading)){
            XDrawString(dpy, quit, gc, 4, 10, "Exit", 4);
            XDrawString(dpy, clearButton, gc, 4, 10, "Clear", 5);
            XDrawString(dpy, drawButton, gc, 4, 10, "Draw", 4);
            //***********************************event****
            XNextEvent(dpy, &e);
            switch(e.type){
                case ButtonPress : 
                    if (e.xany.window == quit) {
                        return 0;
                    } else if (e.xany.window == clearButton) {
                        XClearWindow(dpy, w);
                        t = 0;
                        isDraw = 0;
                        pointNum = 0;
                    } else if (e.xany.window == drawButton) {
                        if (!pointNum) break;
                        isDraw = 1;
                    } else {
                        if (0 < t && t < 1) XClearWindow(dpy, w);
                        selectedPoints[pointNum].x = e.xbutton.x;
                        selectedPoints[pointNum].y = e.xbutton.y;
                        bufPoints[pointNum] = selectedPoints[pointNum];
                        pointNum++;
                        drawPointDetail(dpy, w, gc, bufPoints, pointNum);
                        isDraw = 0;
                        t = 0;
                    }
                    break;
                case Expose:
                    drawPointDetail(dpy, w, gc, bufPoints, pointNum);
                    isDraw = 0;
                    t = 0;
            }
        } else {
            //********************************animation****
            if (t < 1 && isDraw) {
                nanosleep(&wait, NULL);
                drawBeizerCurve(dpy, w, gc, selectedPoints, bufPoints, t, pointNum);
                t += 0.00001;
            } else if (t >= 1 && isDraw) {
                isDraw = 0;
            }
        }
        XFlush(dpy);
	}
    return 0;
}
Exemple #27
0
void xf_xdamage_init(xfInfo* xfi)
{
	Bool pixmaps;
	int damage_event;
	int damage_error;
	int major, minor;
	XGCValues values;

	if (XShmQueryExtension(xfi->display) != False)
	{
		XShmQueryVersion(xfi->display, &major, &minor, &pixmaps);

		if (pixmaps != True)
		{
			printf("XShmQueryVersion failed\n");
			return;
		}
	}
	else
	{
		printf("XShmQueryExtension failed\n");
		return;
	}

	if (XDamageQueryExtension(xfi->display, &damage_event, &damage_error) == 0)
	{
		printf("XDamageQueryExtension failed\n");
		return;
	}

	XDamageQueryVersion(xfi->display, &major, &minor);

	if (XDamageQueryVersion(xfi->display, &major, &minor) == 0)
	{
		printf("XDamageQueryVersion failed\n");
		return;
	}
	else if (major < 1)
	{
		printf("XDamageQueryVersion failed: major:%d minor:%d\n", major, minor);
		return;
	}

	xfi->xdamage_notify_event = damage_event + XDamageNotify;
	xfi->xdamage = XDamageCreate(xfi->display, xfi->root_window, XDamageReportDeltaRectangles);

	if (xfi->xdamage == None)
	{
		printf("XDamageCreate failed\n");
		return;
	}

#ifdef WITH_XFIXES
	xfi->xdamage_region = XFixesCreateRegion(xfi->display, NULL, 0);

	if (xfi->xdamage_region == None)
	{
		printf("XFixesCreateRegion failed\n");
		XDamageDestroy(xfi->display, xfi->xdamage);
		xfi->xdamage = None;
		return;
	}
#endif

	values.subwindow_mode = IncludeInferiors;
	xfi->xdamage_gc = XCreateGC(xfi->display, xfi->root_window, GCSubwindowMode, &values);
	XSetFunction(xfi->display, xfi->xdamage_gc, GXcopy);
}
/**
 * gdk_pixbuf_xlib_render_threshold_alpha:
 * @pixbuf: A pixbuf.
 * @bitmap: Bitmap where the bilevel mask will be painted to.
 * @src_x: Source X coordinate.
 * @src_y: source Y coordinate.
 * @dest_x: Destination X coordinate.
 * @dest_y: Destination Y coordinate.
 * @width: Width of region to threshold.
 * @height: Height of region to threshold.
 * @alpha_threshold: Opacity values below this will be painted as zero; all
 * other values will be painted as one.
 *
 * Takes the opacity values in a rectangular portion of a pixbuf and thresholds
 * them to produce a bi-level alpha mask that can be used as a clipping mask for
 * a drawable.
 *
 **/
void
gdk_pixbuf_xlib_render_threshold_alpha (GdkPixbuf *pixbuf, Pixmap bitmap,
					int src_x, int src_y,
					int dest_x, int dest_y,
					int width, int height,
					int alpha_threshold)
{
	GC gc;
	XColor color;
	int x, y;
	guchar *p;
	int start, start_status;
	int status;
	XGCValues gcv;

	g_return_if_fail (pixbuf != NULL);
	g_return_if_fail (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
	g_return_if_fail (gdk_pixbuf_get_n_channels (pixbuf) == 3 || gdk_pixbuf_get_n_channels (pixbuf) == 4);
	g_return_if_fail (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);

	g_return_if_fail (bitmap != 0);
	g_return_if_fail (width >= 0 && height >= 0);
	g_return_if_fail (src_x >= 0 && src_x + width <= gdk_pixbuf_get_width (pixbuf));
	g_return_if_fail (src_y >= 0 && src_y + height <= gdk_pixbuf_get_height (pixbuf));

	g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255);

	if (width == 0 || height == 0)
		return;

	gc = XCreateGC (gdk_pixbuf_dpy, bitmap, 0, &gcv);

	if (!gdk_pixbuf_get_has_alpha (pixbuf)) {
		color.pixel = (alpha_threshold == 255) ? 0 : 1;
		XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);
		XFillRectangle (gdk_pixbuf_dpy, bitmap, gc,
				dest_x, dest_y, width, height);
		XFreeGC (gdk_pixbuf_dpy, gc);
		return;
	}

	color.pixel = 0;
	XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);
	XFillRectangle (gdk_pixbuf_dpy, bitmap, gc,
			dest_x, dest_y, width, height);

	color.pixel = 1;
	XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);

	for (y = 0; y < height; y++) {
		p = (gdk_pixbuf_get_pixels (pixbuf) + (y + src_y) * gdk_pixbuf_get_rowstride (pixbuf) + src_x * gdk_pixbuf_get_n_channels (pixbuf)
		     + gdk_pixbuf_get_n_channels (pixbuf) - 1);

		start = 0;
		start_status = *p < alpha_threshold;

		for (x = 0; x < width; x++) {
			status = *p < alpha_threshold;

			if (status != start_status) {
				if (!start_status)
					XDrawLine (gdk_pixbuf_dpy, bitmap, gc,
						   start + dest_x, y + dest_y,
						   x - 1 + dest_x, y + dest_y);

				start = x;
				start_status = status;
			}

			p += gdk_pixbuf_get_n_channels (pixbuf);
		}

		if (!start_status)
			XDrawLine (gdk_pixbuf_dpy, bitmap, gc,
				   start + dest_x, y + dest_y,
				   x - 1 + dest_x, y + dest_y);
	}

	XFreeGC (gdk_pixbuf_dpy, gc);
}
Exemple #29
0
int main(int argc, char* argv[]) {

  int number_of_stars = 200;
  int iterations = 1000;
  prec time_unit = gdt;

  if(argc == 3)
    {
      number_of_stars = atoi(argv[1]);
      iterations = atoi(argv[2]);
    }
  struct star* star_array = malloc(sizeof(struct star) * number_of_stars);
  generate_init_values(number_of_stars, star_array);
  
  
  
  
  
#ifdef ANIMATE
  XPoint* points = malloc(sizeof(XPoint)*number_of_stars);
  Display* disp;
  Window window, rootwin;
  int screen;

  disp = XOpenDisplay(NULL);
  screen = DefaultScreen(disp);
  rootwin = RootWindow(disp,screen);
  window = XCreateSimpleWindow(disp,rootwin,
                               0,0,X_SIZE,Y_SIZE,1,0,0);
  GC gc = XCreateGC(disp, window, 0, 0);
  XSetForeground(disp, gc, WhitePixel(disp, screen));
  XSetBackground(disp, gc, BlackPixel(disp, screen));
  XMapWindow(disp,window);

  XClearWindow(disp,window);	
	
  copyToXBuffer(star_array, points, number_of_stars);
  XDrawPoints(disp, window, gc, points, number_of_stars, 0);

  XFlush(disp);

#endif

  clock_t start = clock();
  for(int i = 0; i < iterations; i++)
    {

#ifndef ANIMATE
      
      resetForces(number_of_stars, star_array);
      updateForces(number_of_stars, number_of_stars - 1, star_array);
      for(int j = 0; j < number_of_stars; ++j){
        update_position(&star_array[j], time_unit);
      }

#endif
     
#ifdef ANIMATE

      resetForces(number_of_stars, star_array);
      updateForces(number_of_stars, number_of_stars - 1, star_array);
      for(int j = 0; j < number_of_stars; ++j){
        update_position(&star_array[j], time_unit);


        copyToXBuffer(star_array, points,number_of_stars );
        XDrawPoints(disp, window, gc, points, number_of_stars, CoordModeOrigin);
	

      }
      XClearWindow(disp,window);

    
#endif
 
    }
  clock_t stop = clock();
  float diff = (float)(stop - start)/CLOCKS_PER_SEC;
  printf("Total: %lf seconds\n",diff);
  printf("Bodies: %d\n",number_of_stars);
  printf("Iterations: %d\n", iterations);

#ifdef ANIMATE
  free(points);
  XCloseDisplay(disp);
#endif
  free(star_array);
  return 0;
}
Exemple #30
-1
/*******************************************************************************\
|* openXwindow																   *|
\*******************************************************************************/
void openXwindow(int argc, char *argv[], char *pixmap_bytes[], char *pixmask_bits, int pixmask_width, int pixmask_height) {

	unsigned int	borderwidth = 1;
	XClassHint		classHint;
	char			*display_name = NULL;
	char			*wname = argv[0];
	XTextProperty	name;

	XGCValues		gcv;
	unsigned long	gcm;


	int				dummy=0;
	int				i;

	for (i=1; argv[i]; i++) {
		if (!strcmp(argv[i], "-display"))
			display_name = argv[i+1];
	}

	if (!(display = XOpenDisplay(display_name))) {
		fprintf(stderr, "%s: can't open display %s\n",
						wname, XDisplayName(display_name));
		exit(1);
	}
	screen  = DefaultScreen(display);
	Root    = RootWindow(display, screen);
	d_depth = DefaultDepth(display, screen);
	x_fd    = XConnectionNumber(display);

	/* Convert XPM to XImage */
	GetXPM(&wmgen, pixmap_bytes);

	/* Create a window to hold the stuff */
	mysizehints.flags = USSize | USPosition;
	mysizehints.x = 0;
	mysizehints.y = 0;

	back_pix = GetColor("white");
	fore_pix = GetColor("black");

	XWMGeometry(display, screen, Geometry, NULL, borderwidth, &mysizehints,
				&mysizehints.x, &mysizehints.y,&mysizehints.width,&mysizehints.height, &dummy);

	mysizehints.width = 64;
	mysizehints.height = 64;

	win = XCreateSimpleWindow(display, Root, mysizehints.x, mysizehints.y,
				mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);

	iconwin = XCreateSimpleWindow(display, win, mysizehints.x, mysizehints.y,
				mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);

	/* Activate hints */
	XSetWMNormalHints(display, win, &mysizehints);
	classHint.res_name = wname;
	classHint.res_class = wname;
	XSetClassHint(display, win, &classHint);

	XSelectInput(display, win, ButtonPressMask | ExposureMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);
	XSelectInput(display, iconwin, ButtonPressMask | ExposureMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);

	if (XStringListToTextProperty(&wname, 1, &name) == 0) {
		fprintf(stderr, "%s: can't allocate window name\n", wname);
		exit(1);
	}

	XSetWMName(display, win, &name);

	/* Create GC for drawing */

	gcm = GCForeground | GCBackground | GCGraphicsExposures;
	gcv.foreground = fore_pix;
	gcv.background = back_pix;
	gcv.graphics_exposures = 0;
	NormalGC = XCreateGC(display, Root, gcm, &gcv);

	/* ONLYSHAPE ON */

	pixmask = XCreateBitmapFromData(display, win, pixmask_bits, pixmask_width, pixmask_height);

	XShapeCombineMask(display, win, ShapeBounding, 0, 0, pixmask, ShapeSet);
	XShapeCombineMask(display, iconwin, ShapeBounding, 0, 0, pixmask, ShapeSet);

	/* ONLYSHAPE OFF */

	mywmhints.initial_state = WithdrawnState;
	mywmhints.icon_window = iconwin;
	mywmhints.icon_x = mysizehints.x;
	mywmhints.icon_y = mysizehints.y;
	mywmhints.window_group = win;
	mywmhints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint;

	XSetWMHints(display, win, &mywmhints);

	XSetCommand(display, win, argv, argc);
	XMapWindow(display, win);

}