len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-12-09 13:15:18 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

moved X11-specific files into a separate subdir to keep root clean for

Browse source 
target files


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@282 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Daniel Stenberg 2002-04-27 23:48:49 +00:00
parent c1543511b3
commit 3caa3c0871
17 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

82
uisimulator/x11/Makefile Normal file
View file

@ -0,0 +1,82 @@
############################################################################
# __________ __ ___.
# Open \______ \ ____ ____ | | _\_ |__ _______ ___
# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
# \/ \/ \/ \/ \/
# $Id$
#
# Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se>
#
# All files in this archive are subject to the GNU General Public License.
# See the file COPYING in the source tree root for full license agreement.
#
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
# KIND, either express or implied.
#
############################################################################
TARGET = rockboxui
FIRMWAREDIR = ../firmware
DRIVERS = $(FIRMWAREDIR)/drivers
CC = gcc
RM = rm -f
DEBUG = -g
DEFINES = -DHAVE_CONFIG_H -DGETTIMEOFDAY_TWO_ARGS -DSIMULATOR -DHAVE_LCD_BITMAP
LDFLAGS = -lX11 -lm -lXt -lXmu -lnsl
UNAME := $(shell uname)
ifeq ($(UNAME),Linux)
INCLUDES = -I/usr/X11R6/include -I$(DRIVERS) -I$(FIRMWAREDIR)
LIBDIRS = -L/usr/X11R6/lib
else
INCLUDES = -I$(FIRMWAREDIR)
LIBDIRS =
endif
CFLAGS = $(DEBUG) $(DEFINES) $(INCLUDES)
#SRCS = $(wildcard *.c)
SRCS = screenhack.c uibasic.c resources.c visual.c lcd.c lcd-x11.c \
button-x11.c chartables.c tetris.c app.c
OBJS := $(SRCS:c=o)
all: $(TARGET)
clean:
$(RM) $(OBJS) *~ core $(TARGET) $(CLIENTS)
$(RM) -r $(DEPS)
distclean: clean
$(RM) config.cache
lcd.o: $(DRIVERS)/lcd.c
$(CC) $(CFLAGS) -c $< -o $@
chartables.o: $(FIRMWAREDIR)/chartables.c
$(CC) $(CFLAGS) -c $< -o $@
.c.o:
$(CC) $(CFLAGS) -c $<
$(TARGET): $(OBJS)
$(CC) -o $(TARGET) $(LIBDIRS) $(LDFLAGS) $(OBJS)
DEPS:=.deps
$(DEPS)/%.d: %.c
@$(SHELL) -c 'if [ ! -d $(DEPS) ]; then \
echo Creating the dependency directory: $(DEPS); \
mkdir $(DEPS); fi'
@echo "Updating Dependencies for $<"
@$(SHELL) -ec '$(CC) -MM $(CFLAGS) $< \
|sed '\''s/\($*\)\.o[ :]*/\1.o $(<:%.c=%.d) : /g'\'' > $@; \
[ -s $@ ] || rm -f $@'
-include $(SRCS:%.c=$(DEPS)/%.d)

9
uisimulator/x11/README Normal file
View file

@ -0,0 +1,9 @@
Solaris
$ make
$ ./rockboxui
Linux
$ make LIBDIRS=-L/usr/X11R6/lib
$ ./rockboxui

108
uisimulator/x11/button-x11.c Normal file
View file

@ -0,0 +1,108 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Björn Stenberg
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define HAVE_RECORDER_KEYPAD
#include "types.h"
#include "button.h"
#include "X11/keysym.h"
/*
*Initialize buttons
*/
void button_init()
{
}
/*
* Translate X keys to Recorder keys
*
* We simulate recorder keys on the numeric keypad:
*
* 4,6,8,2 = Left, Right, Up, Down
* 5 = Play/pause
* Div,Mul,Sub = The tree menu keys
* +,Enter = On, Off
*
*/
static int get_raw_button (void)
{
int k = screenhack_handle_events();
switch(k)
{
case XK_KP_Left:
case XK_Left:
case XK_KP_4:
return BUTTON_LEFT;
case XK_KP_Right:
case XK_Right:
case XK_KP_6:
return BUTTON_RIGHT;
case XK_KP_Up:
case XK_Up:
case XK_KP_8:
return BUTTON_UP;
case XK_KP_Down:
case XK_Down:
case XK_KP_2:
return BUTTON_DOWN;
case XK_KP_Space:
case XK_KP_5:
return BUTTON_PLAY;
case XK_KP_Enter:
return BUTTON_OFF;
case XK_KP_Add:
return BUTTON_ON;
case XK_KP_Divide:
return BUTTON_F1;
case XK_KP_Multiply:
return BUTTON_F2;
case XK_KP_Subtract:
return BUTTON_F3;
default:
return 0;
}
}
/*
* Get the currently pressed button.
* Returns one of BUTTON_xxx codes, with possibly a modifier bit set.
* No modifier bits are set when the button is first pressed.
* BUTTON_HELD bit is while the button is being held.
* BUTTON_REL bit is set when button has been released.
*/
int button_get(void)
{
return get_raw_button();
}
/* -----------------------------------------------------------------
* local variables:
* eval: (load-file "rockbox-mode.el")
* end:
*/

362
uisimulator/x11/config.h Normal file
View file

