void
_okl4_extension_premap_mem_container(okl4_extension_t *ext,
_okl4_mem_container_t *container, okl4_word_t attach_perms)
{
#ifndef ARM_SHARED_DOMAINS
if (container->type == _OKL4_TYPE_MEMSECTION) {
_okl4_kspace_premap_memsec(ext->kspace->id,
(okl4_memsec_t *)container, attach_perms);
} else if (container->type == _OKL4_TYPE_ZONE) {
_okl4_kspace_premap_zone(ext->kspace->id,
(okl4_zone_t *)container, attach_perms);
} else {
assert(!"Unknown container type.");
}
#else /* ARM_SHARED_DOMAINS */
/* Map a window from the extension space back into the base space. */
if (container->type == _OKL4_TYPE_MEMSECTION) {
map_window(ext->kspace->id, ext->base_pd->kspace->id, container->range);
} else if (container->type == _OKL4_TYPE_ZONE) {
map_window(ext->kspace->id, ((okl4_zone_t *)container)->kspaceid,
container->range);
} else {
assert(!"Unknown container type.");
}
#endif /* ARM_SHARED_DOMAINS */
}
static int init_mode(int mode)
{
int oldcols=vstat.cols;
int oldwidth=bitmap_width;
int oldheight=bitmap_height;
bitmap_init_mode(mode, &bitmap_width, &bitmap_height);
/* Deal with 40 col doubling */
if(oldcols != vstat.cols) {
if(oldcols == 40)
vstat.scaling /= 2;
if(vstat.cols == 40)
vstat.scaling *= 2;
}
if(vstat.scaling < 1)
vstat.scaling = 1;
map_window();
/* Resize window if necessary. */
if((!(bitmap_width == 0 && bitmap_height == 0)) && (oldwidth != bitmap_width || oldheight != bitmap_height))
resize_window();
send_rectangle(0,0,bitmap_width,bitmap_height,TRUE);
sem_post(&mode_set);
return(0);
}
void X11Window::show(bool activate)
{
log_event("debug", "clan::X11Window::show(): Mapping window.");
map_window();
if (activate)
set_enabled(true);
}
void X11Window::restore()
{
if (!is_window_mapped)
log_event("debug", "clan::X11Window::restore(): Window is not yet mapped.");
if (is_minimized())
{
if (restore_to_maximized)
{
log_event("debug", "clan::X11Window::restore(): Restoring to maximized window.");
maximize();
}
else
{
log_event("debug", "clan::X11Window::restore(): Restoring minimized window.");
map_window();
maximized = false;
}
}
else if (is_maximized())
{
log_event("debug", "clan::X11Window::restore(): Restoring window size.");
atoms.modify_net_wm_state(handle.window, _NET_WM_STATE_REMOVE, "_NET_WM_STATE_MAXIMIZED_HORZ", "_NET_WM_STATE_MAXIMIZED_VERT");
maximized = false;
}
}
int
main(int argc, char **argv)
{
unsigned int mainWndId;
unsigned int gc;
KWEvent event;
mainWndId = new_main_window_simple(50, 50, WIDTH, HEIGHT, "Window 1, This is the first one.");
if (mainWndId == BAD_WND_ID) {
LOG(("%s\n", "<Demo2 Error> can not create the main window."));
exit (-1);
}
gc = new_gc();
select_events(mainWndId, EVENT_MASK_EXPOSURE);
map_window(mainWndId);
for (;;) {
get_next_event(&event);
switch (event.type) {
}
}
}
int main(int argc, char **argv)
{
int num_queued;
time_t start_time;
double t;
long num_frames, fast_skip = 200, fast_rewind = 200;
unsigned int width, height;
XEvent xevent;
const char *prgname = argv[0];
const char *classname = "XLndmovie";
char *pixel_file_name = NULL;
FILE *pixel_file;
unsigned char *buffer = NULL, *huff = NULL;
XImage *shm_image;
XShmSegmentInfo shminfo;
int shm_major, shm_minor;
Bool shm_pixmaps;
int ShmCompletionType;
int shmtransfer_completed;
int i, count, step_key = 0;
char xkey[32];
KeySym keysym;
XComposeStatus compose;
int oc;
extern int optind;
extern char *optarg;
init_signal_handling();
display = xwin_init(NULL, prgname, classname, argc, argv, &screen_no, &width, &height);
fixed_font = XLoadQueryFont(display, "fixed");
mit_shm = XShmQueryVersion(display, &shm_major, &shm_minor, &shm_pixmaps);
mit_shm = XShmQueryExtension(display);
if (mit_shm == True)
{
/* printf("Shared memory extension used (found V %d.%d)\n", shm_major, shm_minor); */
ShmCompletionType = XShmGetEventBase(display) + ShmCompletion;
}
/*
else
printf("Standard Xlib used, no shared memory\n");
*/
while ((oc = getopt(argc, argv, "c:f:r:h")) != -1)
{
switch (oc)
{
case 'c':
cell_boxsize = strtol(optarg, NULL, 10);
break;
case 'f':
fast_skip = strtol(optarg, NULL, 10);
if (fast_skip < 1)
fast_skip = 200;
break;
case 'r':
fast_rewind = strtol(optarg, NULL, 10);
if (fast_rewind < 1)
fast_rewind = 200;
break;
default:
fprintf(stderr, "Unknown option \'-%c\' -- ignored\n", oc);
break;
}
}
if (optind < argc)
pixel_file_name = argv[optind++];
else
{
fprintf(stderr, "No pixel file specified -- exit\n");
exit (EXIT_FAILURE);
}
pixel_file = fopen(pixel_file_name, "rb");
if (pixel_file == NULL)
{
fprintf(stderr, "Failed to open pixel file \"%s\" -- exit\n", pixel_file_name);
exit (EXIT_FAILURE);
}
read_pixheader(pixel_file);
if ((cell_boxsize <= 0) || ((width / world_width) < cell_boxsize))
cell_boxsize = width / world_width;
if ((height / world_height) < cell_boxsize)
cell_boxsize = height / world_height;
if (cell_boxsize <= 0)
cell_boxsize = 1;
if ((height / world_height) < cell_boxsize)
cell_boxsize = height / world_height;
window_width = world_width * cell_boxsize;
pixmap_height = world_height * cell_boxsize;
if (fixed_font)
window_height = pixmap_height + fixed_font->ascent + fixed_font->descent + 5;
else
window_height = pixmap_height;
buffer = (unsigned char *) malloc(world_width * world_height * sizeof(char));
if (buffer == NULL)
{
fprintf(stderr, "Failed to allocate internal buffer\n");
exit (EXIT_FAILURE);
}
huff = (unsigned char *) malloc(world_width * world_height * sizeof(char));
if (buffer == NULL)
{
fprintf(stderr, "Failed to allocate internal buffer\n");
free(buffer);
exit (EXIT_FAILURE);
}
window = create_window(MOVER | FULLER | CLOSER | RTARROW | LFARROW | UPARROW | DNARROW,
window_width, window_height, redraw_pixworld, close_pixwindow, 100, 100, window_width, window_height);
XSelectInput(display, window, WH_EVENTMASK | WH_SELECTMASK);
map_window(window);
if (create_lndgcs(lnd_gc, lndx_gc, background_gc, &text_gc))
{
fprintf(stderr, "Failed to create necessary GCs (insufficient colors?)\n");
free(buffer);
free(huff);
exit (EXIT_FAILURE);
}
if (mit_shm)
{
shm_image = XShmCreateImage(display, DefaultVisual(display, screen_no),
DefaultDepth(display, screen_no), ZPixmap, NULL, &shminfo, window_width, pixmap_height);
/*
printf("XImage Structure:\n");
printf("width = %d, height = %d, depth = %d\n", shm_image->width, shm_image->height, shm_image->depth);
printf("format: ");
switch (shm_image->format)
{
case XYBitmap:
printf("XYBitmap\n");
break;
case XYPixmap:
printf("XYPixmap\n");
break;
case ZPixmap:
printf("ZPixmap\n");
break;
default:
printf("UNKNOWN (%d)\n", shm_image->format);
break;
}
printf("%d bytes per line, %d bits per pixel\n", shm_image->bytes_per_line, shm_image->bits_per_pixel);
switch (shm_image->byte_order)
{
case MSBFirst:
printf("byte order: MSBFirst\n");
break;
case LSBFirst:
printf("byte order: LSBFirst\n");
break;
default:
printf("byte order UNKNOWN (%d)\n", shm_image->byte_order);
break;
}
switch (shm_image->bitmap_bit_order)
{
case MSBFirst:
printf("bitmap bit order: MSBFirst\n");
break;
case LSBFirst:
printf("bitmap bit order: LSBFirst\n");
break;
default:
printf("bitmap bit order UNKNOWN (%d)\n", shm_image->bitmap_bit_order);
break;
}
*/
shminfo.shmid = shmget(IPC_PRIVATE, shm_image->bytes_per_line * shm_image->height, IPC_CREAT | 0777);
if (shminfo.shmid == -1)
{
fprintf(stderr, "Failed to get shared memory segment, falling back to standard Xlib\n");
mit_shm = 0;
}
else
{
shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
shm_image->data = shminfo.shmaddr;
shminfo.readOnly = False;
if (XShmAttach(display, &shminfo))
; /* printf("Shared mem successfully attached to server\n"); */
else
{
mit_shm = 0;
XDestroyImage(shm_image);
shmdt(shminfo.shmaddr);
shmctl(shminfo.shmid, IPC_RMID, 0);
printf("Shared memory released\n");
}
}
}
if (!mit_shm)
{
paint_pixmap = XCreatePixmap(display, window, window_width, pixmap_height, DefaultDepth(display, screen_no));
XFillRectangle(display, paint_pixmap, background_gc[15], 0, 0, window_width, pixmap_height);
}
redraw_pixmap = XCreatePixmap(display, window, window_width, pixmap_height, DefaultDepth(display, screen_no));
XFillRectangle(display, redraw_pixmap, background_gc[15], 0, 0, window_width, pixmap_height);
/*
for (i = 0; i < 6; i++)
{
XPutPixel(shm_image, 0, 0, lnd_pixel[i]);
printf("lnd_pixel[%d]=%08lx -> data=%02x\n", i, lnd_pixel[i], shm_image->data[0]);
XPutPixel(shm_image, 0, 0, lndx_pixel[i]);
printf("lndx_pixel[%d]=%08lx -> data=%02x\n", i, lndx_pixel[i], shm_image->data[0]);
}
XPutPixel(shm_image, 0, 0, back_pixel);
printf("back_pixel=%08lx -> data=%02x\n", back_pixel, shm_image->data[0]);
*/
do
{
XNextEvent(display, &xevent);
num_queued = XEventsQueued(display, QueuedAfterFlush);
process_xevent(&xevent);
}
while (!((xevent.type == Expose) && (xevent.xexpose.window == window)));
shmtransfer_completed = 1;
start_time = time(NULL);
num_frames = 0;
while (!game_over)
{
if(feof(pixel_file) || ferror(pixel_file))
{
if (resume_fpos != -1)
{
mode = SINGLE_STEP;
/* printf("switched to single step due to feof / ferror\n"); */
step_key = 0;
/*
printf("rewinding to resume pos %ld\n", resume_fpos);
fseek(pixel_file, resume_fpos, SEEK_SET);
*/
}
else
{
fprintf(stderr, "Encountered EOF without finding any entry point -- quitting\n");
game_over = 1;
}
}
num_queued = XEventsQueued(display, QueuedAfterFlush);
while ((num_queued) || ((mode == SINGLE_STEP) && !step_key))
{
XNextEvent(display, &xevent);
num_queued = XEventsQueued(display, QueuedAfterFlush);
/* printf("received event: %s, window: %d\n", event_name[xevent.type], (int) xevent.xany.window); */
if (process_xevent(&xevent))
continue;
if (xevent.type == ShmCompletionType)
{
/* printf("shm transfer completed\n"); */
shmtransfer_completed = 1;
}
if (xevent.type == KeyPress)
{
count = XLookupString(&(xevent.xkey), xkey, 32, &keysym, &compose);
if (count)
{
switch(xkey[0])
{
case 'f':
/* printf("fast forward\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = FAST_FORWARD;
break;
case 'r':
/* printf("fast rewind\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = FAST_REWIND;
break;
case 'b':
/* printf("backward play\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = BACKWARD_PLAY;
rewind_generation(pixel_file);
break;
case 's':
/* printf("single step\n"); */
mode = SINGLE_STEP;
step_key = 0;
break;
case 'n':
/* printf("normal play\n"); */
/* printf("rewind position: %ld\n", resume_fpos); */
mode = NORMAL_PLAY;
break;
case 'q': case 'Q':
/* printf("game over, bye bye\n"); */
mode = NORMAL_PLAY;
step_key = 1;
game_over = 1;
break;
default:
step_key = 1;
break;
}
}
}
}
if ((mode == NORMAL_PLAY) || (mode == BACKWARD_PLAY) || ((mode == SINGLE_STEP) && step_key)
|| ((mode == FAST_FORWARD) && ((generation % fast_skip) == (fast_skip - 1)))
|| ((mode == FAST_REWIND) && ((generation % fast_rewind) == 1)))
{
if (mit_shm && shmtransfer_completed)
{
if (shm_draw_generation(pixel_file, shm_image, buffer, huff))
{
mode = SINGLE_STEP;
/* printf("switched to single step after shm_draw_generation\n"); */
step_key = 0;
}
else
{
if (window != BadValue)
XShmPutImage(display, window, background_gc[15], shm_image, 0, 0, 0, window_height - pixmap_height, window_width, pixmap_height, True);
if (redraw_pixmap != BadValue)
XShmPutImage(display, redraw_pixmap, background_gc[15], shm_image, 0, 0, 0, 0, window_width, pixmap_height, True);
shmtransfer_completed = 0;
num_frames++;
}
}
else
{
if (draw_generation(pixel_file, paint_pixmap, buffer, huff))
{
mode = SINGLE_STEP;
/* printf("switched to single step after draw_generation\n"); */
step_key = 0;
}
else
{
if (window != BadValue)
XCopyArea(display, paint_pixmap, window, background_gc[15], 0, 0, window_width, pixmap_height, 0, window_height - pixmap_height);
if (redraw_pixmap != BadValue)
XCopyArea(display, paint_pixmap, redraw_pixmap, background_gc[15], 0, 0, window_width, pixmap_height, 0, 0);
num_frames++;
}
}
redraw_text();
if (mode == FAST_REWIND)
{
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
}
step_key = 0;
}
switch (mode)
{
case BACKWARD_PLAY:
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
/* fall through */
case FAST_REWIND:
if (rewind_generation(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after rewind_generation\n"); */
step_key = 0;
}
redraw_text();
break;
case FAST_FORWARD:
if (skip_frame(pixel_file))
{
mode = SINGLE_STEP;
/* printf("switched to single step after skip_frame\n"); */
step_key = 0;
}
redraw_text();
break;
}
}
t = difftime(time(NULL), start_time);
/* printf("%ld frames in %f seconds (%f frames/sec)\n", num_frames, t, num_frames / t); */
if (mit_shm)
{
XShmDetach(display, &shminfo);
XDestroyImage(shm_image);
shmdt(shminfo.shmaddr);
shmctl(shminfo.shmid, IPC_RMID, 0);
printf("Shared memory released\n");
}
free_lndgcs();
if (window != BadValue)
remove_window(window);
if (redraw_pixmap != BadValue)
XFreePixmap(display, redraw_pixmap);
if (paint_pixmap != BadValue)
XFreePixmap(display, paint_pixmap);
free(buffer);
free(huff);
return (EXIT_SUCCESS);
}
