int puglCreateWindow(PuglView* view, const char* title) { PuglInternals* const impl = view->impl; impl->display = XOpenDisplay(NULL); impl->screen = DefaultScreen(impl->display); XVisualInfo* const vi = getVisual(view); if (!vi) { XCloseDisplay(impl->display); impl->display = NULL; return 1; } #ifdef PUGL_HAVE_GL int glxMajor, glxMinor; glXQueryVersion(impl->display, &glxMajor, &glxMinor); PUGL_LOGF("GLX Version %d.%d\n", glxMajor, glxMinor); #endif Window xParent = view->parent ? (Window)view->parent : RootWindow(impl->display, impl->screen); Colormap cmap = XCreateColormap( impl->display, xParent, vi->visual, AllocNone); XSetWindowAttributes attr; memset(&attr, 0, sizeof(XSetWindowAttributes)); attr.background_pixel = BlackPixel(impl->display, impl->screen); attr.border_pixel = BlackPixel(impl->display, impl->screen); attr.colormap = cmap; attr.event_mask = (ExposureMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask); impl->win = XCreateWindow( impl->display, xParent, 0, 0, view->width, view->height, 0, vi->depth, InputOutput, vi->visual, CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &attr); if (!createContext(view, vi)) { XDestroyWindow(impl->display, impl->win); impl->win = 0; XCloseDisplay(impl->display); impl->display = NULL; return 1; } XSizeHints sizeHints; memset(&sizeHints, 0, sizeof(sizeHints)); if (!view->resizable) { sizeHints.flags = PMinSize|PMaxSize; sizeHints.min_width = view->width; sizeHints.min_height = view->height; sizeHints.max_width = view->width; sizeHints.max_height = view->height; XSetNormalHints(impl->display, impl->win, &sizeHints); } else if (view->min_width > 0 && view->min_height > 0) { sizeHints.flags = PMinSize; sizeHints.min_width = view->min_width; sizeHints.min_height = view->min_height; XSetNormalHints(impl->display, impl->win, &sizeHints); } if (title) { XStoreName(impl->display, impl->win, title); } if (!view->parent) { Atom wmDelete = XInternAtom(impl->display, "WM_DELETE_WINDOW", True); XSetWMProtocols(impl->display, impl->win, &wmDelete, 1); } if (glXIsDirect(impl->display, impl->ctx)) { PUGL_LOG("DRI enabled (to disable, set LIBGL_ALWAYS_INDIRECT=1\n"); } else { PUGL_LOG("No DRI available\n"); } XFree(vi); return PUGL_SUCCESS; }
int main(void) { Display *display; Window window; //initialization for a window int screen; //which screen /* open connection with the server */ display = XOpenDisplay(NULL); if(display == NULL) { fprintf(stderr, "cannot open display\n"); return 0; } screen = DefaultScreen(display); /* set window size */ int width = 400; int height = 400; /* set window position */ int x = 0; int y = 0; /* border width in pixels */ int border_width = 0; /* create window */ window = XCreateSimpleWindow(display, RootWindow(display, screen), x, y, width, height, border_width, BlackPixel(display, screen), WhitePixel(display, screen)); /* create graph */ GC gc; XGCValues values; long valuemask = 0; gc = XCreateGC(display, window, valuemask, &values); //XSetBackground (display, gc, WhitePixel (display, screen)); XSetForeground (display, gc, BlackPixel (display, screen)); XSetBackground(display, gc, 0X0000FF00); XSetLineAttributes (display, gc, 1, LineSolid, CapRound, JoinRound); /* map(show) the window */ XMapWindow(display, window); XSync(display, 0); struct timespec timeStart, timeEnd; clock_gettime(CLOCK_REALTIME, &timeStart); /* draw points */ int* repeatsBuffer; Compl z, c; int repeats; double temp, lengthsq; int i, j; repeatsBuffer = (int*)malloc(sizeof(int) * width * height); #pragma omp parallel for num_threads(60) private(i,j,repeats,lengthsq,temp,z,c) schedule(static,10) for(i=0; i<width; i++) { for(j=0; j<height; j++) { z.real = 0.0; z.imag = 0.0; c.real = -2.0 + (double)i * (4.0/(double)width); c.imag = -2.0 + (double)j * (4.0/(double)height); repeats = 0; lengthsq = 0.0; while(repeats < 100000 && lengthsq < 4.0) { /* Theorem : If c belongs to M, then |Zn| <= 2. So Zn^2 <= 4 */ temp = z.real*z.real - z.imag*z.imag + c.real; z.imag = 2*z.real*z.imag + c.imag; z.real = temp; lengthsq = z.real*z.real + z.imag*z.imag; repeats++; } repeatsBuffer[i*width+j]=repeats; } } clock_gettime(CLOCK_REALTIME, &timeEnd); printf("Time Usage: %lf s\n", (double)(timeEnd.tv_sec - timeStart.tv_sec) + (double)(timeEnd.tv_nsec - timeStart.tv_nsec)/1e9); fflush(stdout); for(i = 0; i < width * height; i++){ XSetForeground (display, gc, 1024 * 1024 * (repeatsBuffer[i] % 256)); XDrawPoint (display, window, gc, i/width, i%width); } XFlush(display); free(repeatsBuffer); sleep(2); return 0; }
int main(int argc, char** argv) { Display* dpy = XOpenDisplay(NULL); if (dpy == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); } int s = DefaultScreen(dpy); Window win = XCreateSimpleWindow(dpy, RootWindow(dpy, s), 10, 10, 660, 200, 1, BlackPixel(dpy, s), WhitePixel(dpy, s)); XSelectInput(dpy, win, ExposureMask | KeyPressMask); XMapWindow(dpy, win); #if defined(__APPLE_CC__) XStoreName(dpy, win, "Geeks3D.com - X11 window under Mac OS X (Lion)"); #else XStoreName(dpy, win, "Geeks3D.com - X11 window under Linux (Mint 10)"); #endif Atom WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False); XSetWMProtocols(dpy, win, &WM_DELETE_WINDOW, 1); bool uname_ok = false; struct utsname sname; int ret = uname(&sname); if (ret != -1) { uname_ok = true; } XEvent e; while (1) { XNextEvent(dpy, &e); if (e.type == Expose) { int y_offset = 20; #if defined(__APPLE_CC__) const char* s1 = "X11 test app under Mac OS X Lion"; #else const char* s1 = "X11 test app under Linux"; #endif const char* s2 = "(C)2012 Geeks3D.com"; XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, s1, strlen(s1)); y_offset += 20; XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, s2, strlen(s2)); y_offset += 20; if (uname_ok) { char buf[256] = {0}; sprintf(buf, "System information:"); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 15; sprintf(buf, "- System: %s", sname.sysname); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 15; sprintf(buf, "- Release: %s", sname.release); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 15; sprintf(buf, "- Version: %s", sname.version); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 15; sprintf(buf, "- Machine: %s", sname.machine); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 20; } XWindowAttributes wa; XGetWindowAttributes(dpy, win, &wa); int width = wa.width; int height = wa.height; char buf[128]= {0}; sprintf(buf, "Current window size: %dx%d", width, height); XDrawString(dpy, win, DefaultGC(dpy, s), 10, y_offset, buf, strlen(buf)); y_offset += 20; } if (e.type == KeyPress) { char buf[128] = {0}; KeySym keysym; int len = XLookupString(&e.xkey, buf, sizeof buf, &keysym, NULL); if (keysym == XK_Escape) break; } if ((e.type == ClientMessage) && (static_cast<unsigned int>(e.xclient.data.l[0]) == WM_DELETE_WINDOW)) { break; } } XDestroyWindow(dpy, win); XCloseDisplay(dpy); return 0; }
void * winClipboardProc(void *pvNotUsed) { Atom atomClipboard, atomClipboardManager; int iReturn; HWND hwnd = NULL; int iConnectionNumber = 0; #ifdef HAS_DEVWINDOWS int fdMessageQueue = 0; #else struct timeval tvTimeout; #endif fd_set fdsRead; int iMaxDescriptor; Display *pDisplay = NULL; Window iWindow = None; int iRetries; Bool fUseUnicode; char szDisplay[512]; int iSelectError; ErrorF("winClipboardProc - Hello\n"); ++clipboardRestarts; /* Do we have Unicode support? */ g_fUnicodeSupport = winClipboardDetectUnicodeSupport(); /* Do we use Unicode clipboard? */ fUseUnicode = g_fUnicodeClipboard && g_fUnicodeSupport; /* Save the Unicode support flag in a global */ g_fUseUnicode = fUseUnicode; /* Allow multiple threads to access Xlib */ if (XInitThreads() == 0) { ErrorF("winClipboardProc - XInitThreads failed.\n"); goto winClipboardProc_Exit; } /* See if X supports the current locale */ if (XSupportsLocale() == False) { ErrorF("winClipboardProc - Warning: Locale not supported by X.\n"); } /* Set error handler */ XSetErrorHandler(winClipboardErrorHandler); g_winClipboardProcThread = pthread_self(); g_winClipboardOldIOErrorHandler = XSetIOErrorHandler(winClipboardIOErrorHandler); /* Set jump point for Error exits */ iReturn = setjmp(g_jmpEntry); /* Check if we should continue operations */ if (iReturn != WIN_JMP_ERROR_IO && iReturn != WIN_JMP_OKAY) { /* setjmp returned an unknown value, exit */ ErrorF("winClipboardProc - setjmp returned: %d exiting\n", iReturn); goto winClipboardProc_Exit; } else if (iReturn == WIN_JMP_ERROR_IO) { /* TODO: Cleanup the Win32 window and free any allocated memory */ ErrorF("winClipboardProc - setjmp returned for IO Error Handler.\n"); pthread_exit(NULL); } /* Use our generated cookie for authentication */ winSetAuthorization(); /* Initialize retry count */ iRetries = 0; /* Setup the display connection string x */ /* * NOTE: Always connect to screen 0 since we require that screen * numbers start at 0 and increase without gaps. We only need * to connect to one screen on the display to get events * for all screens on the display. That is why there is only * one clipboard client thread. */ snprintf(szDisplay, 512, "127.0.0.1:%s.0", display); /* Print the display connection string */ ErrorF("winClipboardProc - DISPLAY=%s\n", szDisplay); /* Open the X display */ do { pDisplay = XOpenDisplay(szDisplay); if (pDisplay == NULL) { ErrorF("winClipboardProc - Could not open display, " "try: %d, sleeping: %d\n", iRetries + 1, WIN_CONNECT_DELAY); ++iRetries; sleep(WIN_CONNECT_DELAY); continue; } else break; } while (pDisplay == NULL && iRetries < WIN_CONNECT_RETRIES); /* Make sure that the display opened */ if (pDisplay == NULL) { ErrorF("winClipboardProc - Failed opening the display, giving up\n"); goto winClipboardProc_Done; } /* Save the display in the screen privates */ g_pClipboardDisplay = pDisplay; ErrorF("winClipboardProc - XOpenDisplay () returned and " "successfully opened the display.\n"); /* Get our connection number */ iConnectionNumber = ConnectionNumber(pDisplay); #ifdef HAS_DEVWINDOWS /* Open a file descriptor for the windows message queue */ fdMessageQueue = open(WIN_MSG_QUEUE_FNAME, O_RDONLY); if (fdMessageQueue == -1) { ErrorF("winClipboardProc - Failed opening %s\n", WIN_MSG_QUEUE_FNAME); goto winClipboardProc_Done; } /* Find max of our file descriptors */ iMaxDescriptor = max(fdMessageQueue, iConnectionNumber) + 1; #else iMaxDescriptor = iConnectionNumber + 1; #endif /* Create atoms */ atomClipboard = XInternAtom(pDisplay, "CLIPBOARD", False); atomClipboardManager = XInternAtom(pDisplay, "CLIPBOARD_MANAGER", False); /* Create a messaging window */ iWindow = XCreateSimpleWindow(pDisplay, DefaultRootWindow(pDisplay), 1, 1, 500, 500, 0, BlackPixel(pDisplay, 0), BlackPixel(pDisplay, 0)); if (iWindow == 0) { ErrorF("winClipboardProc - Could not create an X window.\n"); goto winClipboardProc_Done; } XStoreName(pDisplay, iWindow, "xwinclip"); /* Select event types to watch */ if (XSelectInput(pDisplay, iWindow, PropertyChangeMask) == BadWindow) ErrorF("winClipboardProc - XSelectInput generated BadWindow " "on messaging window\n"); /* Save the window in the screen privates */ g_iClipboardWindow = iWindow; /* Create Windows messaging window */ hwnd = winClipboardCreateMessagingWindow(); /* Save copy of HWND in screen privates */ g_hwndClipboard = hwnd; /* Assert ownership of selections if Win32 clipboard is owned */ if (NULL != GetClipboardOwner()) { /* PRIMARY */ iReturn = XSetSelectionOwner(pDisplay, XA_PRIMARY, iWindow, CurrentTime); if (iReturn == BadAtom || iReturn == BadWindow || XGetSelectionOwner(pDisplay, XA_PRIMARY) != iWindow) { ErrorF("winClipboardProc - Could not set PRIMARY owner\n"); goto winClipboardProc_Done; } /* CLIPBOARD */ iReturn = XSetSelectionOwner(pDisplay, atomClipboard, iWindow, CurrentTime); if (iReturn == BadAtom || iReturn == BadWindow || XGetSelectionOwner(pDisplay, atomClipboard) != iWindow) { ErrorF("winClipboardProc - Could not set CLIPBOARD owner\n"); goto winClipboardProc_Done; } } /* Pre-flush X events */ /* * NOTE: Apparently you'll freeze if you don't do this, * because there may be events in local data structures * already. */ winClipboardFlushXEvents(hwnd, iWindow, pDisplay, fUseUnicode); /* Pre-flush Windows messages */ if (!winClipboardFlushWindowsMessageQueue(hwnd)) return 0; /* Signal that the clipboard client has started */ g_fClipboardStarted = TRUE; /* Loop for X events */ while (1) { /* Setup the file descriptor set */ /* * NOTE: You have to do this before every call to select * because select modifies the mask to indicate * which descriptors are ready. */ FD_ZERO(&fdsRead); FD_SET(iConnectionNumber, &fdsRead); #ifdef HAS_DEVWINDOWS FD_SET(fdMessageQueue, &fdsRead); #else tvTimeout.tv_sec = 0; tvTimeout.tv_usec = 100; #endif /* Wait for a Windows event or an X event */ iReturn = select(iMaxDescriptor, /* Highest fds number */ &fdsRead, /* Read mask */ NULL, /* No write mask */ NULL, /* No exception mask */ #ifdef HAS_DEVWINDOWS NULL /* No timeout */ #else &tvTimeout /* Set timeout */ #endif ); #ifndef HAS_WINSOCK iSelectError = errno; #else iSelectError = WSAGetLastError(); #endif if (iReturn < 0) { #ifndef HAS_WINSOCK if (iSelectError == EINTR) #else if (iSelectError == WSAEINTR) #endif continue; ErrorF("winClipboardProc - Call to select () failed: %d. " "Bailing.\n", iReturn); break; } /* Branch on which descriptor became active */ if (FD_ISSET(iConnectionNumber, &fdsRead)) { /* Process X events */ /* Exit when we see that server is shutting down */ iReturn = winClipboardFlushXEvents(hwnd, iWindow, pDisplay, fUseUnicode); if (WIN_XEVENTS_SHUTDOWN == iReturn) { ErrorF("winClipboardProc - winClipboardFlushXEvents " "trapped shutdown event, exiting main loop.\n"); break; } } #ifdef HAS_DEVWINDOWS /* Check for Windows event ready */ if (FD_ISSET(fdMessageQueue, &fdsRead)) #else if (1) #endif { /* Process Windows messages */ if (!winClipboardFlushWindowsMessageQueue(hwnd)) { ErrorF("winClipboardProc - " "winClipboardFlushWindowsMessageQueue trapped " "WM_QUIT message, exiting main loop.\n"); break; } } } winClipboardProc_Exit: /* disable the clipboard, which means the thread will die */ g_fClipboard = FALSE; winClipboardProc_Done: /* Close our Windows window */ if (g_hwndClipboard) { /* Destroy the Window window (hwnd) */ winDebug("winClipboardProc - Destroy Windows window\n"); PostMessage(g_hwndClipboard, WM_DESTROY, 0, 0); winClipboardFlushWindowsMessageQueue(g_hwndClipboard); } /* Close our X window */ if (pDisplay && iWindow) { iReturn = XDestroyWindow(pDisplay, iWindow); if (iReturn == BadWindow) ErrorF("winClipboardProc - XDestroyWindow returned BadWindow.\n"); else ErrorF("winClipboardProc - XDestroyWindow succeeded.\n"); } #ifdef HAS_DEVWINDOWS /* Close our Win32 message handle */ if (fdMessageQueue) close(fdMessageQueue); #endif #if 0 /* * FIXME: XCloseDisplay hangs if we call it, as of 2004/03/26. The * XSync and XSelectInput calls did not help. */ /* Discard any remaining events */ XSync(pDisplay, TRUE); /* Select event types to watch */ XSelectInput(pDisplay, DefaultRootWindow(pDisplay), None); /* Close our X display */ if (pDisplay) { XCloseDisplay(pDisplay); } #endif /* global clipboard variable reset */ g_fClipboardLaunched = FALSE; g_fClipboardStarted = FALSE; g_iClipboardWindow = None; g_pClipboardDisplay = NULL; g_hwndClipboard = NULL; /* checking if we need to restart */ if (clipboardRestarts >= WIN_CLIPBOARD_RETRIES) { /* terminates clipboard thread but the main server still lives */ ErrorF ("winClipboardProc - the clipboard thread has restarted %d times and seems to be unstable, disabling clipboard integration\n", clipboardRestarts); g_fClipboard = FALSE; return; } if (g_fClipboard) { sleep(WIN_CLIPBOARD_DELAY); ErrorF("winClipboardProc - trying to restart clipboard thread \n"); /* Create the clipboard client thread */ if (!winInitClipboard()) { ErrorF("winClipboardProc - winClipboardInit failed.\n"); return; } winDebug("winClipboardProc - winInitClipboard returned.\n"); /* Flag that clipboard client has been launched */ g_fClipboardLaunched = TRUE; } else { ErrorF("winClipboardProc - Clipboard disabled - Exit from server \n"); /* clipboard thread has exited, stop server as well */ kill(getpid(), SIGTERM); } return NULL; }
void windrawstring(pdfapp_t *app, int x, int y, char *s) { XSetForeground(xdpy, xgc, BlackPixel(xdpy, DefaultScreen(xdpy))); XDrawString(xdpy, xwin, xgc, x, y, s, strlen(s)); }
/* ** GLW_SetMode */ int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen ) { int attrib[] = { GLX_RGBA, // 0 GLX_RED_SIZE, 4, // 1, 2 GLX_GREEN_SIZE, 4, // 3, 4 GLX_BLUE_SIZE, 4, // 5, 6 GLX_DOUBLEBUFFER, // 7 GLX_DEPTH_SIZE, 1, // 8, 9 GLX_STENCIL_SIZE, 1, // 10, 11 None }; // these match in the array #define ATTR_RED_IDX 2 #define ATTR_GREEN_IDX 4 #define ATTR_BLUE_IDX 6 #define ATTR_DEPTH_IDX 9 #define ATTR_STENCIL_IDX 11 Window root; XVisualInfo *visinfo; XSetWindowAttributes attr; XSizeHints sizehints; unsigned long mask; int colorbits, depthbits, stencilbits; int tcolorbits, tdepthbits, tstencilbits; int dga_MajorVersion, dga_MinorVersion; int actualWidth, actualHeight; int i; const char* glstring; // bk001130 - from cvs1.17 (mkv) CL_RefPrintf( PRINT_ALL, "Initializing OpenGL display\n"); CL_RefPrintf (PRINT_ALL, "...setting mode %d:", mode ); if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) ) { CL_RefPrintf( PRINT_ALL, " invalid mode\n" ); return RSERR_INVALID_MODE; } CL_RefPrintf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight); if (!(dpy = XOpenDisplay(NULL))) { fprintf(stderr, "Error couldn't open the X display\n"); return RSERR_INVALID_MODE; } scrnum = DefaultScreen(dpy); root = RootWindow(dpy, scrnum); actualWidth = glConfig.vidWidth; actualHeight = glConfig.vidHeight; // Get video mode list if (!XF86VidModeQueryVersion(dpy, &vidmode_MajorVersion, &vidmode_MinorVersion)) { vidmode_ext = qfalse; } else { CL_RefPrintf(PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n", vidmode_MajorVersion, vidmode_MinorVersion); vidmode_ext = qtrue; } // Check for DGA dga_MajorVersion = 0, dga_MinorVersion = 0; if (in_dgamouse->value) { if (!XF86DGAQueryVersion(dpy, &dga_MajorVersion, &dga_MinorVersion)) { // unable to query, probalby not supported CL_RefPrintf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" ); Cvar_Set( "in_dgamouse", "0" ); } else { CL_RefPrintf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n", dga_MajorVersion, dga_MinorVersion); } } if (vidmode_ext) { int best_fit, best_dist, dist, x, y; XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes); // Are we going fullscreen? If so, let's change video mode if (fullscreen) { best_dist = 9999999; best_fit = -1; for (i = 0; i < num_vidmodes; i++) { if (glConfig.vidWidth > vidmodes[i]->hdisplay || glConfig.vidHeight > vidmodes[i]->vdisplay) continue; x = glConfig.vidWidth - vidmodes[i]->hdisplay; y = glConfig.vidHeight - vidmodes[i]->vdisplay; dist = (x * x) + (y * y); if (dist < best_dist) { best_dist = dist; best_fit = i; } } if (best_fit != -1) { actualWidth = vidmodes[best_fit]->hdisplay; actualHeight = vidmodes[best_fit]->vdisplay; // change to the mode XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]); vidmode_active = qtrue; // Move the viewport to top left XF86VidModeSetViewPort(dpy, scrnum, 0, 0); CL_RefPrintf(PRINT_ALL, "XFree86-VidModeExtension Activated at %dx%d\n", actualWidth, actualHeight); } else { fullscreen = 0; CL_RefPrintf(PRINT_ALL, "XFree86-VidModeExtension: No acceptable modes found\n"); } } else { CL_RefPrintf(PRINT_ALL, "XFree86-VidModeExtension: Ignored on non-fullscreen/Voodoo\n"); } } if (!r_colorbits->value) colorbits = 24; else colorbits = r_colorbits->value; if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) ) colorbits = 16; if (!r_depthbits->value) depthbits = 24; else depthbits = r_depthbits->value; stencilbits = r_stencilbits->value; for (i = 0; i < 16; i++) { // 0 - default // 1 - minus colorbits // 2 - minus depthbits // 3 - minus stencil if ((i % 4) == 0 && i) { // one pass, reduce switch (i / 4) { case 2 : if (colorbits == 24) colorbits = 16; break; case 1 : if (depthbits == 24) depthbits = 16; else if (depthbits == 16) depthbits = 8; case 3 : if (stencilbits == 24) stencilbits = 16; else if (stencilbits == 16) stencilbits = 8; } } tcolorbits = colorbits; tdepthbits = depthbits; tstencilbits = stencilbits; if ((i % 4) == 3) { // reduce colorbits if (tcolorbits == 24) tcolorbits = 16; } if ((i % 4) == 2) { // reduce depthbits if (tdepthbits == 24) tdepthbits = 16; else if (tdepthbits == 16) tdepthbits = 8; } if ((i % 4) == 1) { // reduce stencilbits if (tstencilbits == 24) tstencilbits = 16; else if (tstencilbits == 16) tstencilbits = 8; else tstencilbits = 0; } if (tcolorbits == 24) { attrib[ATTR_RED_IDX] = 8; attrib[ATTR_GREEN_IDX] = 8; attrib[ATTR_BLUE_IDX] = 8; } else { // must be 16 bit attrib[ATTR_RED_IDX] = 4; attrib[ATTR_GREEN_IDX] = 4; attrib[ATTR_BLUE_IDX] = 4; } attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth attrib[ATTR_STENCIL_IDX] = tstencilbits; visinfo = qglXChooseVisual(dpy, scrnum, attrib); if (!visinfo) { continue; } CL_RefPrintf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n", attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX], attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]); glConfig.colorBits = tcolorbits; glConfig.depthBits = tdepthbits; glConfig.stencilBits = tstencilbits; break; } if (!visinfo) { CL_RefPrintf( PRINT_ALL, "Couldn't get a visual\n" ); return RSERR_INVALID_MODE; } /* window attributes */ attr.background_pixel = BlackPixel(dpy, scrnum); attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); attr.event_mask = X_MASK; if (vidmode_active) { mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | CWEventMask | CWOverrideRedirect; attr.override_redirect = True; attr.backing_store = NotUseful; attr.save_under = False; } else mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow(dpy, root, 0, 0, actualWidth, actualHeight, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr); XStoreName( dpy, win, WINDOW_CLASS_NAME ); /* GH: Don't let the window be resized */ sizehints.flags = PMinSize | PMaxSize; sizehints.min_width = sizehints.max_width = actualWidth; sizehints.min_height = sizehints.max_height = actualHeight; XSetWMNormalHints( dpy, win, &sizehints ); XMapWindow( dpy, win ); if (vidmode_active) XMoveWindow(dpy, win, 0, 0); XFlush(dpy); XSync(dpy,False); // bk001130 - from cvs1.17 (mkv) ctx = qglXCreateContext(dpy, visinfo, NULL, True); XSync(dpy,False); // bk001130 - from cvs1.17 (mkv) /* GH: Free the visinfo after we're done with it */ XFree( visinfo ); qglXMakeCurrent(dpy, win, ctx); // bk001130 - from cvs1.17 (mkv) glstring = (char *)qglGetString (GL_RENDERER); CL_RefPrintf( PRINT_ALL, "GL_RENDERER: %s\n", glstring ); // bk010122 - new software token (Indirect) if ( !Q_stricmp( glstring, "Mesa X11") || !Q_stricmp( glstring, "Mesa GLX Indirect") ) { if ( !r_allowSoftwareGL->integer ) { CL_RefPrintf( PRINT_ALL, "\n\n***********************************************************\n" ); CL_RefPrintf( PRINT_ALL, " You are using software Mesa (no hardware acceleration)! \n" ); CL_RefPrintf( PRINT_ALL, " Driver DLL used: %s\n", drivername ); CL_RefPrintf( PRINT_ALL, " If this is intentional, add\n" ); CL_RefPrintf( PRINT_ALL, " \"+set r_allowSoftwareGL 1\"\n" ); CL_RefPrintf( PRINT_ALL, " to the command line when starting the game.\n" ); CL_RefPrintf( PRINT_ALL, "***********************************************************\n"); GLimp_Shutdown( ); return RSERR_INVALID_MODE; } else { CL_RefPrintf( PRINT_ALL, "...using software Mesa (r_allowSoftwareGL==1).\n" ); } } return RSERR_OK; }
// real construction (Init() must have been called before!) bool wxWindowX11::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name) { wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") ); CreateBase(parent, id, pos, size, style, wxDefaultValidator, name); parent->AddChild(this); Display *xdisplay = (Display*) wxGlobalDisplay(); int xscreen = DefaultScreen( xdisplay ); Visual *xvisual = DefaultVisual( xdisplay, xscreen ); Colormap cm = DefaultColormap( xdisplay, xscreen ); m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); m_backgroundColour.CalcPixel( (WXColormap) cm ); m_foregroundColour = *wxBLACK; m_foregroundColour.CalcPixel( (WXColormap) cm ); Window xparent = (Window) parent->GetClientAreaWindow(); // Add window's own scrollbars to main window, not to client window if (parent->GetInsertIntoMain()) { // wxLogDebug( "Inserted into main: %s", GetName().c_str() ); xparent = (Window) parent->GetMainWindow(); } // Size (not including the border) must be nonzero (or a Value error results)! // Note: The Xlib manual doesn't mention this restriction of XCreateWindow. wxSize size2(size); if (size2.x <= 0) size2.x = 20; if (size2.y <= 0) size2.y = 20; wxPoint pos2(pos); if (pos2.x == -1) pos2.x = 0; if (pos2.y == -1) pos2.y = 0; #if wxUSE_TWO_WINDOWS bool need_two_windows = ((( wxSUNKEN_BORDER | wxRAISED_BORDER | wxSIMPLE_BORDER | wxHSCROLL | wxVSCROLL ) & m_windowStyle) != 0); #else bool need_two_windows = FALSE; #endif #if wxUSE_NANOX long xattributes = 0; #else XSetWindowAttributes xattributes; long xattributes_mask = 0; xattributes_mask |= CWBackPixel; xattributes.background_pixel = m_backgroundColour.GetPixel(); xattributes_mask |= CWBorderPixel; xattributes.border_pixel = BlackPixel( xdisplay, xscreen ); xattributes_mask |= CWEventMask; #endif if (need_two_windows) { #if wxUSE_NANOX long backColor, foreColor; backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue()); foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue()); Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y, 0, 0, InputOutput, xvisual, backColor, foreColor); XSelectInput( xdisplay, xwindow, GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask | PropertyChangeMask ); #else // Normal X11 xattributes.event_mask = ExposureMask | StructureNotifyMask | ColormapChangeMask; Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y, 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes ); #endif XSetWindowBackgroundPixmap( xdisplay, xwindow, None ); m_mainWindow = (WXWindow) xwindow; wxAddWindowToTable( xwindow, (wxWindow*) this ); XMapWindow( xdisplay, xwindow ); #if !wxUSE_NANOX xattributes.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask | PropertyChangeMask | VisibilityChangeMask ; if (!HasFlag( wxFULL_REPAINT_ON_RESIZE )) { xattributes_mask |= CWBitGravity; xattributes.bit_gravity = StaticGravity; } #endif if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER)) { pos2.x = 2; pos2.y = 2; size2.x -= 4; size2.y -= 4; } else if (HasFlag( wxSIMPLE_BORDER )) { pos2.x = 1; pos2.y = 1; size2.x -= 2; size2.y -= 2; } else { pos2.x = 0; pos2.y = 0; } // Make again sure the size is nonzero. if (size2.x <= 0) size2.x = 1; if (size2.y <= 0) size2.y = 1; #if wxUSE_NANOX backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue()); foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue()); xwindow = XCreateWindowWithColor( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y, 0, 0, InputOutput, xvisual, backColor, foreColor); XSelectInput( xdisplay, xwindow, GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask | PropertyChangeMask ); #else xwindow = XCreateWindow( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y, 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes ); #endif XSetWindowBackgroundPixmap( xdisplay, xwindow, None ); m_clientWindow = (WXWindow) xwindow; wxAddClientWindowToTable( xwindow, (wxWindow*) this ); XMapWindow( xdisplay, xwindow ); } else { // wxLogDebug( "No two windows needed %s", GetName().c_str() ); #if wxUSE_NANOX long backColor, foreColor; backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue()); foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue()); Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y, 0, 0, InputOutput, xvisual, backColor, foreColor); XSelectInput( xdisplay, xwindow, GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask | PropertyChangeMask ); #else xattributes.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask | PropertyChangeMask | VisibilityChangeMask ; if (!HasFlag( wxFULL_REPAINT_ON_RESIZE )) { xattributes_mask |= CWBitGravity; xattributes.bit_gravity = NorthWestGravity; } Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y, 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes ); #endif XSetWindowBackgroundPixmap( xdisplay, xwindow, None ); m_mainWindow = (WXWindow) xwindow; m_clientWindow = m_mainWindow; wxAddWindowToTable( xwindow, (wxWindow*) this ); XMapWindow( xdisplay, xwindow ); } // Is a subwindow, so map immediately m_isShown = TRUE; // Without this, the cursor may not be restored properly (e.g. in splitter // sample). SetCursor(*wxSTANDARD_CURSOR); SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); // Don't call this, it can have nasty repercussions for composite controls, // for example // SetSize(pos.x, pos.y, size.x, size.y); return TRUE; }
int main(int argc, char **argv) { FILE *fp; int x_1,y_1,x_2,y_2,x_3,y_3; char a; int i,j; int outside; int ButtonPressed = 0; int temp_x, temp_y; pixel_count = 0; for(i=0;i<302;i++) { for(j=0;j<302;j++) { cost[i][j] = 9999; } } if( (display_ptr = XOpenDisplay(display_name)) == NULL ) { printf("Could not open display. \n"); exit(-1);} printf("Connected to X server %s\n", XDisplayName(display_name) ); screen_num = DefaultScreen( display_ptr ); screen_ptr = DefaultScreenOfDisplay( display_ptr ); color_map = XDefaultColormap( display_ptr, screen_num ); display_width = DisplayWidth( display_ptr, screen_num ); display_height = DisplayHeight( display_ptr, screen_num ); printf("Width %d, Height %d, Screen Number %d\n", display_width, display_height, screen_num); border_width = 10; win_x = 0; win_y = 0; win_width = display_width; win_height = display_height; win= XCreateSimpleWindow( display_ptr, RootWindow( display_ptr, screen_num), win_x, win_y, win_width, win_height, border_width, BlackPixel(display_ptr, screen_num), WhitePixel(display_ptr, screen_num) ); size_hints = XAllocSizeHints(); wm_hints = XAllocWMHints(); class_hints = XAllocClassHint(); if( size_hints == NULL || wm_hints == NULL || class_hints == NULL ) { printf("Error allocating memory for hints. \n"); exit(-1);} size_hints -> flags = PPosition | PSize | PMinSize ; size_hints -> min_width = 60; size_hints -> min_height = 60; XStringListToTextProperty( &win_name_string,1,&win_name); XStringListToTextProperty( &icon_name_string,1,&icon_name); wm_hints -> flags = StateHint | InputHint ; wm_hints -> initial_state = NormalState; wm_hints -> input = False; class_hints -> res_name = "x_use_example"; class_hints -> res_class = "examples"; XSetWMProperties( display_ptr, win, &win_name, &icon_name, argv, argc, size_hints, wm_hints, class_hints ); XSelectInput( display_ptr, win, ExposureMask | StructureNotifyMask | ButtonPressMask ); XMapWindow( display_ptr, win ); XFlush(display_ptr); gc_red = XCreateGC( display_ptr, win, valuemask, &gc_red_values); XSetLineAttributes( display_ptr, gc_red, 3, LineSolid, CapRound, JoinRound); if( XAllocNamedColor( display_ptr, color_map, "red", &tmp_color1, &tmp_color2 ) == 0 ) {printf("failed to get color red\n"); exit(-1);} else XSetForeground( display_ptr, gc_red, tmp_color1.pixel ); gc_black = XCreateGC( display_ptr, win, valuemask, &gc_black_values); XSetLineAttributes(display_ptr, gc_black, 3, LineSolid,CapRound, JoinRound); if( XAllocNamedColor( display_ptr, color_map, "black", &tmp_color1, &tmp_color2 ) == 0 ) {printf("failed to get color black\n"); exit(-1);} else XSetForeground( display_ptr, gc_black, tmp_color1.pixel ); gc_blue = XCreateGC( display_ptr, win, valuemask, &gc_blue_values); XSetLineAttributes(display_ptr, gc_blue, 3, LineSolid,CapRound, JoinRound); if( XAllocNamedColor( display_ptr, color_map, "blue", &tmp_color1, &tmp_color2 ) == 0 ) {printf("failed to get blue yellow\n"); exit(-1);} else XSetForeground( display_ptr, gc_blue, tmp_color1.pixel ); gc_white = XCreateGC( display_ptr, win, valuemask, &gc_white_values); XSetLineAttributes(display_ptr, gc_white, 3, LineSolid,CapRound, JoinRound); if( XAllocNamedColor( display_ptr, color_map, "white", &tmp_color1, &tmp_color2 ) == 0 ) {printf("failed to get color white\n"); exit(-1);} else XSetForeground( display_ptr, gc_white, tmp_color1.pixel ); if ( argc != 2 ) { printf( "Usage: %s filename.extension \n", argv[0] ); exit(-1); } fp = fopen(argv[1], "r"); if (fp == NULL) { fprintf(stderr, "Can't open file %s!\n", argv[1]); printf( "Usage: %s filename.extension or Check whether file is present or not\n", argv[0] ); exit(-1); } triangle_count = 0; while (fscanf(fp, "%c %c%d%c%d%c %c%d%c%d%c %c%d%c%d%c%c", &a,&a,&x_1,&a,&y_1,&a,&a,&x_2,&a,&y_2,&a,&a,&x_3,&a,&y_3,&a,&a) != EOF) { if(get_x_min(x_1,x_2,x_3) >= 0 && get_y_min(y_1,y_2,y_3) >= 0 && get_x_max(x_1,x_2,x_3) <= display_width - 300 && get_y_max(y_1,y_2,y_3) <= display_height - 200) { t[triangle_count].x1 = x_1; t[triangle_count].x2 = x_2; t[triangle_count].x3 = x_3; t[triangle_count].y1 = y_1; t[triangle_count].y2 = y_2; t[triangle_count].y3 = y_3; triangle_count++; } } x_min = t[0].x1; x_max = x_min; y_min = t[0].y1; y_max = y_min; for(i=0;i<triangle_count;i++) { if(x_min > t[i].x1) x_min = t[i].x1; if(x_min > t[i].x2) x_min = t[i].x2; if(x_min > t[i].x2) x_min = t[i].x3; if(y_min > t[i].y1) y_min = t[i].y1; if(y_min > t[i].y2) y_min = t[i].y2; if(y_min > t[i].y3) y_min = t[i].y3; if(x_max < t[i].x1) x_max = t[i].x1; if(x_max < t[i].x2) x_max = t[i].x2; if(x_max < t[i].x3) x_max = t[i].x3; if(y_max < t[i].y1) y_max = t[i].y1; if(y_max < t[i].y2) y_max = t[i].y2; if(y_max < t[i].y3) y_max = t[i].y3; } x_center = win_width / 2; y_center = win_height / 2; x_gap = x_max - x_min; y_gap = y_max - y_min; x_start = x_center - x_gap/2 - 50; y_start = y_center - y_gap/2 - 50; x_end = x_start + x_gap + 100; y_end = y_start + y_gap + 100; rec_width = x_end - x_start; rec_height = y_end - y_start; for(i=0;i<triangle_count;i++) { t[i].x1 = t[i].x1 + x_start + 50 - x_min; t[i].x2 = t[i].x2 + x_start + 50 - x_min; t[i].x3 = t[i].x3 + x_start + 50 - x_min; t[i].y1 = t[i].y1 + y_start + 50 - y_min; t[i].y2 = t[i].y2 + y_start + 50 - y_min; t[i].y3 = t[i].y3 + y_start + 50 - y_min; } for(i=0;i<triangle_count;i++) { t[i].point_1_inside_triangle = 0; t[i].point_2_inside_triangle = 0; t[i].point_3_inside_triangle = 0; } for(i=0;i<triangle_count;i++) { for(j=0;j<triangle_count;j++) { if(j!=i) { if(point_in_triangle(t[i].x1,t[i].y1,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1) { t[i].point_1_inside_triangle = 1; } if(point_in_triangle(t[i].x2,t[i].y2,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1) { t[i].point_2_inside_triangle = 1; } if(point_in_triangle(t[i].x3,t[i].y3,t[j].x1,t[j].y1,t[j].x2,t[j].y2,t[j].x3,t[j].y3)==1) { t[i].point_3_inside_triangle = 1; } } } } while(1) { XNextEvent( display_ptr, &report ); switch( report.type ) { case Expose: for(i=0;i<triangle_count;i++) { XDrawLine(display_ptr, win, gc_black, t[i].x1, t[i].y1, t[i].x2, t[i].y2); XDrawLine(display_ptr, win, gc_black, t[i].x2, t[i].y2, t[i].x3, t[i].y3); XDrawLine(display_ptr, win, gc_black, t[i].x3, t[i].y3, t[i].x1, t[i].y1); } XDrawRectangle(display_ptr, win, gc_black, x_start, y_start, rec_width, rec_height ); break; case ConfigureNotify: win_width = report.xconfigure.width; win_height = report.xconfigure.height; break; case ButtonPress: { int x, y; x = report.xbutton.x; y = report.xbutton.y; if (report.xbutton.button == Button1 ) { outside = 0; if(x <= x_start || y <= y_start || x >= x_end || y >= y_end) { outside = 1; } for(i=0;i<triangle_count;i++) { if(point_in_triangle(x,y,t[i].x1,t[i].y1,t[i].x2,t[i].y2,t[i].x3,t[i].y3)==1) { outside = 1; break; } } if(outside == 0) { ButtonPressed++; if(ButtonPressed == 1) { temp_x = x; temp_y = y; pixel_count = 0; XFillArc( display_ptr, win, gc_red, x - win_height/150, y - win_height/150, win_height/100, win_height/100, 0, 360*64); pixel[pixel_count].name = pixel_count; pixel[pixel_count].x = x; pixel[pixel_count].y = y; pixel_count++; } else if(ButtonPressed == 2) { if(temp_x == x && temp_y == y) { ButtonPressed = 1; break; } XFillArc( display_ptr, win, gc_red, x - win_height/150, y - win_height/150, win_height/100, win_height/100, 0, 360*64); for(i=0;i<triangle_count;i++) { if(t[i].point_1_inside_triangle != 1) { pixel[pixel_count].name = pixel_count; pixel[pixel_count].x = t[i].x1; pixel[pixel_count].y = t[i].y1; pixel_count++; } if(t[i].point_2_inside_triangle != 1) { pixel[pixel_count].name = pixel_count; pixel[pixel_count].x = t[i].x2; pixel[pixel_count].y = t[i].y2; pixel_count++; } if(t[i].point_3_inside_triangle != 1) { pixel[pixel_count].name = pixel_count; pixel[pixel_count].x = t[i].x3; pixel[pixel_count].y = t[i].y3; pixel_count++; } } pixel[pixel_count].name = pixel_count; pixel[pixel_count].x = x; pixel[pixel_count].y = y; pixel_count++; for(i=0;i<pixel_count-1;i++) { for(j=i+1;j<pixel_count;j++) { if(can_see(pixel[i].x,pixel[i].y,pixel[j].x,pixel[j].y)==1) { cost[pixel[i].name][pixel[j].name] = cost[pixel[j].name][pixel[i].name] = eculidian_dist(pixel[i].x,pixel[i].y,pixel[j].x,pixel[j].y); } } } dijsktra(pixel[0].name, pixel[pixel_count-1].name); } else { clear_cost(); expose(); ButtonPressed = 0; } } } else { XFlush(display_ptr); XCloseDisplay(display_ptr); exit(0); } } break; default: break; } } exit(0); }
unsigned long QXlibScreen::blackPixel() { return BlackPixel(mDisplay->nativeDisplay(), mScreen); }
void xskin_start_interface( int pipe_in ) { int xskin_sc; XEvent xskin_e; XSetWindowAttributes xskin_attr; XSizeHints xskin_hint; XClassHint xskin_chint; XTextProperty ct; char *namlist[2]; /* setup window */ xskin_d = XOpenDisplay( NULL ); xskin_sc = DefaultScreen( xskin_d ); xskin_r = RootWindow( xskin_d, xskin_sc ); xskin_gc = DefaultGC( xskin_d, xskin_sc ); xskin_vis = DefaultVisual( xskin_d, xskin_sc ); xskin_depth = DefaultDepth( xskin_d, xskin_sc ); xskin_w = XCreateSimpleWindow( xskin_d, xskin_r, 0, 0, skin_width, skin_height, 0, WhitePixel( xskin_d, xskin_sc ), BlackPixel( xskin_d, xskin_sc ) ); xskin_attr.backing_store = True; xskin_attr.override_redirect = False; XChangeWindowAttributes( xskin_d, xskin_w, CWBackingStore|CWOverrideRedirect, &xskin_attr ); XSelectInput( xskin_d, xskin_w, KeyPressMask|ExposureMask| EnterWindowMask|LeaveWindowMask| ButtonPressMask|ButtonReleaseMask| Button1MotionMask ); xskin_hint.flags = USSize | PMinSize | PMaxSize | USPosition; xskin_hint.width = xskin_hint.min_width = xskin_hint.max_width = skin_width; xskin_hint.height = xskin_hint.min_height = xskin_hint.max_height = skin_height; XSetNormalHints( xskin_d, xskin_w, &xskin_hint ); xskin_chint.res_name = XSKIN_RES_NAME; xskin_chint.res_class = XSKIN_RES_CLASS; XSetClassHint( xskin_d, xskin_w, &xskin_chint ); namlist[0]=(char *)safe_malloc(strlen(XSKIN_WINDOW_NAME)+1); strcpy( namlist[0], XSKIN_WINDOW_NAME ); XmbTextListToTextProperty( xskin_d, namlist, 1, XCompoundTextStyle, &ct ); XSetWMName( xskin_d, xskin_w, &ct ); XSetWMIconName( xskin_d, xskin_w, &ct ); free(namlist[0]); /* setup pixmaps */ if ( load_skins()!=0 ) goto finish; XSetWindowBackgroundPixmap( xskin_d, xskin_w, xskin_back ); XClearWindow( xskin_d, xskin_w ); XMapWindow( xskin_d, xskin_w ); while( 1 ) { XNextEvent( xskin_d, &xskin_e ); if ( xskin_e.type == Expose ) break; } fshuf=0; frep=0; fequ=1; fpll=1; fplay=0; fpause=0; fremain=0; play_val=1; vol_val=50; last_current_time=0; total_time=0; speana_buf = NULL; strcpy( last_text, "welcome to timidity" ); install_sighandler(); repaint(); ts_spectrum( -1, speana_buf ); XFlush(xskin_d); xskin_jobs( pipe_in ); /* tskin main jobs */ finish: signal_vector(0); /* finish */ }
unsigned long XApplication::GetBlackColor() const { return BlackPixel(this->display, this->screen); }
void WindowDevice::WINOPEN(const char *_title, int _xLoc, int _yLoc, int _width, int _height) { // set the WindowDevices title, height, wdth, xLoc and yLoc strcpy(title, _title); height = _height; width = _width; xLoc = _xLoc; yLoc = _yLoc; #ifdef _UNIX if (winOpen == 0) { // we must close the old window XFreeGC(theDisplay, theGC); XDestroyWindow(theDisplay, theWindow); } // define the position and size of the window - only hints hints.x = _xLoc; hints.y = _yLoc; hints.width = _width; hints.height = _height; hints.flags = PPosition | PSize; // set the defualt foreground and background colors XVisualInfo visual; visual.visual = 0; int depth = DefaultDepth(theDisplay, theScreen); if (background == 0) { if (XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual) == 0) { foreground = BlackPixel(theDisplay, theScreen); background = WhitePixel(theDisplay, theScreen); } else { foreground = 0; background = 255; } } // now open a window theWindow = XCreateSimpleWindow(theDisplay,RootWindow(theDisplay,0), hints.x, hints.y, hints.width,hints.height,4, foreground, background); if (theWindow == 0) { opserr << "WindowDevice::WINOPEN() - could not open a window\n"; exit(-1); } XSetStandardProperties(theDisplay, theWindow, title, title, None, 0, 0, &hints); // create a graphical context theGC = XCreateGC(theDisplay, theWindow, 0, 0); // if we were unable to get space for our colors // we must create and use our own colormap if (colorFlag == 3 ) { // create the colormap if the 1st window if (numWindowDevice == 1) { int fail = false; // XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual); if (XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual) == 0) { opserr << "WindowDevice::initX11() - could not get a visual for PseudoColor\n"; opserr << "Colors diplayed will be all over the place\n"; cmap = DefaultColormap(theDisplay, theScreen); fail = true; } else { opserr << "WindowDevice::WINOPEN have created our own colormap, \n"; opserr << "windows may change color as move mouse from one window to\n"; opserr << "another - depends on your video card to use another colormap\n\n"; cmap = XCreateColormap(theDisplay,theWindow, visual.visual, AllocAll); } /* cmap = XCreateColormap(theDisplay,theWindow, DefaultVisual(theDisplay,0),AllocAll); */ if (cmap == 0) { opserr << "WindowDevice::initX11() - could not get a new color table\n"; exit(-1); } // we are going to try to allocate 256 new colors -- need 8 planes for this depth = DefaultDepth(theDisplay, theScreen); if (depth < 8) { opserr << "WindowDevice::initX11() - needed at least 8 planes\n"; exit(-1); } if (fail == false) { int cnt = 0; for (int red = 0; red < 8; red++) { for (int green = 0; green < 8; green++) { for (int blue = 0; blue < 4; blue++) { pixels[32*red + 4*green + blue] = cnt; colors[cnt].pixel = pixels[32*red + 4*green + blue]; colors[cnt].red = (65536/7)*red; colors[cnt].green = (65536/7)*green; colors[cnt].blue = (65536/3)*blue; colors[cnt].flags = DoRed | DoGreen | DoBlue; cnt++; } } } background = 0; //pixels[0]; foreground = 255; // pixels[255]; XStoreColors(theDisplay, cmap, colors, cnt); } } // now set the windows to use the colormap XSetWindowColormap(theDisplay, theWindow, cmap); } XSetBackground(theDisplay, theGC, background); XSetForeground(theDisplay, theGC, foreground); XMapWindow(theDisplay,theWindow); XClearWindow(theDisplay, theWindow); XFlush(theDisplay); #else // auxInitDisplayMode(AUX_SINGLE | AUX_RGBA); // auxInitPosition(100,100,_width,_height); // auxInitWindow("G3"); if (winOpen == 0) oglDestroyWindow(title,theWND, theHRC, theHDC); theWND = oglCreateWindow(title, xLoc, yLoc, width, height, &theHRC, &theHDC); if (theWND == NULL) exit(1); winOpen = 0; wglMakeCurrent(theHDC, theHRC); glClearColor(1.0f,1.0f,1.0f,1.0f); glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, (GLsizei)width, (GLsizei)height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); // gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height); glFlush(); #endif winOpen = 0; }
/* This function should be written using GTK+ primitives*/ static void gstroke_invisible_window_init (GtkWidget *widget) { XSetWindowAttributes w_attr; XWindowAttributes orig_w_attr; unsigned long mask, col_border, col_background; unsigned int border_width; XSizeHints hints; Display *disp = GDK_WINDOW_XDISPLAY(gtk_widget_get_window(widget)); Window wind = gdk_x11_window_get_xid(gtk_widget_get_window(widget)); int screen = DefaultScreen (disp); if (!gstroke_draw_strokes()) return; gstroke_disp = disp; /* X server should save what's underneath */ XGetWindowAttributes (gstroke_disp, wind, &orig_w_attr); hints.x = orig_w_attr.x; hints.y = orig_w_attr.y; hints.width = orig_w_attr.width; hints.height = orig_w_attr.height; mask = CWSaveUnder; w_attr.save_under = True; /* inhibit all the decorations */ mask |= CWOverrideRedirect; w_attr.override_redirect = True; /* Don't set a background, transparent window */ mask |= CWBackPixmap; w_attr.background_pixmap = None; /* Default input window look */ col_background = WhitePixel (gstroke_disp, screen); /* no border for the window */ #if 0 border_width = 5; #endif border_width = 0; col_border = BlackPixel (gstroke_disp, screen); gstroke_window = XCreateSimpleWindow (gstroke_disp, wind, 0, 0, hints.width - 2 * border_width, hints.height - 2 * border_width, border_width, col_border, col_background); gstroke_gc = XCreateGC (gstroke_disp, gstroke_window, 0, NULL); XSetFunction (gstroke_disp, gstroke_gc, GXinvert); XChangeWindowAttributes (gstroke_disp, gstroke_window, mask, &w_attr); XSetLineAttributes (gstroke_disp, gstroke_gc, 2, LineSolid, CapButt, JoinMiter); XMapRaised (gstroke_disp, gstroke_window); #if 0 /*FIXME: is this call really needed? If yes, does it need the real argc and argv? */ hints.flags = PPosition | PSize; XSetStandardProperties (gstroke_disp, gstroke_window, "gstroke_test", NULL, (Pixmap)NULL, NULL, 0, &hints); /* Receive the close window client message */ { /* FIXME: is this really needed? If yes, something should be done with wmdelete...*/ Atom wmdelete = XInternAtom (gstroke_disp, "WM_DELETE_WINDOW", False); XSetWMProtocols (gstroke_disp, gstroke_window, &wmdelete, True); } #endif }
int main (void) { int i; int allocateOK; ximg = NULL; d = XOpenDisplay (NULL); if (!d) fputs ("Couldn't open display\n", stderr), exit (1); screen = DefaultScreen (d); gc = DefaultGC (d, screen); /* Find a visual */ vis.screen = screen; vlist = XGetVisualInfo (d, VisualScreenMask, &vis, &match); if (!vlist) fputs ("No matched visuals\n", stderr), exit (1); vis = vlist[0]; XFree (vlist); // That's not a fair comparison colormap_size is depth in bits! // if (vis.colormap_size < COLORS) // printf("Colormap is too small: %i.\n",vis.colormap_size); // , exit (1); // printf("Colour depth: %i\n",vis.colormap_size); // No way this number means nothing! It is 64 for 16-bit truecolour and 256 for 8-bit! win = XCreateSimpleWindow (d, DefaultRootWindow (d), 0, 0, WIN_W, WIN_H, 0, WhitePixel (d, screen), BlackPixel (d, screen)); int xclass=get_xvisinfo_class(vis); // printf("class = %i\n",xclass); stylee = ( vis.depth > 8 ? styleeTrueColor : styleePrivate ); // printf("stylee=%i\n",stylee); if ( get_xvisinfo_class(vis) % 2 == 1) { /* The odd numbers can redefine colors */ // printf("%i\n",get_xvisinfo_class(vis)); colormap = DefaultColormap (d, screen); Visual *defaultVisual=DefaultVisual(d,screen); /* Allocate cells */ allocateOK = (XAllocColorCells (d, colormap, 1, NULL, 0, color, COLORS) != 0); printf("Allocated OK? %i\n",allocateOK); if (allocateOK) { // printf("Allocated OK\n"); // This doesn't work for installed colormap! /* Modify the colorcells */ for (i = 0; i < COLORS; i++) xrgb[i].pixel = color[i]; XStoreColors (d, colormap, xrgb, COLORS); } else { colormap = XCreateColormap(d,win,defaultVisual,AllocNone); // redocolors(); } // black = XBlackPixel(d,screen); // white = XWhitePixel(d,screen); XAllocColorCells(d,colormap,1,0,0,color,colors); XSetWindowColormap(d,win,colormap); } else if ( get_xvisinfo_class(vis) == TrueColor) { colormap = DefaultColormap (d, screen); // printf("TrueColor %i = %i\n",xclass,TrueColor); /* This will lookup the color and sets the xrgb[i].pixel value */ // for (i = 0; i < COLORS; i++) // XAllocColor (d, colormap, &xrgb[i]); } else fprintf (stderr, "Not content with visual class %d.\n", get_xvisinfo_class(vis) ), exit (1); /* Find out if MITSHM is supported and useable */ printf ("MITSHM: "); if (XShmQueryVersion (d, &mitshm_major_code, &mitshm_minor_code, &shared_pixmaps)) { int (*handler) (Display *, XErrorEvent *); ximg = XShmCreateImage (d, vis.visual, vis.depth, XShmPixmapFormat (d), NULL, &shminfo, WIN_W, WIN_H); shminfo.shmid = shmget (IPC_PRIVATE, ximg->bytes_per_line * ximg->height, IPC_CREAT | 0777); shminfo.shmaddr = (char *)shmat (shminfo.shmid, 0, 0); ximg->data = (char *)shminfo.shmaddr; handler = XSetErrorHandler (mitshm_handler); XShmAttach (d, &shminfo); /* Tell the server to attach */ XSync (d, 0); XSetErrorHandler (handler); shmctl (shminfo.shmid, IPC_RMID, 0); /* Mark this shm segment for deletion at once. The segment will * automatically become released when both the server and this * client have detached from it. * (Process termination automagically detach shm segments) */ if (!can_use_mitshm) { shmdt (shminfo.shmaddr); ximg = NULL; } } if (ximg == NULL) { can_use_mitshm = 0; /* XInitImage(ximg); */ ximg = XCreateImage (d, vis.visual, vis.depth, ZPixmap, 0, (char *)malloc (WIN_W * WIN_H), WIN_W, WIN_H, 8, 0); } if (can_use_mitshm) printf ("YES!\n"); else printf ("NO, using fallback instead.\n"); // DrawFractal (ximg,xrgb); XSelectInput (d, win, ButtonPressMask | ExposureMask); XMapWindow (d, win); real_main(); // XNextEvent (d, &ev); // switch (ev.type) { // case ButtonPress: // should_quit = 1; // break; // case Expose: // if (can_use_mitshm) // XShmPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H, True); // else // XPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H); // break; // default: // break; // } if (get_xvisinfo_class(vis) % 2 == 1 || get_xvisinfo_class(vis) == TrueColor) { unsigned long color[COLORS]; if (allocateOK) { for (i = 0; i < COLORS; i++) color[i] = xrgb[i].pixel; XFreeColors (d, colormap, color, COLORS, 0); } /* Allocated colors freed */ } else { XUninstallColormap (d, colormap); } if (can_use_mitshm) { XShmDetach (d, &shminfo); /* Server detached */ XDestroyImage (ximg); /* Image struct freed */ shmdt (shminfo.shmaddr); /* We're detached */ } else XDestroyImage (ximg); /* Image struct freed */ XDestroyWindow (d, win); /* Window removed */ XCloseDisplay (d); /* Display disconnected */ /* So you can see how your computer compares to your friend's */ getrusage (RUSAGE_SELF, &resource_utilization); float seconds=(float)resource_utilization.ru_utime.tv_sec +(float)resource_utilization.ru_utime.tv_usec*0.000000001; printf("CPU seconds per frame: %f\n",seconds/(float)frameno); // printf ("CPU seconds consumed: %ds and %dµs\n", // (int) resource_utilization.ru_utime.tv_sec, // (int) resource_utilization.ru_utime.tv_usec); return 0; }
int XMessageBox::show() { if (mDisplay == NULL) return -1; int retVal = 0; retVal = loadFont(); if (retVal < 0) return retVal; // set the maximum window dimensions mScreenWidth = DisplayWidth(mDisplay, DefaultScreen(mDisplay)); mScreenHeight = DisplayHeight(mDisplay, DefaultScreen(mDisplay)); mMaxWindowWidth = min(mScreenWidth, MessageBox_MaxWinWidth); mMaxWindowHeight = min(mScreenHeight, MessageBox_MaxWinHeight); // split the message into a vector of lines splitMessage(); // set the dialog dimensions setDimensions(); mWin = XCreateSimpleWindow( mDisplay, DefaultRootWindow(mDisplay), (mScreenWidth - mMBWidth) / 2, (mScreenHeight - mMBHeight) / 2, mMBWidth, mMBHeight, 1, BlackPixel(mDisplay, DefaultScreen(mDisplay)), WhitePixel(mDisplay, DefaultScreen(mDisplay))); mGC = XCreateGC(mDisplay, mWin, 0, 0); XSetFont(mDisplay, mGC, mFS->fid); // set input mask XSelectInput(mDisplay, mWin, ExposureMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask); // set wm protocols in case they hit X Atom wm_delete_window = XInternAtom(mDisplay, "WM_DELETE_WINDOW", False); Atom wm_protocols = XInternAtom(mDisplay, "WM_PROTOCOLS", False); XSetWMProtocols (mDisplay, mWin, &wm_delete_window, 1); // set pop up dialog hint XSetTransientForHint(mDisplay, mWin, mWin); // set title XTextProperty wtitle; wtitle.value = (unsigned char *)mTitle; wtitle.encoding = XA_STRING; wtitle.format = 8; wtitle.nitems = strlen(mTitle); XSetWMName(mDisplay, mWin, &wtitle); // show window XMapWindow(mDisplay, mWin); // move it in case some bozo window manager repositioned it XMoveWindow(mDisplay, mWin, (mScreenWidth - mMBWidth) / 2, (mScreenHeight - mMBHeight) / 2); // raise it to top XRaiseWindow(mDisplay, mWin); XMessageBoxButton* clickedButton = NULL; XEvent event; Vector<XMessageBoxButton>::iterator iter; bool done = false; while (!done) { XNextEvent(mDisplay, &event); switch (event.type) { case Expose: repaint(); break; case MotionNotify: for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) iter->setMouseCoordinates(event.xmotion.x, event.xmotion.y); break; case ButtonPress: for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) { if (iter->pointInRect(event.xbutton.x, event.xbutton.y)) { iter->setMouseDown(true); iter->setMouseCoordinates(event.xbutton.x, event.xbutton.y); break; } } break; case ButtonRelease: for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) { if (iter->pointInRect(event.xbutton.x, event.xbutton.y) && iter->isMouseDown()) { // we got a winner! clickedButton = iter; done = true; break; } } if (clickedButton == NULL) { // user released outside a button. clear the button states for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) iter->setMouseDown(false); } break; case ClientMessage: if (event.xclient.message_type == wm_protocols && event.xclient.data.l[0] == static_cast<long>(wm_delete_window)) done = true; break; } repaint(); } XUnmapWindow(mDisplay, mWin); XDestroyWindow(mDisplay, mWin); XFreeGC(mDisplay, mGC); XFreeFont(mDisplay, mFS); if (clickedButton != NULL) return clickedButton->getClickVal(); else return -1; }
void drawswarm(Window win) { swarmstruct *sp = &swarms[screen]; int b; /* <=- Wasp -=> */ /* Age the arrays. */ sp->wx[2] = sp->wx[1]; sp->wx[1] = sp->wx[0]; sp->wy[2] = sp->wy[1]; sp->wy[1] = sp->wy[0]; /* Accelerate */ sp->wxv += balance_rand(WASPACC); sp->wyv += balance_rand(WASPACC); /* Speed Limit Checks */ if (sp->wxv > WASPVEL) sp->wxv = WASPVEL; if (sp->wxv < -WASPVEL) sp->wxv = -WASPVEL; if (sp->wyv > WASPVEL) sp->wyv = WASPVEL; if (sp->wyv < -WASPVEL) sp->wyv = -WASPVEL; /* Move */ sp->wx[0] = sp->wx[1] + sp->wxv; sp->wy[0] = sp->wy[1] + sp->wyv; /* Bounce Checks */ if ((sp->wx[0] < sp->border) || (sp->wx[0] > sp->width - sp->border - 1)) { sp->wxv = -sp->wxv; sp->wx[0] += sp->wxv; } if ((sp->wy[0] < sp->border) || (sp->wy[0] > sp->height - sp->border - 1)) { sp->wyv = -sp->wyv; sp->wy[0] += sp->wyv; } /* Don't let things settle down. */ sp->xv[LRAND() % sp->beecount] += balance_rand(3); sp->yv[LRAND() % sp->beecount] += balance_rand(3); /* <=- Bees -=> */ for (b = 0; b < sp->beecount; b++) { int distance, dx, dy; /* Age the arrays. */ X(2, b) = X(1, b); X(1, b) = X(0, b); Y(2, b) = Y(1, b); Y(1, b) = Y(0, b); /* Accelerate */ dx = sp->wx[1] - X(1, b); dy = sp->wy[1] - Y(1, b); distance = abs(dx) + abs(dy); /* approximation */ if (distance == 0) distance = 1; sp->xv[b] += (dx * BEEACC) / distance; sp->yv[b] += (dy * BEEACC) / distance; /* Speed Limit Checks */ if (sp->xv[b] > BEEVEL) sp->xv[b] = BEEVEL; if (sp->xv[b] < -BEEVEL) sp->xv[b] = -BEEVEL; if (sp->yv[b] > BEEVEL) sp->yv[b] = BEEVEL; if (sp->yv[b] < -BEEVEL) sp->yv[b] = -BEEVEL; /* Move */ X(0, b) = X(1, b) + sp->xv[b]; Y(0, b) = Y(1, b) + sp->yv[b]; /* Fill the segment lists. */ sp->segs[b].x1 = X(0, b); sp->segs[b].y1 = Y(0, b); sp->segs[b].x2 = X(1, b); sp->segs[b].y2 = Y(1, b); sp->old_segs[b].x1 = X(1, b); sp->old_segs[b].y1 = Y(1, b); sp->old_segs[b].x2 = X(2, b); sp->old_segs[b].y2 = Y(2, b); } XSetForeground(dsp, Scr[screen].gc, BlackPixel(dsp, screen)); XDrawLine(dsp, win, Scr[screen].gc, sp->wx[1], sp->wy[1], sp->wx[2], sp->wy[2]); XDrawSegments(dsp, win, Scr[screen].gc, sp->old_segs, sp->beecount); XSetForeground(dsp, Scr[screen].gc, WhitePixel(dsp, screen)); XDrawLine(dsp, win, Scr[screen].gc, sp->wx[0], sp->wy[0], sp->wx[1], sp->wy[1]); if (!mono && Scr[screen].npixels > 2) { XSetForeground(dsp, Scr[screen].gc, Scr[screen].pixels[sp->pix]); if (++sp->pix >= Scr[screen].npixels) sp->pix = 0; } XDrawSegments(dsp, win, Scr[screen].gc, sp->segs, sp->beecount); }
main() { int llx,lly,urx,ury,width,height, scrwidth,scrheight,scrwidthmm,scrheightmm; float xres,yres; char buf[LBUF]; Display *dpy; int scr; unsigned long black,white; GC gcpix,gcwin; Window win; Pixmap pix; XEvent ev; DPSContext dps; /* open display */ if ((dpy=XOpenDisplay(NULL))==NULL) { fprintf(stderr,"Cannot connect to display %s\n", XDisplayName(NULL)); exit(-1); } scr = DefaultScreen(dpy); black = BlackPixel(dpy,scr); white = WhitePixel(dpy,scr); /* determine BoundingBox */ llx = LLX_DEFAULT; lly = LLY_DEFAULT; urx = URX_DEFAULT; ury = URY_DEFAULT; fgets(buf,LBUF,stdin); if (strstr(buf,"EPS")!=NULL) { while(fgets(buf,LBUF,stdin)!=NULL) { if (buf[0]!='%' || buf[1]!='%') continue; if (strstr(buf,"%%BoundingBox:")==buf) { if (strstr(buf,"(atend)")==NULL) { sscanf(&buf[14],"%d %d %d %d", &llx,&lly,&urx,&ury); } break; } else if (strstr(buf,"%%EndComments")==buf) { break; } else if (strstr(buf,"%%EndProlog")==buf) { break; } } } /* width and height in pixels */ scrwidth = WidthOfScreen(DefaultScreenOfDisplay(dpy)); scrheight = HeightOfScreen(DefaultScreenOfDisplay(dpy)); scrwidthmm = WidthMMOfScreen(DefaultScreenOfDisplay(dpy)); scrheightmm = HeightMMOfScreen(DefaultScreenOfDisplay(dpy)); xres = (int)(25.4*scrwidth/scrwidthmm)/72.0; yres = (int)(25.4*scrheight/scrheightmm)/72.0; if (xres*(urx-llx)>scrwidth || yres*(ury-lly)>scrheight) { xres = (scrwidth-32.0)/(urx-llx); yres = (scrheight-32.0)/(ury-lly); xres = yres = (xres<yres)?xres:yres; } width = (urx-llx)*xres; height = (ury-lly)*yres; /* create pixmap and its gc */ pix = XCreatePixmap(dpy,DefaultRootWindow(dpy),width,height, DefaultDepth(dpy,scr)); gcpix = XCreateGC(dpy,pix,0,NULL); /* create and set Display PostScript context for pixmap */ dps = XDPSCreateSimpleContext(dpy,pix,gcpix,0,height, DPSDefaultTextBackstop,DPSDefaultErrorProc,NULL); if (dps==NULL) { fprintf(stderr,"Cannot create DPS context\n"); exit(-1); } DPSPrintf(dps,"\n resyncstart\n"); DPSSetContext(dps); DPSFlushContext(dps); DPSWaitContext(dps); /* paint white background */ DPSPrintf(dps, "gsave\n" "1 setgray\n" "0 0 %d %d rectfill\n" "grestore\n", urx-llx,ury-lly); /* translate */ DPSPrintf(dps,"%d %d translate\n",-llx,-lly); /* read PostScript from standard input and render in pixmap */ DPSPrintf(dps,"/showpage {} def\n"); while (fgets(buf,LBUF,stdin)!=NULL) DPSWritePostScript(dps,buf,strlen(buf)); DPSFlushContext(dps); DPSWaitContext(dps); /* create and map window */ win = XCreateSimpleWindow(dpy,DefaultRootWindow(dpy), 100,100,width,height,1,black,white); XSetStandardProperties(dpy,win,"EPS Pixmap","EPSpix", None,NULL,0,NULL); XMapWindow(dpy,win); /* copy pixmap to window; in pixmap, black=0 and white=1 */ gcwin = XCreateGC(dpy,win,0,NULL); XCopyArea(dpy,pix,win,gcwin,0,0,width,height,0,0); /* main event loop */ XSelectInput(dpy,win, KeyPressMask | ExposureMask); while(True) { XNextEvent(dpy,&ev); if (ev.type==Expose) { while (XCheckTypedEvent(dpy,Expose,&ev)); XCopyArea(dpy,pix,win,gcwin,0,0,width,height,0,0); } else if (ev.type==KeyPress) { break; } } /* clean up */ DPSDestroySpace(DPSSpaceFromContext(dps)); XFreePixmap(dpy,pix); XFreeGC(dpy,gcpix); XFreeGC(dpy,gcwin); }
int CreeTermGraph(TC *p,unsigned int largeur,unsigned int hauteur,char* titre) { char *display_name = getenv("DISPLAY"); unsigned long valuemask = 0; XGCValues values ; p->largeur = largeur; p->hauteur = hauteur; if ((p->display = XOpenDisplay(display_name)) == NULL) return -1; p->screen_num = DefaultScreen(p->display); p->win = XCreateSimpleWindow(p->display, RootWindow(p->display,p->screen_num), 0,0, largeur,hauteur, 1, BlackPixel(p->display,p->screen_num), WhitePixel(p->display,p->screen_num)); XStoreName(p->display,p->win,titre); XMapWindow(p->display,p->win); XFlush(p->display); p->gc = XCreateGC(p->display,p->win,valuemask,&values); /***** Allocations des couleurs *****/ p->cm = DefaultColormap(p->display,DefaultScreen(p->display)); if (XAllocNamedColor(p->display,p->cm,"black",&(p->Noir),&(p->Noir)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"white",&(p->Blanc),&(p->Blanc)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"red",&(p->Rouge),&(p->Rouge)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"blue",&(p->Bleu),&(p->Bleu)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"green",&(p->Vert),&(p->Vert)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"yellow",&(p->Jaune),&(p->Jaune)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"brown",&(p->Brun),&(p->Brun)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"gray",&(p->Gris),&(p->Gris)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"magenta",&(p->Magenta),&(p->Magenta)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"cyan",&(p->Cyan),&(p->Cyan)) == 0) return -1; if (XAllocNamedColor(p->display,p->cm,"orange",&(p->Orange),&(p->Orange)) == 0) return -1; XSetBackground(p->display, p->gc, p->Blanc.pixel); XSync(p->display, False); sleep(1); return 0; }
QT_BEGIN_NAMESPACE QXlibWindow::QXlibWindow(QWidget *window) : QPlatformWindow(window) , mGLContext(0) , mScreen(QXlibScreen::testLiteScreenForWidget(window)) { int x = window->x(); int y = window->y(); int w = window->width(); int h = window->height(); #if !defined(QT_NO_OPENGL) if(window->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenGL && QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL) || window->platformWindowFormat().alpha()) { #if !defined(QT_OPENGL_ES_2) XVisualInfo *visualInfo = qglx_findVisualInfo(mScreen->display()->nativeDisplay(),mScreen->xScreenNumber(),window->platformWindowFormat()); #else QPlatformWindowFormat windowFormat = correctColorBuffers(window->platformWindowFormat()); EGLDisplay eglDisplay = mScreen->eglDisplay(); EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,windowFormat); VisualID id = QXlibEglIntegration::getCompatibleVisualId(mScreen->display()->nativeDisplay(), eglDisplay, eglConfig); XVisualInfo visualInfoTemplate; memset(&visualInfoTemplate, 0, sizeof(XVisualInfo)); visualInfoTemplate.visualid = id; XVisualInfo *visualInfo; int matchingCount = 0; visualInfo = XGetVisualInfo(mScreen->display()->nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount); #endif //!defined(QT_OPENGL_ES_2) if (visualInfo) { mDepth = visualInfo->depth; mFormat = (mDepth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32; mVisual = visualInfo->visual; Colormap cmap = XCreateColormap(mScreen->display()->nativeDisplay(), mScreen->rootWindow(), visualInfo->visual, AllocNone); XSetWindowAttributes a; a.background_pixel = WhitePixel(mScreen->display()->nativeDisplay(), mScreen->xScreenNumber()); a.border_pixel = BlackPixel(mScreen->display()->nativeDisplay(), mScreen->xScreenNumber()); a.colormap = cmap; x_window = XCreateWindow(mScreen->display()->nativeDisplay(), mScreen->rootWindow(),x, y, w, h, 0, visualInfo->depth, InputOutput, visualInfo->visual, CWBackPixel|CWBorderPixel|CWColormap, &a); } else { qFatal("no window!"); } } else #endif //!defined(QT_NO_OPENGL) { mDepth = mScreen->depth(); mFormat = (mDepth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32; mVisual = mScreen->defaultVisual(); x_window = XCreateSimpleWindow(mScreen->display()->nativeDisplay(), mScreen->rootWindow(), x, y, w, h, 0 /*border_width*/, mScreen->blackPixel(), mScreen->whitePixel()); } #ifdef MYX11_DEBUG qDebug() << "QTestLiteWindow::QTestLiteWindow creating" << hex << x_window << window; #endif XSetWindowBackgroundPixmap(mScreen->display()->nativeDisplay(), x_window, XNone); XSelectInput(mScreen->display()->nativeDisplay(), x_window, ExposureMask | KeyPressMask | KeyReleaseMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | PropertyChangeMask | StructureNotifyMask); gc = createGC(); Atom protocols[5]; int n = 0; protocols[n++] = QXlibStatic::atom(QXlibStatic::WM_DELETE_WINDOW); // support del window protocol protocols[n++] = QXlibStatic::atom(QXlibStatic::WM_TAKE_FOCUS); // support take focus window protocol // protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_PING); // support _NET_WM_PING protocol #ifndef QT_NO_XSYNC protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_SYNC_REQUEST); // support _NET_WM_SYNC_REQUEST protocol #endif // QT_NO_XSYNC if (window->windowFlags() & Qt::WindowContextHelpButtonHint) protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_CONTEXT_HELP); XSetWMProtocols(mScreen->display()->nativeDisplay(), x_window, protocols, n); }
int ui_init( int *argc, char ***argv ) { char *displayName=NULL; /* Use default display */ XWMHints *wmHints; XSizeHints *sizeHints; XClassHint *classHint; char *windowNameList=(char *)"Fuse",*iconNameList=(char *)"Fuse"; XTextProperty windowName, iconName; unsigned long windowFlags; XSetWindowAttributes windowAttributes; /* Allocate memory for various things */ if( ui_widget_init() ) return 1; if(!(wmHints = XAllocWMHints())) { fprintf(stderr,"%s: failure allocating memory\n", fuse_progname); return 1; } if(!(sizeHints = XAllocSizeHints())) { fprintf(stderr,"%s: failure allocating memory\n", fuse_progname); return 1; } if(!(classHint = XAllocClassHint())) { fprintf(stderr,"%s: failure allocating memory\n", fuse_progname); return 1; } if(XStringListToTextProperty(&windowNameList,1,&windowName) == 0 ) { fprintf(stderr,"%s: structure allocation for windowName failed\n", fuse_progname); return 1; } if(XStringListToTextProperty(&iconNameList,1,&iconName) == 0 ) { fprintf(stderr,"%s: structure allocation for iconName failed\n", fuse_progname); return 1; } /* Open a connection to the X server */ if ( ( display=XOpenDisplay(displayName)) == NULL ) { fprintf(stderr,"%s: cannot connect to X server %s\n", fuse_progname, XDisplayName(displayName)); return 1; } /* Set up our error handler */ xerror_expecting = xerror_error = 0; XSetErrorHandler( xerror_handler ); xui_screenNum = DefaultScreen(display); /* Create the main window */ xui_mainWindow = XCreateSimpleWindow( display, RootWindow( display, xui_screenNum ), 0, 0, DISPLAY_ASPECT_WIDTH, DISPLAY_SCREEN_HEIGHT, 0, BlackPixel( display, xui_screenNum ), WhitePixel( display, xui_screenNum ) ); /* Set standard window properties */ sizeHints->flags = PBaseSize | PResizeInc | PMaxSize | PMinSize; sizeHints->base_width = 0; sizeHints->base_height = 0; sizeHints->min_width = DISPLAY_ASPECT_WIDTH; sizeHints->min_height = DISPLAY_SCREEN_HEIGHT; sizeHints->width_inc = DISPLAY_ASPECT_WIDTH; sizeHints->height_inc = DISPLAY_SCREEN_HEIGHT; sizeHints->max_width = 3 * DISPLAY_ASPECT_WIDTH; sizeHints->max_height = 3 * DISPLAY_SCREEN_HEIGHT; if( settings_current.aspect_hint ) { sizeHints->flags |= PAspect; sizeHints->min_aspect.x = 4; sizeHints->min_aspect.y = 3; sizeHints->max_aspect.x = 4; sizeHints->max_aspect.y = 3; } wmHints->flags=StateHint | InputHint; wmHints->initial_state=NormalState; wmHints->input=True; classHint->res_name=(char *)fuse_progname; classHint->res_class=(char *)"Fuse"; XSetWMProperties(display, xui_mainWindow, &windowName, &iconName, *argv, *argc, sizeHints, wmHints, classHint); XFree( windowName.value ); XFree( iconName.value ); XFree( sizeHints ); XFree( wmHints ); XFree( classHint ); /* Ask the server to use its backing store for this window */ windowFlags=CWBackingStore; windowAttributes.backing_store=WhenMapped; XChangeWindowAttributes(display, xui_mainWindow, windowFlags, &windowAttributes); /* Select which types of event we want to receive */ XSelectInput(display, xui_mainWindow, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask | FocusChangeMask | PointerMotionMask ); { static XColor dummy = { 0, 0, 0, 0, 4, 0 }; XGCValues xgc; GC gc; Pixmap mask = XCreatePixmap( display, RootWindow( display, xui_screenNum ), 1, 1, 1 ); xgc.function = GXclear; gc = XCreateGC( display, mask, GCFunction, &xgc ); XFillRectangle( display, mask, gc, 0, 0, 1, 1 ); nullpointer = XCreatePixmapCursor( display, mask,mask, &dummy,&dummy, 0,0 ); XFreePixmap( display, mask ); XFreeGC( display, gc ); } /* Ask to be notified of window close requests */ delete_window_atom = XInternAtom( display, "WM_DELETE_WINDOW", 0 ); XSetWMProtocols( display, xui_mainWindow, &delete_window_atom, 1 ); if( xdisplay_init() ) return 1; /* And finally display the window */ XMapWindow(display,xui_mainWindow); ui_mouse_present = 1; return 0; }
int set_full_screen(Display *dpy) { signal(SIGUSR1, fake_right_button); fulldisplay = dpy; Window curwin, rootw; Cursor hand_cursor; int x1, y1, winx, winy; unsigned int mask; XEvent ev; int screen_num; if (!dpy) { fprintf(stderr, "WTPEN : cannot get default display\n"); exit(1); } /* style for line */ unsigned int line_width = 8; int line_style = LineSolid; int cap_style = CapRound; int join_style = JoinRound; screen_num = DefaultScreen(dpy); rootw = DefaultRootWindow(dpy); if (rootw == None) { fprintf(stderr, "WTPEN : full screen mode cannot get root window\n"); exit(1); } hand_cursor = XCreateFontCursor(dpy, XC_hand2); drawgc = XCreateGC(dpy, rootw, 0, NULL); // hier wordt getekend (met xor) XSetSubwindowMode(dpy, drawgc, IncludeInferiors); XSetForeground(dpy, drawgc, WhitePixel(dpy, screen_num) ^ BlackPixel(dpy, screen_num)); XSetLineAttributes(dpy, drawgc, line_width, line_style, cap_style, join_style); XSetFunction(dpy, drawgc, GXandInverted); //XSetFunction(dpy, drawgc, GXxor); fprintf(stderr, "full screen mode grab button\n"); XGrabButton(dpy, AnyButton, 0, rootw, False, ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | OwnerGrabButtonMask, GrabModeSync, GrabModeAsync, None, hand_cursor); while (1) { fprintf (stderr, "fullscreen\n"); // wordt bij tekenen aangeroepen XAllowEvents(dpy, SyncPointer, CurrentTime); XWindowEvent(dpy, rootw, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask, &ev); switch(ev.type) { case ButtonPress: kill(getppid(), SIGUSR2); if(ev.xbutton.button != Button1) { int num; XUngrabButton(dpy, AnyButton, 0, rootw); XFlush(dpy); record_coordinate(0xff, 0xff); clear_draw_area(dpy, rootw, drawgc); num = get_coordinates_num(); return num; } XQueryPointer(dpy, rootw, &rootw, &curwin, &x1, &y1, //root x, root y &winx, &winy, &mask); record_coordinate(x1, y1); break; case ButtonRelease: if (ev.xbutton.button == Button1) { if (get_coordinates_num() == 2) { free_coordinates(); XUngrabButton(dpy, AnyButton, 0, rootw); forward_click_event(dpy, &ev); XFlush(dpy); return 0; } record_coordinate(0xff, 0x00); kill(getppid(), SIGALRM); } break; case MotionNotify: if (ev.xmotion.state & Button1MotionMask) { CoordinateList *cl_end; XQueryPointer(dpy, rootw, &rootw, &curwin, &x1, &y1, //root x, root y &winx, &winy, &mask); cl_end = coordinate_list_end(); if (cl_end) { if (!(cl_end->x == 0xff && cl_end->y == 0x00)) { XDrawLine(dpy, rootw, drawgc, x1, y1, cl_end->x, cl_end->y); record_coordinate(x1, y1); } } else { record_coordinate(x1, y1); } } break; default: break; } } fprintf(stderr, "exit fullscreen\n"); // wordt nooit bereikt return 1; }
int main(int argc, char **argv) { XEvent evt; Colormap colormap; struct timeval tv; int screenNumber; long eventMask; unsigned long white; unsigned long black; Status rc; int iters; int opt; int draw_lines; int draw_rects; int draw_stipples; int draw_fonts; int draw_image; int zero_counters; int scroll_type; char image_file[256]; char proxy_app[256]; char msg[4096]; // set some defaults g_winWidth = 640; g_winHeight = 480; iters = 5000; draw_lines = 1; draw_rects = 1; draw_stipples = 1; draw_fonts = 1; draw_image = 1; g_delay_dur = 1000; scroll_type = SCROLL_SMOOTH1; zero_counters = 0; strcpy(image_file, "yosemite.bmp"); strcpy(msg, "To be or not to be!"); // process cmd line args opterr = 0; while ((opt = getopt(argc, argv, "lrsg:c:f:i:d:o:z:")) != -1) { switch (opt) { case 'g': if (sscanf(optarg, "%dx%d", &g_winWidth, &g_winHeight) != 2) { fprintf(stderr, "\nerror: invalid geometry specified\n\n"); usage(); return -1; } break; case 'c': if (sscanf(optarg, "%d", &iters) != 1) { fprintf(stderr, "\nerror: invalid count specified\n\n"); usage(); return -1; } break; case 'l': draw_lines = 1; draw_rects = 0; draw_stipples = 0; draw_fonts = 0; draw_image = 0; break; case 'r': draw_rects = 1; draw_lines = 0; draw_stipples = 0; draw_fonts = 0; draw_image = 0; break; case 's': draw_stipples = 1; draw_lines = 0; draw_rects = 0; draw_fonts = 0; draw_image = 0; break; case 'f': if (strlen(optarg) <= 0) { fprintf(stderr, "\nerror: -f option requires an argument\n\n"); usage(); return -1; } draw_fonts = 1; strncpy(msg, optarg, 4096); draw_lines = 0; draw_rects = 0; draw_stipples = 0; draw_image = 0; break; case 'i': if (strlen(optarg) <= 0) { fprintf(stderr, "\nerror: -i option requires an argument\n\n"); usage(); return -1; } draw_image = 1; strncpy(image_file, optarg, 255); draw_lines = 0; draw_rects = 0; draw_stipples = 0; draw_fonts = 0; break; case 'h': usage(); return 0; break; case 'v': printf("xdemo Ver 1.0\n"); return 0; break; case 'd': if (sscanf(optarg, "%d", &g_delay_dur) != 1) { fprintf(stderr, "\nerror: -d option requires an argument\n\n"); usage(); return -1; } break; case 'z': if (strlen(optarg) <= 0) { fprintf(stderr, "\nerror: invalid proxy application specified\n\n"); usage(); return -1; } strcpy(proxy_app, optarg); printf("##### LK_TODO: proxy_app=%s\n", proxy_app); zero_counters = 1; break; case 'o': if (strcmp(optarg, "jump") == 0) { scroll_type = SCROLL_JUMP; } else if (strcmp(optarg, "smooth1") == 0) { scroll_type = SCROLL_SMOOTH1; } else if (strcmp(optarg, "smooth2") == 0) { scroll_type = SCROLL_SMOOTH2; } else if (strcmp(optarg, "smooth3") == 0) { scroll_type = SCROLL_SMOOTH3; } else if (strcmp(optarg, "smooth4") == 0) { scroll_type = SCROLL_SMOOTH4; } else { fprintf(stderr, "\ninvalid scroll type specified\n\n"); usage(); return -1; } break; default: usage(); return -1; } } // must have at least one operation if ((!draw_lines) && (!draw_rects) && (!draw_stipples) && (!draw_fonts) && (!draw_image)) { usage(); return -1; } g_disp = XOpenDisplay(NULL); if (!g_disp) { dprint("error opening X display\n"); exit(-1); } screenNumber = DefaultScreen(g_disp); white = WhitePixel(g_disp, screenNumber); black = BlackPixel(g_disp, screenNumber); g_win = XCreateSimpleWindow(g_disp, DefaultRootWindow(g_disp), 50, 50, // origin g_winWidth, g_winHeight, // size 0, black, // border white ); // backgd XMapWindow(g_disp, g_win); //eventMask = StructureNotifyMask | MapNotify | VisibilityChangeMask; eventMask = StructureNotifyMask | VisibilityChangeMask; XSelectInput(g_disp, g_win, eventMask); g_gc = XCreateGC(g_disp, g_win, 0, // mask of values NULL ); // array of values #if 0 do { dprint("about to call XNextEvent(...)\n"); XNextEvent(g_disp, &evt);// calls XFlush dprint("returned from XNextEvent(...)\n"); } //while(evt.type != MapNotify); while(evt.type != VisibilityNotify); #endif // get access to the screen's color map colormap = DefaultColormap(g_disp, screenNumber); // alloc red color rc = XAllocNamedColor(g_disp, colormap, "red", &g_colors[0], &g_colors[0]); if (rc == 0) { printf("XAllocNamedColor - failed to allocated 'red' color.\n"); exit(1); } rc = XAllocNamedColor(g_disp, colormap, "green", &g_colors[1], &g_colors[1]); if (rc == 0) { printf("XAllocNamedColor - failed to allocated 'green' color.\n"); exit(1); } rc = XAllocNamedColor(g_disp, colormap, "blue", &g_colors[2], &g_colors[2]); if (rc == 0) { printf("XAllocNamedColor - failed to allocated 'blue' color.\n"); exit(1); } rc = XAllocNamedColor(g_disp, colormap, "yellow", &g_colors[3], &g_colors[3]); if (rc == 0) { printf("XAllocNamedColor - failed to allocated 'yellow' color.\n"); exit(1); } rc = XAllocNamedColor(g_disp, colormap, "orange", &g_colors[4], &g_colors[4]); if (rc == 0) { printf("XAllocNamedColor - failed to allocated 'orange' color.\n"); exit(1); } if (zero_counters) { signal_tcp_proxy(proxy_app); } if (draw_lines) { start_timer(&tv); drawLines(iters); printf("drew %d lines in %d ms\n", iters, time_elapsed_ms(tv)); } if (draw_rects) { start_timer(&tv); drawRectangles(iters); printf("drew %d rects in %d ms\n", iters, time_elapsed_ms(tv)); } if (draw_stipples) { start_timer(&tv); // LK_TODO } if (draw_fonts) { start_timer(&tv); drawFont(iters, msg); printf("drew %d strings in %d ms\n", iters, time_elapsed_ms(tv)); } if (draw_image) { start_timer(&tv); drawBMP(image_file, scroll_type); printf("drew BMP in %d ms\n", time_elapsed_ms(tv)); } if (zero_counters) { signal_tcp_proxy(proxy_app); } eventMask = ButtonPressMask|ButtonReleaseMask; XSelectInput(g_disp, g_win, eventMask); do { XNextEvent(g_disp, &evt); // calls XFlush() } while(evt.type != ButtonRelease); XDestroyWindow(g_disp, g_win); XCloseDisplay(g_disp); return 0; }
void init_window(int argc, char *argv[]) { unsigned long get_color_pix(char *color_name); screen = DefaultScreen(display); #if defined(HAVE_BZERO) && !defined(HAVE_MEMSET) bzero(&xsh, sizeof(xsh)); #else memset(&xsh, 0, sizeof(xsh)); #endif if (geometry) { int bitmask; bitmask = XGeometry(display, screen, geometry, NULL, bwidth, 1, 1, 1, 1, &(xsh.x), &(xsh.y), &(xsh.width), &(xsh.height)); if (bitmask & (XValue | YValue)) { xsh.flags |= USPosition; } if (bitmask & (WidthValue | HeightValue)) { xsh.flags |= USSize; } } else { xsh.flags = USPosition | PSize; if (!landscape) { xsh.width = XLENG / shrink; xsh.height = YLENG / shrink; xsh.x = X0; xsh.y = Y0; } else { xsh.width = YLENG / shrink; xsh.height = XLENG / shrink; xsh.x = X0_LAND; xsh.y = Y0; } } /** Color **/ #ifdef COLOR_BUG reverse = 1; #endif if (DisplayPlanes(display, screen) >= 3) { c_flg = 1; if (!reverse) { forepix = get_color_pix(fore_color); backpix = get_color_pix(back_color); highpix = get_color_pix(high_color); brdrpix = get_color_pix(brdr_color); mouspix = get_color_pix(mous_color); } else { forepix = get_color_pix(back_color); backpix = get_color_pix(fore_color); highpix = get_color_pix(high_color); brdrpix = get_color_pix(brdr_color); mouspix = get_color_pix(mous_color); } } else { if (!reverse) { forepix = BlackPixel(display, screen); highpix = BlackPixel(display, screen); backpix = WhitePixel(display, screen); brdrpix = BlackPixel(display, screen); mouspix = BlackPixel(display, screen); } else { forepix = WhitePixel(display, screen); highpix = WhitePixel(display, screen); backpix = BlackPixel(display, screen); brdrpix = WhitePixel(display, screen); mouspix = WhitePixel(display, screen); } } /** Generate Window **/ main_window = XCreateSimpleWindow(display, DefaultRootWindow(display), xsh.x, xsh.y, xsh.width, xsh.height, bwidth, brdrpix, backpix); XSetStandardProperties(display, main_window, windowtitle, windowtitle, None, argv, argc, &xsh); /* winatt.bit_gravity = SouthWestGravity; */ XChangeWindowAttributes(display, main_window, CWBitGravity, &winatt); /** Map Window **/ XSelectInput(display, main_window, StructureNotifyMask); XMapWindow(display, main_window); for (;;) { XNextEvent(display, &ev); if (ev.type == MapNotify) break; } XSelectInput(display, main_window, ButtonPressMask | PointerMotionMask | KeyPressMask | ExposureMask); /* KeyReleaseMask|ExposureMask|StructureNotifyMask); */ /** Cursor **/ watch_cur = XCreateFontCursor(display, XC_watch); XDefineCursor(display, main_window, watch_cur); /** GC **/ gcval.line_width = 1; gc = XCreateGC(display, main_window, GCLineWidth, &gcval); XSetFunction(display, gc, GXcopy); XSetGraphicsExposures(display, gc, False); XSetForeground(display, gc, forepix); XSetBackground(display, gc, backpix); font = XLoadFont(display, f_name[fno]); XSetFont(display, gc, font); }
static void gui_draw_xor_box(GC gc, int x, int y, int width, int height) { XSetForeground(gui->display, gc, WhitePixel(gui->display, gui->screen) ^ BlackPixel(gui->display, gui->screen)); XDrawRectangle(gui->display, gui->root, gc, x, y, width, height); }
int main(int argc, char **argv) { static char *string = "Hello World!"; Display *display; int screen_num; Window win; //窗口ID unsigned int width, height; //窗口尺寸 unsigned int border_width = 0; //边界空白 unsigned int display_width, display_height;//屏幕尺寸 int count; XEvent report; GC gc; unsigned long valuemask = 0; XGCValues values; char *display_name = NULL; //attribute vars XSizeHints size_hints; XSetWindowAttributes attrib; unsigned long attribmask; //moving window Window root, child; unsigned int mask; int root_x, root_y, win_x, win_y, orig_x, orig_y; // 和X 服务器连接 if ( (display=XOpenDisplay(display_name)) == NULL ) { printf("Cannot connect to X server %s\n", XDisplayName(display_name)); exit(-1); } //获得缺省的 screen_num screen_num = DefaultScreen(display); //获得屏幕的宽度和高度 display_width = DisplayWidth(display, screen_num); display_height = DisplayHeight(display, screen_num); //指定所建立窗口的宽度和高度 width = display_width/3; height = display_height/4; //建立窗口 win = XCreateSimpleWindow(display, //display RootWindow(display,screen_num), //父窗口 100, 100, width, height, //位置和大小 border_width, //边界宽度 BlackPixel(display,screen_num), //前景色 WhitePixel(display,screen_num));//背景色 //设置属性 attrib.override_redirect = True; attribmask = CWOverrideRedirect; XChangeWindowAttributes(display, win, attribmask, &attrib); //选择窗口感兴趣的事件掩码 XSelectInput(display, win, ExposureMask | KeyPressMask | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask); //建立GC gc = DefaultGC(display, screen_num); //显示窗口 XMapWindow(display, win); //设置为键盘聚焦窗口 XSetInputFocus(display, win, False, CurrentTime); //进入事件循环 while (1) { //取得队列中的事件 XNextEvent(display, &report); switch (report.type) { //曝光事件, 窗口应重绘 case Expose: //取得最后一个曝光事件 if (report.xexpose.count != 0) break; draw(display, win, gc); break; //窗口尺寸改变, 重新取得窗口的宽度和高度 case ConfigureNotify: break; //取得位置 case ButtonPress: //把窗口浮动到最上方 XRaiseWindow(display, win); //设置键盘聚焦 XSetInputFocus(display, win, False,CurrentTime); //取得指针相对于根窗口的位置和窗口的位置 XQueryPointer(display,win,&root,&child, &root_x, &root_y, &win_x, &win_y, &mask); orig_x = root_x - win_x; orig_y = root_y - win_y; break; case MotionNotify: { int rx, ry, winx, winy; //取得指针相对于根窗口的位置和窗口的位置 XQueryPointer(display,win,&root,&child, &rx, &ry, &winx, &winy, &mask); //移动窗口 XMoveWindow(display, win, rx - root_x + orig_x, ry - root_y + orig_y); } break; case ButtonRelease: break; case KeyPress: { char buffer[1024] = ""; KeySym keysym; //按键符号 int count; //返回的buffer中内容的长度 XComposeStatus compose; //Compose状态 XWindowAttributes xa; unsigned int w, h; XGetWindowAttributes(display,win,&xa); w = xa.width; h = xa.height; //尖头移动窗口 count = XLookupString(&report.xkey,buffer, 1024, &keysym, &compose); if(keysym == XK_Up){ if(h > 10) h -= 2; //改变窗口大小 XResizeWindow(display, win, w, h); } else if(keysym == XK_Down) { h += 2; XResizeWindow(display, win, w, h); } else if(keysym == XK_Left) { if(w > 10) w -= 2; XResizeWindow(display, win, w, h); } else if(keysym == XK_Right) { w += 2; XResizeWindow(display, win, w, h); } else if(keysym == XK_Escape) { exit(0); } } break; default: break; } } }
void gui_move_window(winlist_t *win) { xccore_t *xccore = (xccore_t *)win->data; int event_x, event_y; int offset_x, offset_y; int move_x, move_y; GC moveGC; int draw_flag = False; int workarea_x, workarea_y; int workarea_x2, workarea_y2; unsigned int workarea_width, workarea_height; gui_get_workarea(&workarea_x, &workarea_y, &workarea_width, &workarea_height); workarea_x2 = workarea_x + workarea_width; workarea_y2 = workarea_y + workarea_height; gui_get_mouse_xy(&event_x, &event_y); offset_x = event_x - win->pos_x; offset_y = event_y - win->pos_y; moveGC = XCreateGC(gui->display, gui->root, 0, NULL); XSetSubwindowMode(gui->display, moveGC, IncludeInferiors); XSetForeground(gui->display, moveGC, BlackPixel(gui->display, gui->screen)); XSetFunction(gui->display, moveGC, GXxor); XChangeActivePointerGrab(gui->display, PointerMotionMask | ButtonMotionMask | ButtonReleaseMask | OwnerGrabButtonMask, None, CurrentTime); XGrabServer(gui->display); XEvent myevent; while(1) { XNextEvent(gui->display, &myevent); switch(myevent.type) { case ButtonRelease: if(myevent.xbutton.button == Button1) { if (draw_flag) { gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height); } XFreeGC(gui->display, moveGC); gui_get_mouse_xy(&move_x, &move_y); win->pos_x = move_x - offset_x; win->pos_y = move_y - offset_y; /* */ if (win->pos_x < workarea_x) win->pos_x = workarea_x; if (win->pos_y < workarea_y) win->pos_y = workarea_y; if (win->pos_x + win->width > workarea_x2) win->pos_x = workarea_x2 - win->width - 2; if (win->pos_y + win->height > workarea_y2) win->pos_y = workarea_y2 - win->height - 2; XMoveWindow(gui->display, win->window, win->pos_x, win->pos_y); XUngrabServer(gui->display); gui_save_window_pos(); /* 儲存視窗位置 */ return; } break; case MotionNotify: if (draw_flag) { gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height); } gui_get_mouse_xy(&move_x, &move_y); gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height); draw_flag = True; break; default: break; } } }
ibool MGLAPI XWINDC_initDriver(void *data,MGLDC *dc,int driverId,int modeId,ulong hwnd, int virtualX,int virtualY,int numBuffers,ibool stereo,int refreshRate) /**************************************************************************** * * Function: XWINDC_initDriver * Parameters: dc - Device context. * Returns: True if the device was correctly initialised. * * Description: Initialises the device driver, and starts the specified * graphics mode. This is also where we fill in all of the * vectors in the device context to initialise our device * context properly. * ****************************************************************************/ { Screen *scr; XSetWindowAttributes xswa; Display *dpy = dc->wm.xwindc.dpy; XVisualInfo *visinfo, vis; int nvis, npfv; Window root; int x,y; unsigned int w,h, bw, d; XPixmapFormatValues *pfv; _MGL_initInternal(); dc->deviceType = MGL_WINDOWED_DEVICE; dc->xInch = dc->yInch = 0; g_state.d.hardwareCursor = false; dc->v = &g_state; dc->v->m.refCount++; dc->wm.xwindc.scr = scr = DefaultScreenOfDisplay(dpy); dc->wm.xwindc.gc = DefaultGCOfScreen(scr); xswa.background_pixel = BlackPixel(dpy,XScreenNumberOfScreen(scr)); xswa.backing_store = Always; dc->wm.xwindc.wnd = hwnd; XGetGeometry(dpy, hwnd, &root, &x, &y, &w, &h, &bw, &d); dc->mi.xRes = w; dc->mi.yRes = h; dc->mi.maxPage = 0; dc->mi.bytesPerLine = 0; dc->mi.pageSize = 0; dc->surface = NULL; dc->mi.bitsPerPixel = dc->wm.xwindc.depth = d; vis.visualid = XVisualIDFromVisual(DefaultVisual(dpy, XScreenNumberOfScreen(scr))); visinfo = XGetVisualInfo(dpy, VisualIDMask, &vis, &nvis); pfv = XListPixmapFormats(dpy, &npfv); switch (d) { case 8: dc->mi.maxColor = 0xFFUL; break; case 15: dc->mi.maxColor = 0x7FFFUL; dc->pf= _MGL_pixelFormats[pfRGB555]; break; case 16: dc->mi.maxColor = 0xFFFFUL; dc->pf= _MGL_pixelFormats[visinfo->green_mask==0x7e0 ? pfRGB565 : pfRGB555]; break; case 24: { int i; dc->mi.maxColor = 0xFFFFFFUL; for(i=0; i<npfv; i++) if(pfv[i].depth == 24) break; if(pfv[i].bits_per_pixel==32){ dc->mi.bitsPerPixel = 32; dc->pf= _MGL_pixelFormats[pfARGB32]; }else dc->pf= _MGL_pixelFormats[pfRGB24]; break; } case 32: dc->mi.maxColor = 0xFFFFFFFFUL; dc->pf= _MGL_pixelFormats[pfARGB32]; break; } XFree(visinfo); if(d == 8){ // Set up the private colormap if necesary dc->wm.xwindc.hpal = xswa.colormap = XCreateColormap(dpy, hwnd, DefaultVisualOfScreen(scr), AllocAll); XChangeWindowAttributes(dpy, hwnd, CWColormap, &xswa); } XMapRaised(dpy, hwnd); XClearWindow(dpy, hwnd); XWIN_initInternal(dc); dc->v->w.destroy = destroyDC; dc->r.realizePalette = XWIN_realizePalette; dc->r.getDefaultPalette = XWIN_getDefaultPalette; dc->r.putImage = XWIN_putImage; return true; }
void XMessageBox::repaint() { int white = WhitePixel(mDisplay, DefaultScreen(mDisplay)); int black = BlackPixel(mDisplay, DefaultScreen(mDisplay)); int x = 0; int y = 0; // line V margin y = y + MessageBox_LineVMargin * 2; // line H margin x = MessageBox_LineHMargin; XSetForeground(mDisplay, mGC, black); for (unsigned int i = 0; i < mMessageLines.size(); ++i) { XDrawString(mDisplay, mWin, mGC, x, y, mMessageLines[i], strlen(mMessageLines[i])); if (i < (mMessageLines.size() - 1)) y = y + MessageBox_LineSpacer + mFontHeight; } XFlush(mDisplay); // line V margin y = y + MessageBox_LineVMargin; int maxButWidth = MessageBox_ButtonBoxWidth; int maxButHeight = MessageBox_ButtonBoxHeight; // compute size of text labels on buttons int fgColor, bgColor; int fontDirection, fontAscent, fontDescent; Vector<XMessageBoxButton>::iterator iter; for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) { XCharStruct strInfo; XTextExtents(mFS, iter->getLabel(), strlen(iter->getLabel()), &fontDirection, &fontAscent, &fontDescent, &strInfo); // if (maxButWidth < strInfo.width) // maxButWidth = strInfo.width; // if (maxButHeight < (strInfo.ascent + strInfo.descent)) // maxButHeight = (strInfo.ascent + strInfo.descent); iter->setLabelWidth(strInfo.width); } int buttonBoxWidth = maxButWidth; int buttonBoxHeight = maxButHeight; // draw buttons // button V margin y = y + MessageBox_ButtonVMargin; // center the buttons x = MessageBox_ButtonHMargin + (mMBWidth - getButtonLineWidth()) / 2; for (iter = mButtons.begin(); iter != mButtons.end(); ++iter) { if (iter->drawReverse()) { fgColor = white; bgColor = black; } else { fgColor = black; bgColor = white; } XSetForeground(mDisplay, mGC, bgColor); XFillRectangle(mDisplay, mWin, mGC, x, y, buttonBoxWidth, buttonBoxHeight); XSetForeground(mDisplay, mGC, fgColor); XDrawRectangle(mDisplay, mWin, mGC, x, y, buttonBoxWidth, buttonBoxHeight); XDrawString(mDisplay, mWin, mGC, x + ((buttonBoxWidth - iter->getLabelWidth()) / 2), y + mFontAscent + ((buttonBoxHeight - mFontAscent) / 2), iter->getLabel(), strlen(iter->getLabel())); iter->setButtonRect(x, y, buttonBoxWidth, buttonBoxHeight); x = x + buttonBoxWidth + MessageBox_ButtonSpacer; } }
static gboolean skype_connect() { Window root; Atom skype_inst; Atom type_ret; int format_ret; unsigned long nitems_ret; unsigned long bytes_after_ret; unsigned char *prop; int status; x11_error_code = 0; XSetErrorHandler(x11_error_handler); skype_debug_info("skype_x11", "Set the XErrorHandler\n"); #ifdef USE_XVFB_SERVER if (!getenv("SKYPEDISPLAY")) setenv("SKYPEDISPLAY", ":25", 0); #endif if (getenv("SKYPEDISPLAY")) disp = XOpenDisplay(getenv("SKYPEDISPLAY")); else disp = XOpenDisplay(getenv("DISPLAY")); if (disp == NULL) { skype_debug_info("skype_x11", "Couldn't open display\n"); return FALSE; } skype_debug_info("skype_x11", "Opened display\n"); message_start = XInternAtom( disp, "SKYPECONTROLAPI_MESSAGE_BEGIN", False ); message_continue = XInternAtom( disp, "SKYPECONTROLAPI_MESSAGE", False ); root = DefaultRootWindow( disp ); win = XCreateSimpleWindow( disp, root, 0, 0, 1, 1, 0, BlackPixel( disp, DefaultScreen( disp ) ), BlackPixel( disp, DefaultScreen( disp ) )); XFlush(disp); if (win == None) { XCloseDisplay(disp); disp = NULL; skype_debug_info("skype_x11", "Could not create X11 messaging window\n"); return FALSE; } skype_debug_info("skype_x11", "Created X11 messaging window\n"); skype_inst = XInternAtom(disp, "_SKYPE_INSTANCE", True); if (skype_inst == None) { XDestroyWindow(disp, win); XCloseDisplay(disp); win = (Window)None; disp = NULL; skype_debug_info("skype_x11", "Could not create skype Atom\n"); return FALSE; } skype_debug_info("skype_x11", "Created skype Atom\n"); status = XGetWindowProperty(disp, root, skype_inst, 0, 1, False, XA_WINDOW, &type_ret, &format_ret, &nitems_ret, &bytes_after_ret, &prop); if(status != Success || format_ret != 32 || nitems_ret < 1) { XDestroyWindow(disp, win); XCloseDisplay(disp); win = (Window)None; XFree(prop); disp = NULL; skype_debug_info("skype", "Skype instance not found\n"); return FALSE; } skype_debug_info("skype_x11", "Skype instance found\n"); skype_win = * (const unsigned long *) prop & 0xffffffff; XFree(prop); run_loop = TRUE; skype_debug_info("skype_x11", "Charging lasers...\n"); receiving_thread = g_thread_create((GThreadFunc)receive_message_loop, NULL, FALSE, NULL); return TRUE; }
// #includ ur #life int main(int argc, char *argv[]) { bool q = false; if(argv[1] != NULL && strcmp(argv[1], "-q") == 0) q=true; Display *disp; Window win; XEvent e; int screen; int winy = 0; int winx = 0; int winheight = 300; int winwidth = 500; int borderwidth = 10; int stdcposx = 20; int stdcposy = 20; int cposx = stdcposx; int cposy = stdcposy; int lastdeltime = 0; int lastrowlength = 0; int lastkeysym = 0; char *msg = "Clear"; int bwidth=strlen(msg)*6; int bheight=15; int btop=20; int bmargin = 2; int bleft=winwidth - bwidth - 20; GC white; XColor white_color; Colormap colormap; char whiteidk[] = "#FFFFFF"; GC red; XColor red_color; Colormap rcolormap; char redidk[] = "#FF0000"; disp = XOpenDisplay(NULL); if (disp == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); } screen = DefaultScreen(disp); win = XCreateSimpleWindow(disp, RootWindow(disp, screen), winx, winy, winwidth, winheight, borderwidth, BlackPixel(disp, screen), WhitePixel(disp, screen)); XSelectInput(disp, win, ExposureMask | KeyPressMask | ButtonPressMask); // Window XCreateWindow(display, parent, x, y, width, height, border_width, depth, // class, visual, valuemask, attributes) XMapWindow(disp, win); colormap = DefaultColormap(disp, 0); white = XCreateGC(disp, win, 0, 0); XParseColor(disp, colormap, whiteidk, &white_color); XAllocColor(disp, colormap, &white_color); XSetForeground(disp, white, white_color.pixel); rcolormap = DefaultColormap(disp, 0); red = XCreateGC(disp, win, 0, 0); XParseColor(disp, colormap, redidk, &red_color); XAllocColor(disp, colormap, &red_color); XSetForeground(disp, red, red_color.pixel); while (1) { XNextEvent(disp, &e); if (e.type == Expose) { XFillRectangle(disp, win, red, bleft, btop, bwidth, bheight); XDrawString(disp, win, white, bleft+bmargin, btop+bmargin+9, msg, strlen(msg)); //http://tronche.com/gui/x/xlib/graphics/drawing-text/XDrawString.html } if(e.type == 4) // button press { int x=e.xbutton.x; int y=e.xbutton.y; int button = e.xbutton.button; if(!q) printf("Button pressed. X: %d, Y: %d Button: %d\n",x,y,button); if(button == 1) { if(y < bheight+btop && x < bwidth+bleft) { if(y > btop && x > bleft) { if(!q) printf("You've hitten the button!!\nClearing...\n"); XFillRectangle(disp, win, white, 0, 0, winwidth, winheight); cposx = stdcposx; cposy = stdcposy; if(!q) printf("Repainting clearbutton...\n"); XFillRectangle(disp, win, red, bleft, btop, bwidth, bheight); XDrawString(disp, win, white, bleft+bmargin, btop+bmargin+9, msg, strlen(msg)); } } } } if (e.type == KeyPress) { if(!q) printf("Keycode: %d\n", e.xkey.keycode); unsigned long keysym = XLookupKeysym(&e.xkey, 0); if(!q) printf("Keysym: %lu\n",keysym); char *ascii = XKeysymToString(keysym); if(!q) printf("ASCII: %s\n",ascii); if(keysym == 65307 && lastkeysym == 65406) // alt+ESC { printf("Exiting...\n"); return 0; } else if(keysym == 65293) // line break { cposy+=10; lastrowlength = cposx; cposx = stdcposx; } else if(keysym == 32) // " " { cposx+=6; } else if(keysym == 65288) // delete { time_t now = time(0); if(!q) printf("Time: %ld\n",now); int diff = now-lastdeltime; if(!q) printf("Time since last deletion: %d\n",diff); XFillRectangle(disp, win, white, cposx-6, cposy-9, 6, 11); if(diff == 0) { XFillRectangle(disp, win, white, cposx-12, cposy-9, 6, 11); } lastdeltime = now; if(cposx <= stdcposx) { if(cposy != stdcposy) { cposy-=10; cposx = lastrowlength; } } else { cposx-=6; if(diff == 0 && cposx-6 > stdcposx) { cposx-=6; } } } else if(keysym == 43) // plus { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, "+", 1); cposx+=6; } else if(keysym == 44) // comma { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ",", 1); cposx+=6; } else if(keysym == 45) // minus { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, "-", 1); cposx+=6; } else if(keysym == 46) // period { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ".", 1); cposx+=6; } else if(keysym == 65289) // tab { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, " ", 3); cposx+=18; } else { if(lastkeysym != 65506 || lastkeysym != 65505) { if(keysym == 49) { ascii = "!"; } else if(keysym == 43) { ascii = "?"; } } if(keysym != 65506 && keysym != 65505) { XDrawString(disp, win, DefaultGC(disp, screen), cposx, cposy, ascii, strlen(ascii)); cposx+=strlen(ascii)*6; } } lastkeysym = keysym; } } XCloseDisplay(disp); return 0; }