@ -0,0 +1,362 @@
/* config.h. Generated automatically by configure. */
/* config.h.in --- xscreensaver, Copyright (c) 1998 Jamie Zawinski.
*
* The best way to set these parameters is by running the included `configure'
* script. That examines your system, and generates `config.h' from
* `config.h.in'.
*
* If something goes very wrong, you can edit `config.h' directly, but beware
* that your changes will be lost if you ever run `configure' again.
*/
/* *************************************************************************
CONFIGURING SERVER EXTENSIONS
************************************************************************* */
/* Define this if you have the XReadDisplay extension (I think this is an
SGI-only thing; it's in <X11/extensions/readdisplay.h>.) A few of the
screenhacks will take advantage of this if it's available.
*/
/* #undef HAVE_READ_DISPLAY_EXTENSION */
/* Define this if you have the Iris Video Library (dmedia/vl.h on SGI.)
A few of the screenhacks will take advantage of this if it's available.
*/
/* #undef HAVE_SGI_VIDEO */
/* Define this if you have the XHPDisableReset function (an HP only thing.)
*/
/* #undef HAVE_XHPDISABLERESET */
/* First, some background: there are three distinct server extensions which
* are useful to a screen saver program: they are XIDLE, MIT-SCREEN-SAVER,
* and SCREEN_SAVER.
*
* The XIDLE extension resides in .../contrib/extensions/xidle/ on the X11R5
* contrib tape. This extension lets the client get accurate idle-time
* information from the X server in a potentially more reliable way than by
* simply watching for keyboard and mouse activity. However, the XIDLE
* extension has apparently not been ported to X11R6.
*
* The SCREEN_SAVER extension is found (as far as I know) only in the SGI
* X server, and it exists in all releases since (at least) Irix 5. The
* relevant header file is /usr/include/X11/extensions/XScreenSaver.h.
*
* The similarly-named MIT-SCREEN-SAVER extension came into existence long
* after the SGI SCREEN_SAVER extension was already in use, and resides in
* .../contrib/extensions/screensaver/ on the X11R6 contrib tape. It is
* also found in certain recent X servers built in to NCD X terminals.
*
* The MIT extension does basically the same thing that the XIDLE extension
* does, but there are two things wrong with it: first, because of the way
* the extension was designed, the `fade' option to XScreenSaver will be
* uglier: just before the screen fades out, there will be an unattractive
* flicker to black, because this extension blanks the screen *before*
* telling us that it is time to do so. Second, this extension is known to
* be buggy; on the systems I use, it works, but some people have reported
* X server crashes as a result of using it. XScreenSaver uses this
* extension rather conservatively, because when I tried to use any of its
* more complicated features, I could get it to crash the server at the
* drop of a hat.
*
* In short, the MIT-SCREEN-SAVER extension is a piece of junk. The older
* SGI SCREEN_SAVER extension works great, as does XIDLE. It would be nice
* If those two existed on more systems, that is, would be adopted by the
* X Consortium in favor of their inferior "not-invented-here" entry.
*/
/* Define this if you have the XIDLE extension installed. If you have the
* XIDLE extension, this is recommended. (You have this extension if the
* file /usr/include/X11/extensions/xidle.h exists.) Turning on this flag
* lets XScreenSaver work better with servers which support this extension;
* but it will still work with servers which do not suport it, so it's a good
* idea to compile in support for it if you can.
*/
/* #undef HAVE_XIDLE_EXTENSION */
/* Define this if you have the MIT-SCREEN-SAVER extension installed. See the
* caveats about this extension, above. (It's available if the file
* /usr/include/X11/extensions/scrnsaver.h exists.)
*/
#define HAVE_MIT_SAVER_EXTENSION 1
/* Define this if you have the SGI SCREEN_SAVER extension. This is standard
* on Irix systems, and not available elsewhere.
*/
/* #undef HAVE_SGI_SAVER_EXTENSION */
/* Define this if you have the SGI-VIDEO-CONTROL extension. This is standard
* on Irix systems, and not available elsewhere.
*/
/* #undef HAVE_SGI_VC_EXTENSION */
/* Define this if you have the XDPMS extension. This is standard on
* sufficiently-recent XFree86 systems, and possibly elsewhere. (It's
* available if the file /usr/include/X11/extensions/dpms.h exists.)
*/
/* #undef HAVE_DPMS_EXTENSION */
/* Define this if you have the functions XF86VidModeGetModeLine() and
* XF86VidModeGetViewPort(), in support of virtual desktops where the
* X server's root window is bigger than the actual screen. This is
* an XFree86 thing, and probably doesn't exist elsewhere. (It's
* available if the file /usr/include/X11/extensions/xf86vmode.h exists.)
*/
/* #undef HAVE_XF86VMODE */
/* Define this if you have a Linux-like /proc/interrupts file which can be
* examined to determine when keyboard activity has occurred.
*/
/* #undef HAVE_PROC_INTERRUPTS */
/* *************************************************************************
CONFIGURING GRAPHICS TOOLKITS
************************************************************************* */
/* Define this if you have Motif.
*/
#define HAVE_MOTIF 1
/* Define this if you have Gtk.
*/
/* #undef HAVE_GTK */
/* Define this if you have Athena (-Xaw).
*/
#define HAVE_ATHENA 1
/* Define this if you have Athena, and the version you have includes the
* XawViewportSetCoordinates function in Viewport.h (some old versions of
* the library didn't have this function.)
*/
#define HAVE_XawViewportSetCoordinates 1
/* Define this if you have the XPM library installed. Some of the demos can
* make use of this if it is available.
*/
#define HAVE_XPM 1
/* Define this if you have the Xmu library. This is standard part of X, and
* if your vendor doesn't ship it, you should report that as a bug.
*/
#define HAVE_XMU 1
/* Define this if you have OpenGL. Some of the demos require it, so if you
* don't have it, then those particular demos won't be built. (This won't
* affect the screen saver as a whole.)
*/
/* #undef HAVE_GL */
/* Define this if you have OpenGL, but it's the MesaGL variant. (The
libraries have different names.) (HAVE_GL should be defined too.)
*/
/* #undef HAVE_MESA_GL */
/* Define this if your version of OpenGL has the glBindTexture() routine.
This is the case for OpenGL 1.1, but not for OpenGL 1.0.
*/
/* #undef HAVE_GLBINDTEXTURE */
/* Define this if you have the -lgle and -lmatrix libraries (GL extrusion.)
*/
/* #undef HAVE_GLE */
/* Define this if the `xscreensaver' process itself (the driver process)
should be linked against GL. Most systems won't want this (in particular,
if you're using Linux and/or Mesa, you don't want this) but SGI systems
do want this. It may also be useful on other systems that have serious
GL support -- you only need this if you have a lot of different visuals,
not all of which work with GL programs.
*/
/* #undef DAEMON_USE_GL */
/* Define this if you have the X Shared Memory Extension.
*/
#define HAVE_XSHM_EXTENSION 1
/* Define this if you have the X Double Buffer Extension.
*/
#define HAVE_DOUBLE_BUFFER_EXTENSION 1
/* Some screenhacks like to run an external program to generate random pieces
of text; set this to the one you like ("yow" and "fortune" are the most
likely prospects.) Note that this is just the default; X resources can
be used to override it.
*/
#define ZIPPY_PROGRAM "/usr/local/libexec/emacs/20.4/sparc-sun-solaris2.6/yow"
/* *************************************************************************
CONFIGURING PASSWORD AUTHENTICATION
************************************************************************* */
/* Define this to remove the option of locking the screen at all.
*/
/* #undef NO_LOCKING */
/* Define this if you want to use Kerberos authentication to lock/unlock the
* screen instead of your local password. This currently uses Kerberos V4,
* but a V5 server with V4 compatibility will work. WARNING: DO NOT USE AFS
* string-to-key passwords with this option. This option currently *only*
* works with standard Kerberos des_string_to_key. If your password is an
* AFS password and not a kerberos password, it will not authenticate
* properly. See the comments in driver/kpasswd.c for more information if you
* need it.
*/
/* #undef HAVE_KERBEROS */
/* Define this if you want to use PAM (Pluggable Authentication Modules)
* to lock/unlock the screen, instead of standard /etc/passwd authentication.
*/
/* #undef HAVE_PAM */
/* If PAM is being used, this is the name of the PAM service that xscreensaver
* will authenticate as. The default is "xscreensaver", which means that the
* PAM library will look for an "xscreensaver" line in /etc/pam.conf, or (on
* recent Linux systems) will look for a file called /etc/pam.d/xscreensaver.
* Some systems might already have a PAM installation that is configured for
* xlock, so setting this to "xlock" would also work in that case.
*/
#define PAM_SERVICE_NAME "xscreensaver"
/* Define if you have PAM and pam_strerror() requires two arguments. */
/* #undef PAM_STRERROR_TWO_ARGS */
/* Define this if your system uses `shadow' passwords, that is, the passwords
* live in /etc/shadow instead of /etc/passwd, and one reads them with
* getspnam() instead of getpwnam(). (Note that SCO systems do some random
* other thing; others might as well. See the ifdefs in driver/passwd-pwent.c
* if you're having trouble related to reading passwords.)
*/
#define HAVE_SHADOW_PASSWD 1
/* Define this if your system is Digital or SCO Unix with so-called ``Enhanced
Security'', that is, the passwords live in /tcb/files/auth/<x>/<xyz>
instead of in /etc/passwd, and one reads them with getprpwnam() instead
of getpwnam().
*/
/* #undef HAVE_ENHANCED_PASSWD */
/* Define this if your system is Solaris with ``adjunct'' passwords (this is
the version where one gets at the passwords with getpwanam() instead of
getpwnam().) I haven't tested this one, let me know if it works.
*/
/* #undef HAVE_ADJUNCT_PASSWD */
/* Define this if you are running HPUX with so-called ``Secure Passwords''
(if you have /usr/include/hpsecurity.h, you probably have this.) I
haven't tested this one, let me know if it works.
*/
/* #undef HAVE_HPUX_PASSWD */
/* Define this if you are on a system that supports the VT_LOCKSWITCH and
VT_UNLOCKSWITCH ioctls. If this is defined, then when the screen is
locked, switching to another virtual terminal will also be prevented.
That is, the whole console will be locked, rather than just the VT on
which X is running. (Well, that's the theory anyway -- in practice,
I haven't yet figured out how to make that work.)
*/
/* #undef HAVE_VT_LOCKSWITCH */
/* Define this if you the openlog(), syslog(), and closelog() functions.
This is used for logging failed login attempts.
*/
#define HAVE_SYSLOG 1
/* *************************************************************************
OTHER C ENVIRONMENT JUNK
************************************************************************* */
/* Define this to void* if you're using X11R4 or earlier. */
/* #undef XPointer */
/* Define if you have the nice function. */
#define HAVE_NICE 1
/* Define if you have the setpriority function. */
#define HAVE_SETPRIORITY 1
/* Define to empty if the keyword does not work. */
/* #undef const */
/* Define if you have <sys/wait.h> that is POSIX.1 compatible. */
#define HAVE_SYS_WAIT_H 1
/* Define as __inline if that's what the C compiler calls it. */
/* #undef inline */
/* Define to `int' if <sys/types.h> doesn't define. */
/* #undef mode_t */
/* Define to `int' if <sys/types.h> doesn't define. */
/* #undef pid_t */
/* Define as the return type of signal handlers (int or void). */
#define RETSIGTYPE void
/* Define to `unsigned' if <sys/types.h> doesn't define. */
/* #undef size_t */
/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define if you can safely include both <sys/time.h> and <time.h>. */
#define TIME_WITH_SYS_TIME 1
/* Define if you have the gettimeofday function. */
#define HAVE_GETTIMEOFDAY 1
/* Define if gettimeofday requires two arguments. */
#define GETTIMEOFDAY_TWO_ARGS 1
/* Define if you have the putenv function. */
#define HAVE_PUTENV 1
/* Define if you have the select function. */
#define HAVE_SELECT 1
/* Define if you have the getcwd function. */
#define HAVE_GETCWD 1
/* Define if you have the getcwd function. */
#define HAVE_GETWD 1
/* Define if you have the realpath function. */
#define HAVE_REALPATH 1
/* Define if you have the uname function. */
#define HAVE_UNAME 1
/* Define if you have the fcntl function. */
#define HAVE_FCNTL 1
/* Define if you have the sigaction function. */
#define HAVE_SIGACTION 1
/* Define if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Define if you have the <crypt.h> header file. */
#define HAVE_CRYPT_H 1
/* Define if you have <sys/select.h> that defines fd_set and FD_SET. */
#define HAVE_SYS_SELECT_H 1
/* Define to use sigaction() instead of signal() for SIGCHLD-related activity.
This is necessary at least on SCO OpenServer 5, due to a Unix kernel bug.
*/
/* #undef USE_SIGACTION */
/* Define this if you do pings with a `struct icmp' and a `icmp_id' slot.
*/
#define HAVE_ICMP 1
/* Define this if you do pings with a `struct icmphdr' and a `un.echo.id' slot.
*/
/* #undef HAVE_ICMPHDR */

109
uisimulator/x11/lcd-x11.c Normal file
View file

@ -0,0 +1,109 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se>
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include "screenhack.h"
/*
* Specific implementations for X11, using the generic LCD API and data.
*/
#include "lcd-x11.h"
extern unsigned char display[LCD_WIDTH][LCD_HEIGHT/8];
extern void screen_resized(int width, int height);
extern Display *dpy;
unsigned char display_copy[LCD_WIDTH][LCD_HEIGHT/8];
void lcd_update (void)
{
int x, y;
int p=0;
int bit;
XPoint points[LCD_WIDTH * LCD_HEIGHT];
int cp=0;
XPoint clearpoints[LCD_WIDTH * LCD_HEIGHT];
#if 0
screen_resized(LCD_WIDTH, LCD_HEIGHT);
for(y=0; y<LCD_HEIGHT; y+=8) {
for(x=0; x<LCD_WIDTH; x++) {
if(display[x][y/8]) {
/* one or more bits/pixels are set */
for(bit=0; bit<8; bit++) {
if(display[x][y/8]&(1<<bit)) {
points[p].x = x + MARGIN_X;
points[p].y = y+bit + MARGIN_Y;
p++; /* increase the point counter */
}
}
}
}
}
#else
for(y=0; y<LCD_HEIGHT; y+=8) {
for(x=0; x<LCD_WIDTH; x++) {
if(display[x][y/8] || display_copy[x][y/8]) {
/* one or more bits/pixels are changed */
unsigned char diff =
display[x][y/8] ^ display_copy[x][y/8];
for(bit=0; bit<8; bit++) {
if(display[x][y/8]&(1<<bit)) {
/* set a dot */
points[p].x = x + MARGIN_X;
points[p].y = y+bit + MARGIN_Y;
p++; /* increase the point counter */
}
else if(diff &(1<<bit)) {
/* clear a dot */
clearpoints[cp].x = x + MARGIN_X;
clearpoints[cp].y = y+bit + MARGIN_Y;
cp++; /* increase the point counter */
}
}
}
}
}
/* copy a huge block */
memcpy(display_copy, display, sizeof(display));
#endif
drawdots(1, &points[0], p);
drawdots(0, &clearpoints[0], cp);
fprintf(stderr, "lcd_update: Draws %d pixels, clears %d pixels\n", p, cp);
XSync(dpy,False);
}

24
uisimulator/x11/lcd-x11.h Normal file
View file

@ -0,0 +1,24 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se>
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define MARGIN_X 3
#define MARGIN_Y 3
/* include the "real" lcd.h file here */
#include <lcd.h>

231
uisimulator/x11/resources.c Normal file
View file

@ -0,0 +1,231 @@
/* xscreensaver, Copyright (c) 1992, 1997, 1998
* Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
#include "utils.h"
#include "resources.h"
#include <X11/Xresource.h>
/* Resource functions. Assumes: */
extern char *progname;
extern char *progclass;
extern XrmDatabase db;
static unsigned int get_time_resource (char *res_name, char *res_class,
Bool sec_p);
#ifndef isupper
# define isupper(c) ((c) >= 'A' && (c) <= 'Z')
#endif
#ifndef _tolower
# define _tolower(c) ((c) - 'A' + 'a')
#endif
char *
get_string_resource (char *res_name, char *res_class)
{
XrmValue value;
char *type;
char full_name [1024], full_class [1024];
strcpy (full_name, progname);
strcat (full_name, ".");
strcat (full_name, res_name);
strcpy (full_class, progclass);
strcat (full_class, ".");
strcat (full_class, res_class);
if (XrmGetResource (db, full_name, full_class, &type, &value))
{
char *str = (char *) malloc (value.size + 1);
strncpy (str, (char *) value.addr, value.size);
str [value.size] = 0;
return str;
}
return 0;
}
Bool
get_boolean_resource (char *res_name, char *res_class)
{
char *tmp, buf [100];
char *s = get_string_resource (res_name, res_class);
char *os = s;
if (! s) return 0;
for (tmp = buf; *s; s++)
*tmp++ = isupper (*s) ? _tolower (*s) : *s;
*tmp = 0;
free (os);
while (*buf &&
(buf[strlen(buf)-1] == ' ' ||
buf[strlen(buf)-1] == '\t'))
buf[strlen(buf)-1] = 0;
if (!strcmp (buf, "on") || !strcmp (buf, "true") || !strcmp (buf, "yes"))
return 1;
if (!strcmp (buf,"off") || !strcmp (buf, "false") || !strcmp (buf,"no"))
return 0;
fprintf (stderr, "%s: %s must be boolean, not %s.\n",
progname, res_name, buf);
return 0;
}
int
get_integer_resource (char *res_name, char *res_class)
{
int val;
char c, *s = get_string_resource (res_name, res_class);
char *ss = s;
if (!s) return 0;
while (*ss && *ss <= ' ') ss++; /* skip whitespace */
if (ss[0] == '0' && (ss[1] == 'x' || ss[1] == 'X')) /* 0x: parse as hex */
{
if (1 == sscanf (ss+2, "%x %c", &val, &c))
{
free (s);
return val;
}
}
else /* else parse as dec */
{
if (1 == sscanf (ss, "%d %c", &val, &c))
{
free (s);
return val;
}
}
fprintf (stderr, "%s: %s must be an integer, not %s.\n",
progname, res_name, s);
free (s);
return 0;
}
double
get_float_resource (char *res_name, char *res_class)
{
double val;
char c, *s = get_string_resource (res_name, res_class);
if (! s) return 0.0;
if (1 == sscanf (s, " %lf %c", &val, &c))
{
free (s);
return val;
}
fprintf (stderr, "%s: %s must be a float, not %s.\n",
progname, res_name, s);
free (s);
return 0.0;
}
unsigned int
get_pixel_resource (char *res_name, char *res_class,
Display *dpy, Colormap cmap)
{
XColor color;
char *s = get_string_resource (res_name, res_class);
char *s2;
if (!s) goto DEFAULT;
for (s2 = s + strlen(s) - 1; s2 > s; s2--)
if (*s2 == ' ' || *s2 == '\t')
*s2 = 0;
else
break;
if (! XParseColor (dpy, cmap, s, &color))
{
fprintf (stderr, "%s: can't parse color %s\n", progname, s);
goto DEFAULT;
}
if (! XAllocColor (dpy, cmap, &color))
{
fprintf (stderr, "%s: couldn't allocate color %s\n", progname, s);
goto DEFAULT;
}
free (s);
return color.pixel;
DEFAULT:
if (s) free (s);
return ((strlen(res_class) >= 10 &&
!strcmp ("Background", res_class + strlen(res_class) - 10))
? BlackPixel (dpy, DefaultScreen (dpy))
: WhitePixel (dpy, DefaultScreen (dpy)));
}
int
parse_time (const char *string, Bool seconds_default_p, Bool silent_p)
{
unsigned int h, m, s;
char c;
if (3 == sscanf (string, " %u : %2u : %2u %c", &h, &m, &s, &c))
;
else if (2 == sscanf (string, " : %2u : %2u %c", &m, &s, &c) ||
2 == sscanf (string, " %u : %2u %c", &m, &s, &c))
h = 0;
else if (1 == sscanf (string, " : %2u %c", &s, &c))
h = m = 0;
else if (1 == sscanf (string, " %u %c",
(seconds_default_p ? &s : &m), &c))
{
h = 0;
if (seconds_default_p) m = 0;
else s = 0;
}
else
{
if (! silent_p)
fprintf (stderr, "%s: invalid time interval specification \"%s\".\n",
progname, string);
return -1;
}
if (s >= 60 && (h != 0 || m != 0))
{
if (! silent_p)
fprintf (stderr, "%s: seconds > 59 in \"%s\".\n", progname, string);
return -1;
}
if (m >= 60 && h > 0)
{
if (! silent_p)
fprintf (stderr, "%s: minutes > 59 in \"%s\".\n", progname, string);
return -1;
}
return ((h * 60 * 60) + (m * 60) + s);
}
static unsigned int
get_time_resource (char *res_name, char *res_class, Bool sec_p)
{
int val;
char *s = get_string_resource (res_name, res_class);
if (!s) return 0;
val = parse_time (s, sec_p, False);
free (s);
return (val < 0 ? 0 : val);
}
unsigned int
get_seconds_resource (char *res_name, char *res_class)
{
return get_time_resource (res_name, res_class, True);
}
unsigned int
get_minutes_resource (char *res_name, char *res_class)
{
return get_time_resource (res_name, res_class, False);
}

23
uisimulator/x11/resources.h Normal file
View file

@ -0,0 +1,23 @@
/* xscreensaver, Copyright (c) 1992, 1997 Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
#ifndef __XSCREENSAVER_RESOURCES_H__
#define __XSCREENSAVER_RESOURCES_H__
extern char *get_string_resource (char*,char*);
extern Bool get_boolean_resource (char*,char*);
extern int get_integer_resource (char*,char*);
extern double get_float_resource (char*,char*);
extern unsigned int get_pixel_resource (char*,char*,Display*,Colormap);
extern unsigned int get_minutes_resource (char*,char*);
extern unsigned int get_seconds_resource (char*,char*);
extern int parse_time (const char *string, Bool seconds_default_p,
Bool silent_p);
#endif /* __XSCREENSAVER_RESOURCES_H__ */

576
uisimulator/x11/screenhack.c Normal file
View file

@ -0,0 +1,576 @@
/* xscreensaver, Copyright (c) 1992, 1995, 1997, 1998
* Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
* And remember: X Windows is to graphics hacking as roman numerals are to
* the square root of pi.
*/
/* This file contains simple code to open a window or draw on the root.
The idea being that, when writing a graphics hack, you can just link
with this .o to get all of the uninteresting junk out of the way.
- create a procedure `screenhack(dpy, window)'
- create a variable `char *progclass' which names this program's
resource class.
- create a variable `char defaults []' for the default resources, and
null-terminate it.
- create a variable `XrmOptionDescRec options[]' for the command-line,
and null-terminate it.
And that's it...
*/
#include <stdio.h>
#include <X11/Intrinsic.h>
#include <X11/IntrinsicP.h>
#include <X11/CoreP.h>
#include <X11/Shell.h>
#include <X11/StringDefs.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#ifdef __sgi
# include <X11/SGIScheme.h> /* for SgiUseSchemes() */
#endif /* __sgi */
#ifdef HAVE_XMU
# ifndef VMS
# include <X11/Xmu/Error.h>
# else /* VMS */
# include <Xmu/Error.h>
# endif
#else
# include "xmu.h"
#endif
#include "screenhack.h"
#include "version.h"
#include "vroot.h"
#ifndef isupper
# define isupper(c) ((c) >= 'A' && (c) <= 'Z')
#endif
#ifndef _tolower
# define _tolower(c) ((c) - 'A' + 'a')
#endif
char *progname;
XrmDatabase db;
XtAppContext app;
Bool mono_p;
static XrmOptionDescRec default_options [] = {
{ "-root", ".root", XrmoptionNoArg, "True" },
{ "-window", ".root", XrmoptionNoArg, "False" },
{ "-mono", ".mono", XrmoptionNoArg, "True" },
{ "-install", ".installColormap", XrmoptionNoArg, "True" },
{ "-noinstall",".installColormap", XrmoptionNoArg, "False" },
{ "-visual", ".visualID", XrmoptionSepArg, 0 },
{ "-window-id", ".windowID", XrmoptionSepArg, 0 },
{ 0, 0, 0, 0 }
};
static char *default_defaults[] = {
".root: false",
"*geometry: 200x100", /* this should be .geometry, but nooooo... */
"*mono: false",
"*installColormap: false",
"*visualID: default",
"*windowID: ",
0
};
extern Display* dpy;
static XrmOptionDescRec *merged_options;
static int merged_options_size;
static char **merged_defaults;
static void
merge_options (void)
{
int def_opts_size, opts_size;
int def_defaults_size, defaults_size;
for (def_opts_size = 0; default_options[def_opts_size].option;
def_opts_size++)
;
for (opts_size = 0; options[opts_size].option; opts_size++)
;
merged_options_size = def_opts_size + opts_size;
merged_options = (XrmOptionDescRec *)
malloc ((merged_options_size + 1) * sizeof(*default_options));
memcpy (merged_options, default_options,
(def_opts_size * sizeof(*default_options)));
memcpy (merged_options + def_opts_size, options,
((opts_size + 1) * sizeof(*default_options)));
for (def_defaults_size = 0; default_defaults[def_defaults_size];
def_defaults_size++)
;
for (defaults_size = 0; defaults[defaults_size]; defaults_size++)
;
merged_defaults = (char **)
malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));;
memcpy (merged_defaults, default_defaults,
def_defaults_size * sizeof(*defaults));
memcpy (merged_defaults + def_defaults_size, defaults,
(defaults_size + 1) * sizeof(*defaults));
/* This totally sucks. Xt should behave like this by default.
If the string in `defaults' looks like ".foo", change that
to "Progclass.foo".
*/
{
char **s;
for (s = merged_defaults; *s; s++)
if (**s == '.')
{
const char *oldr = *s;
char *newr = (char *) malloc(strlen(oldr) + strlen(progclass) + 3);
strcpy (newr, progclass);
strcat (newr, oldr);
*s = newr;
}
}
}
/* Make the X errors print out the name of this program, so we have some
clue which one has a bug when they die under the screensaver.
*/
static int
screenhack_ehandler (Display *dpy, XErrorEvent *error)
{
fprintf (stderr, "\nX error in %s:\n", progname);
if (XmuPrintDefaultErrorMessage (dpy, error, stderr))
exit (-1);
else
fprintf (stderr, " (nonfatal.)\n");
return 0;
}
static Bool
MapNotify_event_p (Display *dpy, XEvent *event, XPointer window)
{
return (event->xany.type == MapNotify &&
event->xvisibility.window == (Window) window);
}
#ifdef XLOCKMORE
extern void pre_merge_options (void);
#endif
static Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW;
/* Dead-trivial event handling: exits if "q" or "ESC" are typed.
Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received.
*/
int
screenhack_handle_event (Display *dpy, XEvent *event)
{
int key=0;
switch (event->xany.type)
{
case KeyPress:
{
KeySym keysym;
unsigned char c = 0;
XLookupString (&event->xkey, &c, 1, &keysym, 0);
if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R))
XBell (dpy, 0); /* beep for non-chord keys */
key = keysym;
fprintf(stderr, "KEY PRESSED: %c (%02x)\n", c, c);
}
break;
case ResizeRequest:
screen_resized(event->xresizerequest.width, event->xresizerequest.height);
screen_redraw();
fprintf(stderr, "WINDOW RESIZED to width %d height %d\n",
event->xresizerequest.width, event->xresizerequest.height);
break;
default:
fprintf(stderr, "EVENT: %d (see /usr/include/X11/X.h)\n",
event->xany.type);
break;
case Expose:
screen_redraw();
fprintf(stderr, "EXPOSE: x: %d y: %d width: %d height: %d\n",
event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
break;
case ButtonPress:
fprintf(stderr, "BUTTON PRESSED\n");
break;
case ClientMessage:
{
if (event->xclient.message_type != XA_WM_PROTOCOLS)
{
char *s = XGetAtomName(dpy, event->xclient.message_type);
if (!s) s = "(null)";
fprintf (stderr, "%s: unknown ClientMessage %s received!\n",
progname, s);
}
else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW)
{
char *s1 = XGetAtomName(dpy, event->xclient.message_type);
char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]);
if (!s1) s1 = "(null)";
if (!s2) s2 = "(null)";
fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n",
progname, s1, s2);
}
else
{
exit (0);
}
}
break;
}
return key;
}
int
screenhack_handle_events (void)
{
int key=0;
while (XPending (dpy))
{
XEvent event;
XNextEvent (dpy, &event);
key=screenhack_handle_event (dpy, &event);
}
return key;
}
static Visual *
pick_visual (Screen *screen)
{
#ifdef USE_GL
/* If we're linking against GL (that is, this is the version of screenhack.o
that the GL hacks will use, which is different from the one that the
non-GL hacks will use) then try to pick the "best" visual by interrogating
the GL library instead of by asking Xlib. GL knows better.
*/
Visual *v = 0;
char *string = get_string_resource ("visualID", "VisualID");
char *s;
if (string)
for (s = string; *s; s++)
if (isupper (*s)) *s = _tolower (*s);
if (!string || !*string ||
!strcmp (string, "gl") ||
!strcmp (string, "best") ||
!strcmp (string, "color") ||
!strcmp (string, "default"))
v = get_gl_visual (screen); /* from ../utils/visual-gl.c */
if (string)
free (string);
if (v)
return v;
#endif /* USE_GL */
return get_visual_resource (screen, "visualID", "VisualID", False);
}
/* Notice when the user has requested a different visual or colormap
on a pre-existing window (e.g., "-root -visual truecolor" or
"-window-id 0x2c00001 -install") and complain, since when drawing
on an existing window, we have no choice about these things.
*/
static void
visual_warning (Screen *screen, Window window, Visual *visual, Colormap cmap,
Bool window_p)
{
char *visual_string = get_string_resource ("visualID", "VisualID");
Visual *desired_visual = pick_visual (screen);
char win[100];
char why[100];
if (window == RootWindowOfScreen (screen))
strcpy (win, "root window");
else
sprintf (win, "window 0x%x", (unsigned long) window);
if (window_p)
sprintf (why, "-window-id 0x%x", (unsigned long) window);
else
strcpy (why, "-root");
if (visual_string && *visual_string)
{
char *s;
for (s = visual_string; *s; s++)
if (isupper (*s)) *s = _tolower (*s);
if (!strcmp (visual_string, "default") ||
!strcmp (visual_string, "default") ||
!strcmp (visual_string, "best"))
/* don't warn about these, just silently DWIM. */
;
else if (visual != desired_visual)
{
fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n",
progname, visual_string, why);
fprintf (stderr, "%s: using %s's visual 0x%x.\n",
progname, win, XVisualIDFromVisual (visual));
}
free (visual_string);
}
if (visual == DefaultVisualOfScreen (screen) &&
has_writable_cells (screen, visual) &&
get_boolean_resource ("installColormap", "InstallColormap"))
{
fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n",
progname, why);
fprintf (stderr, "%s: using %s's colormap 0x%x.\n",
progname, win, (unsigned long) cmap);
}
}
int
main (int argc, char **argv)
{
Widget toplevel;
Display *dpy;
Window window;
Screen *screen;
Visual *visual;
Colormap cmap;
Bool root_p;
Window on_window = 0;
XEvent event;
Boolean dont_clear /*, dont_map */;
char version[255];
#ifdef XLOCKMORE
pre_merge_options ();
#endif
merge_options ();
#ifdef __sgi
/* We have to do this on SGI to prevent the background color from being
overridden by the current desktop color scheme (we'd like our backgrounds
to be black, thanks.) This should be the same as setting the
"*useSchemes: none" resource, but it's not -- if that resource is
present in the `default_defaults' above, it doesn't work, though it
does work when passed as an -xrm arg on the command line. So screw it,
turn them off from C instead.
*/
SgiUseSchemes ("none");
#endif /* __sgi */
toplevel = XtAppInitialize (&app, progclass, merged_options,
merged_options_size, &argc, argv,
merged_defaults, 0, 0);
dpy = XtDisplay (toplevel);
screen = XtScreen (toplevel);
db = XtDatabase (dpy);
XtGetApplicationNameAndClass (dpy, &progname, &progclass);
/* half-assed way of avoiding buffer-overrun attacks. */
if (strlen (progname) >= 100) progname[100] = 0;
XSetErrorHandler (screenhack_ehandler);
XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False);
XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
if (argc > 1)
{
const char *s;
int i;
int x = 18;
int end = 78;
Bool help_p = !strcmp(argv[1], "-help");
fprintf (stderr, "%s\n", version);
for (s = progclass; *s; s++) fprintf(stderr, " ");
fprintf (stderr, " eXcellent GUI\n\n");
if (!help_p)
fprintf(stderr, "Unrecognised option: %s\n", argv[1]);
fprintf (stderr, "Options include: ");
for (i = 0; i < merged_options_size; i++)
{
char *sw = merged_options [i].option;
Bool argp = (merged_options [i].argKind == XrmoptionSepArg);
int size = strlen (sw) + (argp ? 6 : 0) + 2;
if (x + size >= end)
{
fprintf (stderr, "\n\t\t ");
x = 18;
}
x += size;
fprintf (stderr, "%s", sw);
if (argp) fprintf (stderr, " <arg>");
if (i != merged_options_size - 1) fprintf (stderr, ", ");
}
fprintf (stderr, ".\n");
exit (help_p ? 0 : 1);
}
dont_clear = get_boolean_resource ("dontClearRoot", "Boolean");
/*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */
mono_p = get_boolean_resource ("mono", "Boolean");
if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2)
mono_p = True;
root_p = get_boolean_resource ("root", "Boolean");
{
char *s = get_string_resource ("windowID", "WindowID");
if (s && *s)
on_window = get_integer_resource ("windowID", "WindowID");
if (s) free (s);
}
if (on_window)
{
XWindowAttributes xgwa;
window = (Window) on_window;
XtDestroyWidget (toplevel);
XGetWindowAttributes (dpy, window, &xgwa);
cmap = xgwa.colormap;
visual = xgwa.visual;
visual_warning (screen, window, visual, cmap, True);
}
else if (root_p)
{
XWindowAttributes xgwa;
window = RootWindowOfScreen (XtScreen (toplevel));
XtDestroyWidget (toplevel);
XGetWindowAttributes (dpy, window, &xgwa);
cmap = xgwa.colormap;
visual = xgwa.visual;
visual_warning (screen, window, visual, cmap, False);
}
else
{
Boolean def_visual_p;
visual = pick_visual (screen);
if (toplevel->core.width <= 0)
toplevel->core.width = 600;
if (toplevel->core.height <= 0)
toplevel->core.height = 480;
def_visual_p = (visual == DefaultVisualOfScreen (screen));
if (!def_visual_p)
{
unsigned int bg, bd;
Widget new;
cmap = XCreateColormap (dpy, RootWindowOfScreen(screen),
visual, AllocNone);
bg = get_pixel_resource ("background", "Background", dpy, cmap);
bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap);
new = XtVaAppCreateShell (progname, progclass,
topLevelShellWidgetClass, dpy,
XtNmappedWhenManaged, False,
XtNvisual, visual,
XtNdepth, visual_depth (screen, visual),
XtNwidth, toplevel->core.width,
XtNheight, toplevel->core.height,
XtNcolormap, cmap,
XtNbackground, (Pixel) bg,
XtNborderColor, (Pixel) bd,
XtNinput, True, /* for WM_HINTS */
0);
XtDestroyWidget (toplevel);
toplevel = new;
XtRealizeWidget (toplevel);
window = XtWindow (toplevel);
}
else
{
XtVaSetValues (toplevel,
XtNmappedWhenManaged, False,
XtNinput, True, /* for WM_HINTS */
0);
XtRealizeWidget (toplevel);
window = XtWindow (toplevel);
if (get_boolean_resource ("installColormap", "InstallColormap"))
{
cmap = XCreateColormap (dpy, window,
DefaultVisualOfScreen (XtScreen (toplevel)),
AllocNone);
XSetWindowColormap (dpy, window, cmap);
}
else
{
cmap = DefaultColormap (dpy, DefaultScreen (dpy));
}
}
/*
if (dont_map)
{
XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0);
XtRealizeWidget (toplevel);
}
else
*/
{
XtPopup (toplevel, XtGrabNone);
}
XtVaSetValues(toplevel, XtNtitle, version, 0);
/* For screenhack_handle_events(): select KeyPress, and
announce that we accept WM_DELETE_WINDOW. */
{
XWindowAttributes xgwa;
XGetWindowAttributes (dpy, window, &xgwa);
XSelectInput (dpy, window,
xgwa.your_event_mask | KeyPressMask | ButtonPressMask | ResizeRedirectMask | ExposureMask);
XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32,
PropModeReplace,
(unsigned char *) &XA_WM_DELETE_WINDOW, 1);
}
}
if (!dont_clear)
{
XSetWindowBackground (dpy, window,
get_pixel_resource ("background", "Background",
dpy, cmap));
XClearWindow (dpy, window);
}
if (!root_p && !on_window)
/* wait for it to be mapped */
XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window);
XSync (dpy, False);
screenhack (dpy, window); /* doesn't return */
return 0;
}

97
uisimulator/x11/screenhack.h Normal file
View file

@ -0,0 +1,97 @@
/* xscreensaver, Copyright (c) 1992-1997 Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
/* Found in Don Hopkins' .plan file:
*
* The color situation is a total flying circus. The X approach to
* device independence is to treat everything like a MicroVax framebuffer
* on acid. A truely portable X application is required to act like the
* persistent customer in the Monty Python ``Cheese Shop'' sketch. Even
* the simplest applications must answer many difficult questions, like:
*
* WHAT IS YOUR DISPLAY?
* display = XOpenDisplay("unix:0");
* WHAT IS YOUR ROOT?
* root = RootWindow(display, DefaultScreen(display));
* AND WHAT IS YOUR WINDOW?
* win = XCreateSimpleWindow(display, root, 0, 0, 256, 256, 1,
* BlackPixel(display, DefaultScreen(display)),
* WhitePixel(display, DefaultScreen(display)))
* OH ALL RIGHT, YOU CAN GO ON.
*
* WHAT IS YOUR DISPLAY?
* display = XOpenDisplay("unix:0");
* WHAT IS YOUR COLORMAP?
* cmap = DefaultColormap(display, DefaultScreen(display));
* AND WHAT IS YOUR FAVORITE COLOR?
* favorite_color = 0; / * Black. * /
* / * Whoops! No, I mean: * /
* favorite_color = BlackPixel(display, DefaultScreen(display));
* / * AAAYYYYEEEEE!! (client dumps core & falls into the chasm) * /
*
* WHAT IS YOUR DISPLAY?
* display = XOpenDisplay("unix:0");
* WHAT IS YOUR VISUAL?
* struct XVisualInfo vinfo;
* if (XMatchVisualInfo(display, DefaultScreen(display),
* 8, PseudoColor, &vinfo) != 0)
* visual = vinfo.visual;
* AND WHAT IS THE NET SPEED VELOCITY OF AN XConfigureWindow REQUEST?
* / * Is that a SubStructureRedirectMask or a ResizeRedirectMask? * /
* WHAT?! HOW AM I SUPPOSED TO KNOW THAT?
* AAAAUUUGGGHHH!!!! (server dumps core & falls into the chasm)
*/
#ifndef __SCREENHACK_H__
#define __SCREENHACK_H__
#include <stdlib.h>
#include "config.h"
#ifdef __hpux
/* Which of the ten billion standards does values.h belong to?
What systems always have it? */
# include <values.h>
#endif
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xresource.h>
#include <X11/Xos.h>
/* M_PI ought to have been defined in math.h, but... */
#ifndef M_PI
# define M_PI 3.1415926535
#endif
#ifndef M_PI_2
# define M_PI_2 1.5707963267
#endif
#include "resources.h"
#include "visual.h"
extern Bool mono_p;
extern char *progname;
extern char *progclass;
extern XrmDatabase db;
extern XrmOptionDescRec options [];
extern char *defaults [];
extern void screenhack (Display*,Window);
extern int screenhack_handle_event (Display*, XEvent*);
extern int screenhack_handle_events (void);
extern void screen_redraw();
extern void screen_resized();
#endif /* __SCREENHACK_H__ */

253
uisimulator/x11/uibasic.c Normal file
View file

@ -0,0 +1,253 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se>
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include "screenhack.h"
#include "version.h"
#include "lcd-x11.h"
#define MAX(x,y) ((x)>(y)?(x):(y))
#define MIN(x,y) ((x)<(y)?(x):(y))
#define PROGNAME "rockboxui"
/* -- -- */
GC draw_gc, erase_gc;
static Colormap cmap;
static XColor color_track, color_car;
static long maxx, maxy;
static double track_zoom=1;
Display *dpy;
Window window;
XrmOptionDescRec options [] = {
/* { "-subtractive", ".additive", XrmoptionNoArg, "false" }, */
{ "-server", ".server", XrmoptionSepArg, 0 },
{ "-help", ".help", XrmoptionNoArg, "false" },
{ 0, 0, 0, 0 }
};
char *progclass = "rockboxui";
char *defaults [] = {
".background: black",
".foreground: white",
"*help: false",
0
};
#define LOGFILE "xgui.log"
void Logf(char *fmt, ...)
{
va_list args;
FILE *log;
struct tm *t;
time_t now=time(NULL);
va_start(args, fmt);
t = localtime(&now);
log = fopen(LOGFILE, "a");
if(log) {
fprintf(log, "%02d:%02d:%02d ",
t->tm_hour, t->tm_min, t->tm_sec);
vfprintf(log, fmt, args);
fprintf(log, "\n");
fclose(log);
}
fprintf(stderr, "%02d:%02d:%02d ",
t->tm_hour, t->tm_min, t->tm_sec);
vfprintf(stderr, fmt, args);
fprintf(stderr, "\n");
va_end(args);
}
void init_window ()
{
XGCValues gcv;
XWindowAttributes xgwa;
char *test_p;
XGetWindowAttributes (dpy, window, &xgwa);
color_track.red=65535;
color_track.green=65535;
color_track.blue=65535;
color_car.red=65535;
color_car.green=65535;
color_car.blue=0;
cmap = xgwa.colormap;
gcv.function = GXxor;
gcv.foreground =
get_pixel_resource ("foreground", "Foreground", dpy, cmap);
draw_gc = erase_gc = XCreateGC (dpy, window, GCForeground, &gcv);
XAllocColor (dpy, cmap, &color_track);
XAllocColor (dpy, cmap, &color_car);
screen_resized(200, 100);
}
void screen_resized(int width, int height)
{
#if 0
XWindowAttributes xgwa;
XGetWindowAttributes (dpy, window, &xgwa);
maxx = ((long)(xgwa.width));
maxy = ((long)(xgwa.height));
#else
maxx = width-1;
maxy = height-1;
#endif
XSetForeground (dpy, draw_gc, get_pixel_resource ("background", "Background",
dpy, cmap));
XFillRectangle(dpy, window, draw_gc, 0, 0, width, height);
}
static void help(void)
{
printf(PROGNAME " " ROCKBOXUI_VERSION " " __DATE__ "\n"
"usage: " PROGNAME "\n"
);
}
void drawline(int color, int x1, int y1, int x2, int y2)
{
if (color==0) {
XSetForeground(dpy, draw_gc,
get_pixel_resource("background", "Background", dpy, cmap));
}
else
XSetForeground(dpy, draw_gc,
get_pixel_resource("foreground", "Foreground", dpy, cmap));
XDrawLine(dpy, window, draw_gc,
(int)(x1*track_zoom),
(int)(y1*track_zoom),
(int)(x2*track_zoom),
(int)(y2*track_zoom));
}
void drawdot(int color, int x, int y)
{
if (color==0) {
XSetForeground(dpy, draw_gc,
get_pixel_resource("background", "Background", dpy, cmap));
}
else
XSetForeground(dpy, draw_gc,
get_pixel_resource("foreground", "Foreground", dpy, cmap));
XDrawPoint(dpy, window, draw_gc, x, y);
}
void drawdots(int color, XPoint *points, int count)
{
if (color==0) {
XSetForeground(dpy, draw_gc,
get_pixel_resource("background", "Background", dpy, cmap));
}
else
XSetForeground(dpy, draw_gc,
get_pixel_resource("foreground", "Foreground", dpy, cmap));
XDrawPoints(dpy, window, draw_gc, points, count, CoordModeOrigin);
}
void drawtext(int color, int x, int y, char *text)
{
if (color==0) {
XSetForeground(dpy, draw_gc,
get_pixel_resource("background", "Background", dpy, cmap));
}
else
XSetForeground(dpy, draw_gc,
get_pixel_resource("foreground", "Foreground", dpy, cmap));
XDrawString(dpy, window, draw_gc, x, y, text, strlen(text));
}
void
screenhack (Display *the_dpy, Window the_window)
{
unsigned short porttouse=0;
char *proxy = NULL;
char *url = NULL;
int i;
char *guiname="Rock-the-box";
Bool helpme;
/* This doesn't work, but I don't know why (Daniel 1999-12-01) */
helpme = get_boolean_resource ("help", "Boolean");
if(helpme) {
help();
}
printf(PROGNAME " " ROCKBOXUI_VERSION " (" __DATE__ ")\n");
dpy=the_dpy;
window=the_window;
init_window();
Logf("Rockbox will kill ya!");
app_main();
}
void screen_redraw()
{
int y, x;
lcd_update();
/* draw a border around the "Recorder" screen */
#define X1 0
#define Y1 0
#define X2 (LCD_WIDTH + MARGIN_X*2)
#define Y2 (LCD_HEIGHT + MARGIN_Y*2)
drawline(1, X1, Y1, X2, Y1);
drawline(1, X2, Y1, X2, Y2);
drawline(1, X1, Y2, X2, Y2);
drawline(1, X1, Y1, X1, Y2);
}

22
uisimulator/x11/utils.h Normal file
View file

@ -0,0 +1,22 @@
/* xscreensaver, Copyright (c) 1997 Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <X11/Xlib.h>
#include <X11/Xos.h>

1
uisimulator/x11/version.h Normal file
View file

@ -0,0 +1 @@
#define ROCKBOXUI_VERSION "0.1"

544
uisimulator/x11/visual.c Normal file
View file

@ -0,0 +1,544 @@
/* xscreensaver, Copyright (c) 1993, 1994, 1995, 1996, 1997, 1998, 1999
* by Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
/* This file contains some code for intelligently picking the best visual
(where "best" is biased in the direction of either: high color counts;
or: having writable color cells...)
*/
#include "utils.h"
#include "resources.h" /* for get_string_resource() */
#include "visual.h"
#include <X11/Xutil.h>
extern char *progname;
#ifndef isupper
# define isupper(c) ((c) >= 'A' && (c) <= 'Z')
#endif
#ifndef _tolower
# define _tolower(c) ((c) - 'A' + 'a')
#endif
static Visual *pick_best_visual (Screen *, Bool, Bool);
static Visual *pick_mono_visual (Screen *);
static Visual *pick_best_visual_of_class (Screen *, int);
static Visual *pick_best_gl_visual (Screen *);
static Visual *id_to_visual (Screen *, int);
static Visual *id_to_visual (Screen *screen, int id);
#define DEFAULT_VISUAL -1
#define BEST_VISUAL -2
#define MONO_VISUAL -3
#define GRAY_VISUAL -4
#define COLOR_VISUAL -5
#define GL_VISUAL -6
#define SPECIFIC_VISUAL -7
Visual *
get_visual (Screen *screen, const char *string, Bool prefer_writable_cells,
Bool verbose_p)
{
char *v = (string ? strdup(string) : 0);
char c, *tmp;
int vclass;
unsigned long id;
Visual *result = 0;
if (v)
for (tmp = v; *tmp; tmp++)
if (isupper (*tmp)) *tmp = _tolower (*tmp);
if (!v || !*v) vclass = BEST_VISUAL;
else if (!strcmp (v, "default")) vclass = DEFAULT_VISUAL;
else if (!strcmp (v, "best")) vclass = BEST_VISUAL;
else if (!strcmp (v, "mono")) vclass = MONO_VISUAL;
else if (!strcmp (v, "monochrome")) vclass = MONO_VISUAL;
else if (!strcmp (v, "gray")) vclass = GRAY_VISUAL;
else if (!strcmp (v, "grey")) vclass = GRAY_VISUAL;
else if (!strcmp (v, "color")) vclass = COLOR_VISUAL;
else if (!strcmp (v, "gl")) vclass = GL_VISUAL;
else if (!strcmp (v, "staticgray")) vclass = StaticGray;
else if (!strcmp (v, "staticcolor")) vclass = StaticColor;
else if (!strcmp (v, "truecolor")) vclass = TrueColor;
else if (!strcmp (v, "grayscale")) vclass = GrayScale;
else if (!strcmp (v, "greyscale")) vclass = GrayScale;
else if (!strcmp (v, "pseudocolor")) vclass = PseudoColor;
else if (!strcmp (v, "directcolor")) vclass = DirectColor;
else if (1 == sscanf (v, " %ld %c", &id, &c)) vclass = SPECIFIC_VISUAL;
else if (1 == sscanf (v, " 0x%lx %c", &id, &c)) vclass = SPECIFIC_VISUAL;
else
{
fprintf (stderr, "%s: unrecognized visual \"%s\".\n", progname, v);
vclass = DEFAULT_VISUAL;
}
if (vclass == DEFAULT_VISUAL)
result = DefaultVisualOfScreen (screen);
else if (vclass == BEST_VISUAL)
result = pick_best_visual (screen, prefer_writable_cells, False);
else if (vclass == MONO_VISUAL)
{
result = pick_mono_visual (screen);
if (!result && verbose_p)
fprintf (stderr, "%s: no monochrome visuals.\n", progname);
}
else if (vclass == GRAY_VISUAL)
{
if (prefer_writable_cells)
result = pick_best_visual_of_class (screen, GrayScale);
if (!result)
result = pick_best_visual_of_class (screen, StaticGray);
if (!result)
result = pick_best_visual_of_class (screen, GrayScale);
if (!result && verbose_p)
fprintf (stderr, "%s: no GrayScale or StaticGray visuals.\n",
progname);
}
else if (vclass == COLOR_VISUAL)
{
int class;
/* First see if the default visual will do. */
result = DefaultVisualOfScreen (screen);
class = visual_class(screen, result);
if (class != TrueColor &&
class != PseudoColor &&
class != DirectColor &&
class != StaticColor)
result = 0;
if (result && visual_depth(screen, result) <= 1)
result = 0;
/* Else, find the best non-default color visual */
if (!result)
result = pick_best_visual (screen, prefer_writable_cells, True);
if (!result && verbose_p)
fprintf (stderr, "%s: no color visuals.\n", progname);
}
else if (vclass == GL_VISUAL)
{
Visual *visual = pick_best_gl_visual (screen);
if (visual)
result = visual;
else if (verbose_p)
fprintf (stderr, "%s: no visual suitable for GL.\n", progname);
}
else if (vclass == SPECIFIC_VISUAL)
{
result = id_to_visual (screen, id);
if (!result && verbose_p)
fprintf (stderr, "%s: no visual with id 0x%x.\n", progname,
(unsigned int) id);
}
else
{
Visual *visual = pick_best_visual_of_class (screen, vclass);
if (visual)
result = visual;
else if (verbose_p)
fprintf (stderr, "%s: no visual of class %s.\n", progname, v);
}
if (v) free (v);
return result;
}
Visual *
get_visual_resource (Screen *screen, char *name, char *class,
Bool prefer_writable_cells)
{
char *string = get_string_resource (name, class);
Visual *v = get_visual (screen, string, prefer_writable_cells, True);
if (string)
free(string);
if (v)
return v;
else
return DefaultVisualOfScreen (screen);
}
static Visual *
pick_best_visual (Screen *screen, Bool prefer_writable_cells, Bool color_only)
{
Visual *visual;
if (!prefer_writable_cells)
{
/* If we don't prefer writable cells, then the "best" visual is the one
on which we can allocate the largest range and number of colors.
Therefore, a TrueColor visual which is at least 16 bits deep is best.
(The assumption here being that a TrueColor of less than 16 bits is
really just a PseudoColor visual with a pre-allocated color cube.)
The next best thing is a PseudoColor visual of any type. After that
come the non-colormappable visuals, and non-color visuals.
*/
if ((visual = pick_best_visual_of_class (screen, TrueColor)) &&
visual_depth (screen, visual) >= 16)
return visual;
}
#define TRY_CLASS(CLASS) \
if ((visual = pick_best_visual_of_class (screen, CLASS)) && \
(!color_only || visual_depth(screen, visual) > 1)) \
return visual
TRY_CLASS(PseudoColor);
TRY_CLASS(TrueColor);
TRY_CLASS(DirectColor);
TRY_CLASS(StaticColor);
if (!color_only)
{
TRY_CLASS(GrayScale);
TRY_CLASS(StaticGray);
}
#undef TRY_CLASS
visual = DefaultVisualOfScreen (screen);
if (!color_only || visual_depth(screen, visual) > 1)
return visual;
else
return 0;
}
static Visual *
pick_mono_visual (Screen *screen)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count;
vi_in.depth = 1;
vi_in.screen = screen_number (screen);
vi_out = XGetVisualInfo (dpy, (VisualDepthMask | VisualScreenMask),
&vi_in, &out_count);
if (vi_out)
{
Visual *v = (out_count > 0 ? vi_out [0].visual : 0);
if (v && vi_out[0].depth != 1)
v = 0;
XFree ((char *) vi_out);
return v;
}
else
return 0;
}
static Visual *
pick_best_visual_of_class (Screen *screen, int visual_class)
{
/* The best visual of a class is the one which on which we can allocate
the largest range and number of colors, which means the one with the
greatest depth and number of cells.
(But actually, for XDaliClock, all visuals of the same class are
probably equivalent - either we have writable cells or we don't.)
*/
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count;
vi_in.class = visual_class;
vi_in.screen = screen_number (screen);
vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask),
&vi_in, &out_count);
if (vi_out)
{
/* choose the 'best' one, if multiple */
int i, best;
Visual *visual;
/* for (i = 0, best = 0; i < out_count; i++) */
for (i = out_count-1, best = i; i >= 0; i--) /* go backwards */
/* It's better if it's deeper, or if it's the same depth with
more cells (does that ever happen? Well, it could...) */
if ((vi_out [i].depth > vi_out [best].depth) ||
((vi_out [i].depth == vi_out [best].depth) &&
(vi_out [i].colormap_size > vi_out [best].colormap_size)))
best = i;
visual = (best < out_count ? vi_out [best].visual : 0);
XFree ((char *) vi_out);
return visual;
}
else
return 0;
}
static Visual *
pick_best_gl_visual (Screen *screen)
{
/* The best visual for GL is a TrueColor visual that is half as deep as
the screen. If such a thing doesn't exist, then TrueColor is best.
Failing that, the deepest available color visual is best.
Compare this function to get_gl_visual() in visual-gl.c.
This function tries to find the best GL visual using Xlib calls,
whereas that function does the same thing using GLX calls.
*/
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count;
Visual *result = 0;
int ndepths = 0;
int *depths = XListDepths (dpy, screen_number (screen), &ndepths);
int screen_depth = depths[ndepths];
XFree (depths);
vi_in.class = TrueColor;
vi_in.screen = screen_number (screen);
vi_in.depth = screen_depth / 2;
vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask |
VisualDepthMask),
&vi_in, &out_count);
if (out_count > 0)
result = vi_out[0].visual;
if (vi_out)
XFree ((char *) vi_out);
if (!result && screen_depth > 24)
{
/* If it's a 32-deep screen and we didn't find a depth-16 visual,
see if there's a depth-12 visual. */
vi_in.class = TrueColor;
vi_in.screen = screen_number (screen);
vi_in.depth = 12;
vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask |
VisualDepthMask),
&vi_in, &out_count);
if (out_count > 0)
result = vi_out[0].visual;
}
if (!result)
/* No half-depth TrueColor? Ok, try for any TrueColor (the deepest.) */
result = pick_best_visual_of_class (screen, TrueColor);
if (!result)
/* No TrueColor? Ok, try for anything. */
result = pick_best_visual (screen, False, False);
return result;
}
static Visual *
id_to_visual (Screen *screen, int id)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count;
vi_in.screen = screen_number (screen);
vi_in.visualid = id;
vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
&vi_in, &out_count);
if (vi_out)
{
Visual *v = vi_out[0].visual;
XFree ((char *) vi_out);
return v;
}
return 0;
}
int
visual_depth (Screen *screen, Visual *visual)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count, d;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
&vi_in, &out_count);
if (! vi_out) abort ();
d = vi_out [0].depth;
XFree ((char *) vi_out);
return d;
}
#if 0
/* You very probably don't want to be using this.
Pixmap depth doesn't refer to the depths of pixmaps, but rather, to
the depth of protocol-level on-the-wire pixmap data, that is, XImages.
To get this info, you should be looking at XImage->bits_per_pixel
instead. (And allocating the data for your XImage structures by
multiplying ximage->bytes_per_line by ximage->height.)
*/
int
visual_pixmap_depth (Screen *screen, Visual *visual)
{
Display *dpy = DisplayOfScreen (screen);
int vdepth = visual_depth (screen, visual);
int pdepth = vdepth;
int i, pfvc = 0;
XPixmapFormatValues *pfv = XListPixmapFormats (dpy, &pfvc);
/* Return the first matching depth in the pixmap formats. If there are no
matching pixmap formats (which shouldn't be able to happen at all) then
return the visual depth instead. */
for (i = 0; i < pfvc; i++)
if (pfv[i].depth == vdepth)
{
pdepth = pfv[i].bits_per_pixel;
break;
}
if (pfv)
XFree (pfv);
return pdepth;
}
#endif /* 0 */
int
visual_class (Screen *screen, Visual *visual)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count, c;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
&vi_in, &out_count);
if (! vi_out) abort ();
c = vi_out [0].class;
XFree ((char *) vi_out);
return c;
}
Bool
has_writable_cells (Screen *screen, Visual *visual)
{
switch (visual_class (screen, visual))
{
case GrayScale: /* Mappable grays. */
case PseudoColor: /* Mappable colors. */
return True;
case StaticGray: /* Fixed grays. */
case TrueColor: /* Fixed colors. */
case StaticColor: /* (What's the difference again?) */
case DirectColor: /* DirectColor visuals are like TrueColor, but have
three colormaps - one for each component of RGB.
Screw it. */
return False;
default:
abort();
return False;
}
}
void
describe_visual (FILE *f, Screen *screen, Visual *visual, Bool private_cmap_p)
{
char n[10];
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
&vi_in, &out_count);
if (! vi_out) abort ();
if (private_cmap_p)
sprintf(n, "%3d", vi_out->colormap_size);
else
strcpy(n, "default");
fprintf (f, "0x%02x (%s depth: %2d, cmap: %s)\n",
(unsigned int) vi_out->visualid,
(vi_out->class == StaticGray ? "StaticGray, " :
vi_out->class == StaticColor ? "StaticColor," :
vi_out->class == TrueColor ? "TrueColor, " :
vi_out->class == GrayScale ? "GrayScale, " :
vi_out->class == PseudoColor ? "PseudoColor," :
vi_out->class == DirectColor ? "DirectColor," :
"UNKNOWN: "),
vi_out->depth, n);
XFree ((char *) vi_out);
}
int
screen_number (Screen *screen)
{
Display *dpy = DisplayOfScreen (screen);
int i;
for (i = 0; i < ScreenCount (dpy); i++)
if (ScreenOfDisplay (dpy, i) == screen)
return i;
abort ();
return 0;
}
int
visual_cells (Screen *screen, Visual *visual)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
int out_count, c;
vi_in.screen = screen_number (screen);
vi_in.visualid = XVisualIDFromVisual (visual);
vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
&vi_in, &out_count);
if (! vi_out) abort ();
c = vi_out [0].colormap_size;
XFree ((char *) vi_out);
return c;
}
Visual *
find_similar_visual(Screen *screen, Visual *old_visual)
{
Display *dpy = DisplayOfScreen (screen);
XVisualInfo vi_in, *vi_out;
Visual *result = 0;
int out_count;
vi_in.screen = screen_number (screen);
vi_in.class = visual_class (screen, old_visual);
vi_in.depth = visual_depth (screen, old_visual);
/* Look for a visual of the same class and depth.
*/
vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask |
VisualDepthMask),
&vi_in, &out_count);
if (vi_out && out_count > 0)
result = vi_out[0].visual;
if (vi_out) XFree (vi_out);
vi_out = 0;
/* Failing that, look for a visual of the same class.
*/
if (!result)
{
vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask),
&vi_in, &out_count);
if (vi_out && out_count > 0)
result = vi_out[0].visual;
if (vi_out) XFree (vi_out);
vi_out = 0;
}
/* Failing that, return the default visual. */
if (!result)
result = DefaultVisualOfScreen (screen);
return result;
}

29
uisimulator/x11/visual.h Normal file
View file

@ -0,0 +1,29 @@
/* xscreensaver, Copyright (c) 1993-1999 by Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
#ifndef __VISUAL_H__
#define __VISUAL_H__
extern Visual *get_visual (Screen *, const char *name, Bool, Bool);
extern Visual *get_visual_resource (Screen *, char *, char *, Bool);
extern int visual_depth (Screen *, Visual *);
/* extern int visual_pixmap_depth (Screen *, Visual *); */
extern int visual_class (Screen *, Visual *);
extern int visual_cells (Screen *, Visual *);
extern int screen_number (Screen *);
extern Visual *find_similar_visual (Screen *, Visual *old);
extern void describe_visual (FILE *f, Screen *, Visual *, Bool private_cmap_p);
extern Visual *get_overlay_visual (Screen *, unsigned long *pixel_return);
extern Bool has_writable_cells (Screen *screen, Visual *visual);
Visual *get_gl_visual (Screen *screen);
#endif /* __VISUAL_H__ */

126
uisimulator/x11/vroot.h Normal file
View file

@ -0,0 +1,126 @@
/*****************************************************************************/
/** Copyright 1991 by Andreas Stolcke **/
/** Copyright 1990 by Solbourne Computer Inc. **/
/** Longmont, Colorado **/
/** **/
/** All Rights Reserved **/
/** **/
/** Permission to use, copy, modify, and distribute this software and **/
/** its documentation for any purpose and without fee is hereby **/
/** granted, provided that the above copyright notice appear in all **/
/** copies and that both that copyright notice and this permis- **/
/** sion notice appear in supporting documentation, and that the **/
/** name of Solbourne not be used in advertising **/
/** in publicity pertaining to distribution of the software without **/
/** specific, written prior permission. **/
/** **/
/** ANDREAS STOLCKE AND SOLBOURNE COMPUTER INC. DISCLAIMS ALL WARRANTIES **/
/** WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF **/
/** MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ANDREAS STOLCKE **/
/** OR SOLBOURNE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL **/
/** DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA **/
/** OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER **/
/** TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE **/
/** OR PERFORMANCE OF THIS SOFTWARE. **/
/*****************************************************************************/
/*
* vroot.h -- Virtual Root Window handling header file
*
* This header file redefines the X11 macros RootWindow and DefaultRootWindow,
* making them look for a virtual root window as provided by certain `virtual'
* window managers like swm and tvtwm. If none is found, the ordinary root
* window is returned, thus retaining backward compatibility with standard
* window managers.
* The function implementing the virtual root lookup remembers the result of
* its last invocation to avoid overhead in the case of repeated calls
* on the same display and screen arguments.
* The lookup code itself is taken from Tom LaStrange's ssetroot program.
*
* Most simple root window changing X programs can be converted to using
* virtual roots by just including
*
* #include <X11/vroot.h>
*
* after all the X11 header files. It has been tested on such popular
* X clients as xphoon, xfroot, xloadimage, and xaqua.
* It also works with the core clients xprop, xwininfo, xwd, and editres
* (and is necessary to get those clients working under tvtwm).
* It does NOT work with xsetroot; get the xsetroot replacement included in
* the tvtwm distribution instead.
*
* Andreas Stolcke <stolcke@ICSI.Berkeley.EDU>, 9/7/90
* - replaced all NULL's with properly cast 0's, 5/6/91
* - free children list (suggested by Mark Martin <mmm@cetia.fr>), 5/16/91
* - include X11/Xlib.h and support RootWindowOfScreen, too 9/17/91
*/
#ifndef _VROOT_H_
#define _VROOT_H_
#if !defined(lint) && !defined(SABER)
static const char vroot_rcsid[] = "#Id: vroot.h,v 1.4 1991/09/30 19:23:16 stolcke Exp stolcke #";
#endif
#include <X11/X.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
static Window
#ifdef __STDC__ /* ANSIfication added by jwz, to avoid superfluous warnings. */
VirtualRootWindowOfScreen(Screen *screen)
#else /* !__STDC__ */
VirtualRootWindowOfScreen(screen) Screen *screen;
#endif /* !__STDC__ */
{
static Screen *save_screen = (Screen *)0;
static Window root = (Window)0;
if (screen != save_screen) {
Display *dpy = DisplayOfScreen(screen);
Atom __SWM_VROOT = None;
int i;
Window rootReturn, parentReturn, *children;
unsigned int numChildren;
root = RootWindowOfScreen(screen);
/* go look for a virtual root */
__SWM_VROOT = XInternAtom(dpy, "__SWM_VROOT", False);
if (XQueryTree(dpy, root, &rootReturn, &parentReturn,
&children, &numChildren)) {
for (i = 0; i < numChildren; i++) {
Atom actual_type;
int actual_format;
unsigned long nitems, bytesafter;
Window *newRoot = (Window *)0;
if (XGetWindowProperty(dpy, children[i],
__SWM_VROOT, 0, 1, False, XA_WINDOW,
&actual_type, &actual_format,
&nitems, &bytesafter,
(unsigned char **) &newRoot) == Success
&& newRoot) {
root = *newRoot;
break;
}
}
if (children)
XFree((char *)children);
}
save_screen = screen;
}
return root;
}
#undef RootWindowOfScreen
#define RootWindowOfScreen(s) VirtualRootWindowOfScreen(s)
#undef RootWindow
#define RootWindow(dpy,screen) VirtualRootWindowOfScreen(ScreenOfDisplay(dpy,screen))
#undef DefaultRootWindow
#define DefaultRootWindow(dpy) VirtualRootWindowOfScreen(DefaultScreenOfDisplay(dpy))
#endif /* _VROOT_H_ */

14
uisimulator/x11/xmu.h Normal file
View file

@ -0,0 +1,14 @@
/* This file contains compatibility routines for systems without Xmu.
* You would be better served by installing Xmu on your machine or
* yelling at your vendor to ship it.
*/
#ifndef __XMU_H__
#define __XMU_H__
#include <X11/Xlib.h>
#include <stdio.h>
int XmuPrintDefaultErrorMessage (Display *dpy, XErrorEvent *event, FILE *fp);
#endif /* __XMU_H__ */