fn_decls.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	init_img_info (image_information *i)
void	main (int argc, char **argv)
void	handle_exposure (register image_information *img, int x, int y, int width, int height, int img_h)
image_information *	action_flip_forward (image_information *img, image_information *img_info, int flip_book_udelay, int n, unsigned long mask, XEvent *event, Boolean *found_event)
image_information *	action_flip_backward (image_information *img, image_information *img_info, int flip_book_udelay, int n, unsigned long mask, XEvent *event, Boolean *found_event)
image_information *	action_flip_book_cycle (image_information *img, image_information *img_info, int n, Boolean flip_forward, int flip_book_udelay)
int	resize_window (image_information *img, int new_w, int new_h)
void	set_watch_cursor (Window window)
void	set_circle_cursor (Window window)
void	set_left_ptr_cursor (Window window)
void	get_cursors (Window window)
XImage *	get_X_image (image_information *img, int width, int height, Boolean share)
void	destroy_X_image (image_information *img, XImage *image)
void	check_pixmap_allocation (image_information *img)
int	allocate_ximage (image_information *img, Boolean reallocate)
void	allocate_pixmap (image_information *img, Boolean reallocate)
void	free_X_pixmap (image_information *img, Pixmap pix)
void	put_X_image (image_information *img, Drawable d, GC gc, XImage *image, int src_x, int src_y, int dest_x, int dest_y, unsigned int width, unsigned int height)
void	determine_icon_size (int image_width, int image_height, int *icon_width, int *icon_height, int *icon_factor)
void	get_x_colormap (image_information *img)
void	open_x_display (char *display_name)
void	calc_view_origin (image_information *img)
void	create_windows (register image_information *img, char *window_geometry)
void	init_color (register image_information *img)
void	free_unique_colors (image_information *img, Pixel *pixels, int npixels)
void	free_image_colors (image_information *img)
void	find_appropriate_visual (register image_information *img)
void	MapPixWindow (image_information *img, int use_top)
void	DrawPixWindow (image_information *img, int x, int y)
void	DrawSpeedWindow (image_information *img, int s)
void	UnmapPixWindow (image_information *img)
void	set_timer (unsigned n)
void	wait_timer (void)
void	choose_scanline_converter (image_information *img)
void	map_rgb_to_bw (image_information *img, rle_pixel **rows, register rle_pixel *bw_row)
void	map_rgb_to_rgb (image_information *img, rle_pixel **in_rows, rle_pixel **out_rows)
void	get_dither_arrays (register image_information *img)
int	shift_match_left (Pixel mask, int high_bit_index)
int	shift_match_right (Pixel mask)
void	check_mono_color (image_information *img, rle_hdr *img_hdr)
void	get_dither_colors (register image_information *img, rle_hdr *img_hdr)
int	eq_cmap (register rle_pixel **cm1, int len1, register rle_pixel **cm2, int len2)
int	XCopyImage (XImage *image, int src_x, int src_y, int width, int height, int dst_x, int dst_y)
int	XAllocColors (register Display *dpy, Colormap cmap, XColor *defs, int ndefs, int *statuses)

Function Documentation

image_information* action_flip_backward	(	image_information *	img,
		image_information *	img_info,
		int	flip_book_udelay,
		int	n,
		unsigned long	mask,
		XEvent *	event,
		Boolean *	found_event
	)

Definition at line 1377 of file getx11.c.

{
    if (mask) *found_event = False;
    
    if ( img == img_info )
    img = &img_info[n - 1];
    for ( ; img >= &img_info[0]; img-- ) {
    set_timer( flip_book_udelay );
    handle_exposure(img, 0, 0, img->w, img->h, img->h);
    XFlush( dpy );
    if (mask && XCheckMaskEvent(dpy, mask, event )){
        *found_event = True;
        break;
    }
    wait_timer();
    }
    if (mask && *found_event)
    return img;
    else return img + 1;
}

image_information* action_flip_book_cycle	(	image_information *	img,
		image_information *	img_info,
		int	n,
		Boolean	flip_forward,
		int	flip_book_udelay
	)

Definition at line 1404 of file getx11.c.

{
    int found_event;
    XEvent event;
    
    do {
    img = (* (flip_forward ? action_flip_forward : action_flip_backward))
        (img, img_info, flip_book_udelay, n, ButtonPressMask|KeyPressMask,
         &event, &found_event);
    XSync(dpy, False);
    } while ( !found_event );    
    return img;
}

image_information* action_flip_forward	(	image_information *	img,
		image_information *	img_info,
		int	flip_book_udelay,
		int	n,
		unsigned long	mask,
		XEvent *	event,
		Boolean *	found_event
	)

Definition at line 1350 of file getx11.c.

{
    if (mask) *found_event = False;

    if ( img == &img_info[n - 1] )
    img = &img_info[0];
    for ( ; img < &img_info[n]; img++ ) {
    set_timer( flip_book_udelay );
    handle_exposure(img, 0, 0, img->w, img->h, img->h);
    XFlush( dpy );
    if (mask && XCheckMaskEvent(dpy, mask, event )){
        *found_event = True;
        break;
    }
    wait_timer();
    }
    if (mask && *found_event)
    return img;
    else return img - 1;
}

void allocate_pixmap	(	image_information *	img,
		Boolean	reallocate
	)

Definition at line 325 of file x11_stuff.c.

{
    extern int stingy_flag;

    int iw = img->w * img->mag_fact;
    int ih = img->h * img->mag_fact;

    if (( img->pixmap != NULL && reallocate ) ||
    ( img->pixmap != NULL && (img->pix_w < iw || img->pix_h < ih ))){
    free_X_pixmap( dpy, img->pixmap );
    img->pixmap = NULL;
    }

    /* reallocate it: use the Min of the winsize and (pic * mag) */
    if ( !img->pixmap && !img->pixmap_failed && !stingy_flag) {
    img->pix_w = Min( iw, img->win_w );
    img->pix_h = Min( ih, img->win_h );
#ifdef X_SHARED_MEMORY
    img->shm_pix.shmid = -1;
    if ( use_shared_pixmaps )
    {
        XImage *image;
        XShmSegmentInfo shminfo;

        /* Allocate an image structure to get bytes_per_line. */
        image = XShmCreateImage( dpy, img->dpy_visual,
                     img->dpy_depth, ZPixmap, 
                     NULL, &shminfo,
                     img->pix_w, img->pix_h );
        /* Get a shared segment for the pixmap. */
        img->shm_pix.shmid =
        shmget( IPC_PRIVATE,
            image->bytes_per_line * image->height,
            IPC_CREAT|0777 );
        XDestroyImage( image );
        if ( img->shm_pix.shmid < 0 )
        {
        if ( errno == ENOSPC )
        {
            if ( !no_shared_space )
            fprintf( stderr,
                 "getx11: No more shared memory segments\n" );
            no_shared_space = True;
        }
        else
            perror( "getx11: shared memory allocation failed" );
        }
        else
        {
        /* Attach the segment & get its address. */
        img->shm_pix.shmaddr = shmat( img->shm_pix.shmid, 0, 0 );

        if ( img->shm_pix.shmaddr == NULL) {
            perror ( "getx11: attach shared pixmap" );
            shmctl( img->shm_pix.shmid, IPC_RMID, 0 );
            img->shm_pix.shmid = -1;
        }
        else
        {
            /* Want to write into the segment! */
            img->shm_pix.readOnly = False;

            /* Tell the X server about it. */
            if ( !XShmAttach( dpy, &img->shm_pix ) )
            {
            fprintf( stderr, "getx11: XShmAttach failed.\n" );
            shmdt( img->shm_pix.shmaddr );
            shmctl( img->shm_pix.shmid, IPC_RMID, 0 );
            img->shm_pix.shmid = -1;
            }
            else
            {
            img->pixmap = XShmCreatePixmap(
                dpy, img->window, img->shm_pix.shmaddr,
                &img->shm_pix, img->pix_w, img->pix_h,
                img->dpy_depth );
            }
        }
        }
    }

    /* If not sharing, or sharing failed, then try to do it normally. */
    if ( img->shm_pix.shmid < 0 )
#endif /* X_SHARED_MEMORY */
        img->pixmap = XCreatePixmap(dpy, img->window,
                    img->pix_w, img->pix_h,
                    img->dpy_depth );
    check_pixmap_allocation( img );
#ifdef X_SHARED_MEMORY
    if ( img->shm_pix.shmid >= 0 )
    {
        /* Remove it now so it will go when we die.
         * Another nice side effect: we don't fill up the SHM table,
         * so we can allocate hundreds of them.
         */
        shmctl( img->shm_pix.shmid, IPC_RMID, 0 );
    }
#endif
    }
}

int allocate_ximage	(	image_information *	img,
		Boolean	reallocate
	)

Definition at line 301 of file x11_stuff.c.

{
    int iw = img->w * img->mag_fact;
    int ih = img->h * img->mag_fact;

    if ( img->image != NULL &&
    ( reallocate || (img->image->width < iw || img->image->height < ih))) {
    destroy_X_image( img, img->image );
    img->image = NULL;
    }
    if (img->image == NULL) {
    int w, h;
        w = Min( iw, img->win_w );
        h = Min( ih, img->win_h );
    img->image = get_X_image( img, w, h, True ); 
    }
    if ( img->image == NULL )
    perror("problem getting XImage");

    return( img->image != NULL );
}

void calc_view_origin

(

image_information *

img

)

Definition at line 575 of file x11_stuff.c.

{
    img->xo = (img->win_w - (img->w * img->mag_fact)) / 2;
    img->yo = (img->win_h - (img->h * img->mag_fact)) / 2;
    img->xo = Max (0, img->xo);
    img->yo = Max (0, img->yo);
}

void check_mono_color	(	image_information *	img,
		rle_hdr *	img_hdr
	)

Definition at line 32 of file in_cmap.c.

{
    /* Get some info out of the RLE header. */
    img->ncmap = img_hdr->ncmap;
    {
    char * v;
    if ( (v = rle_getcom( "color_map_length", img_hdr )) != NULL )
        img->cmlen = atoi( v );
    else
        img->cmlen = 1 << img_hdr->cmaplen;

    /* Protect against bogus information */
    if ( img->cmlen < 0 )
        img->cmlen = 0;
    if ( img->cmlen > 256 )
        img->cmlen = 256;
    }

    /* The mono_color flag means that a single input channel is being
     * pseudocolored by a multi-channel colormap.
     */
    img->mono_color = (img->img_channels == 1 && img->ncmap == 3 &&
               img->cmlen);

}

void check_pixmap_allocation

(

image_information *

img

)

Definition at line 293 of file x11_stuff.c.

{
    wait_img = img;
    XSetErrorHandler( handle_x_errors );
    XSync( dpy, False );
}

void choose_scanline_converter

(

image_information *

img

)

Definition at line 77 of file map_scan.c.

{
    register int i;
    register Boolean table_present;
    static struct {
    Boolean one_color;
    Boolean dither;
    Boolean table_present;
    int bpp;
    void    (*routine)();
    void    (*mag_routine)();
    } map_scanline_table[] =
    {

    /* 1 color, dithr, Table, b/p, routine ptr */

    {  True, True, False, 1, map_1_dither_notable_1,   MAG_1_dither_notable_1},
    {  True, True, True, 8, map_1_dither_table_8,      MAG_1_dither_table_8},
    {  True, False,True, 8, map_1_nodither_table_8,    MAG_1_nodither_table_8},
    {  True, False,False,32,map_1_nodither_notable_32, MAG_1_nodither_notable_32},
    {  False,True, True, 8, map_2or3_dither_table_8,   MAG_2or3_dither_table_8},
    {  False,False,True, 8, map_2or3_nodither_table_8, MAG_2or3_nodither_table_8},
    {  False,True, False,32,map_2or3_dither_notable_32,MAG_2or3_dither_notable_32},
    {  False,False,False,32,map_2or3_nodither_notable_32,MAG_2or3_nodither_notable_32}};

    img->map_scanline = map_scanline_generic;
    img->MAG_scanline = MAG_scanline_generic;

    if (img->pixel_table == NULL)
    table_present = False;
    else table_present = True;

    if (img->mono_color)
    switch (img->image->bits_per_pixel) {
    case 32:
        img->map_scanline = map_1_mono_color_32;
        img->MAG_scanline = MAG_1_mono_color_32;
        break;
    case 8:
        img->map_scanline = map_1_mono_color_8;
        img->MAG_scanline = MAG_1_mono_color_8;
        break;
    default:
        fprintf(stderr, "%s: Warning: Bits per pixel = %d\n",
            progname, img->image->bits_per_pixel);
    }
    else
    for (i = 0; i < COUNT_OF (map_scanline_table); i++) {
        if (map_scanline_table[i].one_color == img->mono_img &&
        map_scanline_table[i].dither == img->dither_img &&
        map_scanline_table[i].table_present == table_present &&
        map_scanline_table[i].bpp == img->image->bits_per_pixel) {
        img->map_scanline = map_scanline_table[i].routine;
        img->MAG_scanline = map_scanline_table[i].mag_routine;

        if ( verbose_flag ) {
            fprintf ( stderr, "Special map_scanline routine used: map_");

            if ( img->mono_img )
            fputs ( "1_", stderr );
            else fputs ( "2or3_", stderr );

            if ( !img->dither_img )
            fputs ( "no", stderr );
            fputs ( "dither_", stderr );

            if (! table_present ) fputs ( "no", stderr );
            fprintf ( stderr, "table_%d (index %d)\n",
                  img->image->bits_per_pixel, i );
        }
        break;
        }
    }
}

void create_windows	(	register image_information *	img,
		char *	window_geometry
	)

void destroy_X_image	(	image_information *	img,
		XImage *	image
	)

Definition at line 238 of file x11_stuff.c.

{ 
#ifdef X_SHARED_MEMORY
    if ( use_shared_pixmaps && image == img->image && img->shm_img.shmid >= 0 )
    {
    XShmDetach (dpy, &img->shm_img);
    XDestroyImage (image);
    shmdt( img->shm_img.shmaddr );
    shmctl( img->shm_img.shmid, IPC_RMID, 0 );
    img->shm_img.shmid = -1;
    }
    else
#endif
    XDestroyImage( image );

    image = NULL;
}

void determine_icon_size	(	int	image_width,
		int	image_height,
		int *	icon_width,
		int *	icon_height,
		int *	icon_factor
	)

Definition at line 466 of file x11_stuff.c.

{
    XIconSize   *icon_sizes;
    int icon_size_count;
    int width, height, factor;
    int i;

    /*
     * We want the Icon to be about DESIRED_ICON_WIDTH x DESIRED_ICON_HEIGHT.  
     * First, make sure that is OK with the window manager.
     * Then figure out the icon scaling factor.
     */

#define DESIRED_ICON_WIDTH  48
#define DESIRED_ICON_HEIGHT 48

    width = DESIRED_ICON_WIDTH;
    height = DESIRED_ICON_HEIGHT;

    if (XGetIconSizes (dpy, root_window, &icon_sizes, &icon_size_count) 
    && icon_size_count >= 1) {

    for (i = 0; i < icon_size_count; i++) {
        if (icon_sizes[i].min_width <= DESIRED_ICON_WIDTH
        && icon_sizes[i].max_width >= DESIRED_ICON_WIDTH
        && icon_sizes[i].min_height <= DESIRED_ICON_HEIGHT
        && icon_sizes[i].max_height >= DESIRED_ICON_HEIGHT) {
        break;
        }
    }

    if (i >= icon_size_count) {
        width = icon_sizes[0].max_width;
        height = icon_sizes[0].max_height;
    }

    }

    factor = image_width / width;
    if (factor < image_height / height) 
    factor = image_height / height;
    if ( factor == 0 )
    factor = 1;

    *icon_width = 1 + (image_width / factor);
    *icon_height = 1 + (image_height / factor);
    *icon_factor = factor;
}

void DrawPixWindow	(	image_information *	img,
		int	x,
		int	y
	)

Definition at line 1997 of file x11_stuff.c.

{
    char str[256];
    unsigned char *r, *g, *b;

    r = SAVED_RLE_ROW( img, y ) + x;

    switch ( img->dpy_channels ) {
    case 1:
    if ( img->mono_color && img->in_cmap ) {
        unsigned char R = img->in_cmap[0][*r];
        unsigned char G = img->in_cmap[1][*r];
        unsigned char B = img->in_cmap[2][*r];
        if ( img->mag_fact > 1 )
        sprintf (str, "(%4d,%4d): %3d -> 0x%02x%02x%02x ( %3d, %3d, %3d ) (Mag %2d)",
             x + img->x, img->h - y - 1 + img->y,
             *r, R, G, B, R, G, B, img->mag_fact);
        else
        sprintf (str, "(%4d,%4d): %3d -> 0x%02x%02x%02x ( %3d, %3d, %3d )",
             x + img->x, img->h - y - 1 + img->y,
             *r, R, G, B, R, G, B);
    } else {
        if ( img->mag_fact > 1 )
        sprintf (str, "(%4d,%4d): ( %3d ) (Mag %2d)",
             x + img->x, img->h - y - 1 + img->y,
             *r, img->mag_fact);
        else
        sprintf (str, "(%4d,%4d): ( %3d )",
             x + img->x, img->h - y - 1 + img->y, *r);
    }
    break;
    case 2:
    g = r + img->w;
    if ( img->mag_fact > 1 )
        sprintf (str, "(%4d,%4d): ( %3d, %3d ) (Mag %2d)",
             x + img->x, img->h - y - 1 + img->y,
             *r, *g, img->mag_fact);
    else
        sprintf (str, "(%4d,%4d): ( %3d, %3d )",
             x + img->x, img->h - y - 1 + img->y,
             *r, *g);
    break;
    case 3:
    g = r + img->w;
    b = g + img->w;
    if ( img->mag_fact > 1 )
        sprintf (str,
             "(%4d,%4d): 0x%02x%02x%02x ( %3d, %3d, %3d ) (Mag %2d)",
             x + img->x, img->h - y - 1 + img->y,
             *r, *g, *b, *r, *g, *b, img->mag_fact);
    else
        sprintf (str, "(%4d,%4d): 0x%02x%02x%02x ( %3d, %3d, %3d )",
             x + img->x, img->h - y - 1 + img->y,
             *r, *g, *b, *r, *g, *b);
    break;
    }

    XClearWindow ( dpy, img->pix_info_window );
    XDrawString ( dpy, img->pix_info_window, img->gc,
          4, 2 + pixel_font_info->ascent, str, strlen (str) );
}

void DrawSpeedWindow	(	image_information *	img,
		int	s
	)

Definition at line 2062 of file x11_stuff.c.

{
    char str[256];

    if ( s > 0 )
    sprintf( str, "%s%d Frames/Second", (s > 0) ? "": "1/", (s>0)?s:-s );
    else
    sprintf( str, "As fast as possible" );

    XClearWindow ( dpy, img->pix_info_window );
    XDrawString ( dpy, img->pix_info_window, img->gc,
          4, 2 + pixel_font_info->ascent, str, strlen (str) );
}

int eq_cmap	(	register rle_pixel **	cm1,
		int	len1,
		register rle_pixel **	cm2,
		int	len2
	)

void find_appropriate_visual

(

register image_information *

img

)

void free_image_colors

(

image_information *

img

)

Definition at line 1679 of file x11_stuff.c.

{
    int ncells = img->mono_img ? img->lvls : img->lvls*img->lvls*img->lvls;
    if ( img->rw_cmap && !img->binary_img )
    XFreeColors(dpy, img->colormap, img->pixel_table, ncells, 0);
}

void free_unique_colors	(	image_information *	img,
		Pixel *	pixels,
		int	npixels
	)

Definition at line 1259 of file x11_stuff.c.

{
    Pixel *p;
    int i, nunique;

    if ( no_color_ref_counts )
    {
    qsort(pixels, npixels, sizeof(Pixel), pixcompare);
    p = pixels;

    for (i=1; i<npixels; i++ ) {
        if ( pixels[i] != *p ) {
        p += 1;
        *p = pixels[i];
        }
    }

    nunique = (p - pixels) + 1;

    DPRINTF(stderr, "In free_unique_pixels \n\nPixels: ");
    for (i=0;i<nunique;i++) DPRINTF(stderr, " %d ",pixels[i]);
    DPRINTF(stderr, "\n");
    }
    else
    nunique = npixels;

    XFreeColors(dpy, img->colormap, pixels, nunique, 0);
}

void free_X_pixmap	(	image_information *	img,
		Pixmap	pix
	)

Definition at line 429 of file x11_stuff.c.

{
    XFreePixmap( dpy, pix );
#ifdef X_SHARED_MEMORY
    if ( use_shared_pixmaps && pix == img->pixmap && img->shm_pix.shmid >= 0 )
    {
    XShmDetach( dpy, &img->shm_pix );
    shmdt( img->shm_pix.shmaddr );
    shmctl( img->shm_pix.shmid, IPC_RMID, 0 );
    img->shm_pix.shmid = -1;
    }
#endif
}

void get_cursors

(

Window

window

)

Definition at line 84 of file x11_stuff.c.

{
    if (circle_cursor == NULL)
    circle_cursor = XCreateFontCursor (dpy, XC_circle);

    if (watch_cursor == NULL)
    watch_cursor = XCreateFontCursor (dpy, XC_watch);

    if (left_ptr_cursor == NULL)
    left_ptr_cursor = XCreateFontCursor (dpy, XC_left_ptr);

    if (circle_cursor == NULL) {
    Pixmap  source;
    Pixmap  mask;
    XColor  color_1;
    XColor  color_2;

    source = XCreateBitmapFromData(dpy, window, circle_bits,
                       circle_width, circle_height);

    mask = XCreateBitmapFromData(dpy, window, circle_mask_bits,
                     circle_width, circle_height);

    color_1.pixel = WhitePixel (dpy, screen);
    color_1.red   = 0xffff;
    color_1.green = 0xffff;
    color_1.blue  = 0xffff;
    color_1.flags = DoRed | DoGreen | DoBlue;

    color_1.pixel = BlackPixel (dpy, screen);
    color_2.red   = 0;
    color_2.green = 0;
    color_2.blue  = 0;
    color_2.flags = DoRed | DoGreen | DoBlue;

    circle_cursor = XCreatePixmapCursor (dpy, source, mask,
                         &color_1, &color_2,
                         circle_x_hot, circle_y_hot);
    XFreePixmap (dpy, source);
    XFreePixmap (dpy, mask);
    }

    if (watch_cursor == NULL)
    watch_cursor = circle_cursor;

    if (left_ptr_cursor == NULL)
    left_ptr_cursor = circle_cursor;
}

void get_dither_arrays

(

register image_information *

img

)

void get_dither_colors	(	register image_information *	img,
		rle_hdr *	img_hdr
	)

void get_x_colormap

(

image_information *

img

)

Definition at line 519 of file x11_stuff.c.

{
    img->colormap = XCreateColormap (dpy, root_window,
                     img->dpy_visual, AllocNone );
    if (img->colormap == NULL) 
    fprintf(stderr, "getx11: Could not create color map for visual\n");
    else {
    VPRINTF(stderr, "created colormap for visual type %s\n",
        visual_class_to_string(img->visual_class));
    }
}

XImage* get_X_image	(	image_information *	img,
		int	width,
		int	height,
		Boolean	share
	)

Definition at line 135 of file x11_stuff.c.

{
    XImage      *image;
#ifdef X_SHARED_MEMORY
    int         shmid = -1;

    if ( use_shared_pixmaps && share )
    {
    img->shm_img.shmid = -1;
    image = XShmCreateImage( dpy, img->dpy_visual,
                 (img->binary_img ? 1 : img->dpy_depth), 
                 (img->binary_img ? XYBitmap : ZPixmap), 
                 NULL, &img->shm_img, width, height );
    if ( image != NULL )
    {
        /* Allocate shared segment. */
        img->shm_img.shmid =
        shmget( IPC_PRIVATE,
            image->bytes_per_line * image->height,
            IPC_CREAT|0777 );
        if ( img->shm_img.shmid < 0 )
        {
        if ( errno == ENOSPC )
        {
            if ( !no_shared_space )
            fprintf( stderr,
                 "getx11: No more shared memory segments\n" );
            no_shared_space = True;
        }
        else
            perror( "getx11: shared memory allocation failed" );
        XDestroyImage( image );
        image = NULL;
        }
        else
        {
        /* Attach the segment & get its address. */
        img->shm_img.shmaddr = image->data =
            shmat( img->shm_img.shmid, 0, 0 );

        if ( image->data == NULL) {
            perror ( "getx11: attach shared image->data" );
            XDestroyImage (image);
            shmctl( img->shm_img.shmid, IPC_RMID, 0 );
            img->shm_img.shmid = -1;
            image = NULL;
        }
        else
        {
            /* Want to write into the segment! */
            img->shm_img.readOnly = False;

            /* Tell the X server about it. */
            if ( !XShmAttach( dpy, &img->shm_img ) )
            {
            fprintf( stderr, "getx11: XShmAttach failed.\n" );
            XDestroyImage (image);
            shmdt( img->shm_img.shmaddr );
            shmctl( img->shm_img.shmid, IPC_RMID, 0 );
            img->shm_img.shmid = -1;
            image = NULL;
            }
        }
        }
    }
    shmid = img->shm_img.shmid;
    }

    /* If not sharing, or if sharing failed, make a normal XImage. */
    if ( shmid >= 0 )
    {
    /* Remove it now so it will go when we die.
     * Another nice side effect: we don't fill up the SHM table,
     * so we can allocate hundreds of them.
     */
    XSync( dpy, False );    /* Make sure the server knows about it. */
    shmctl( shmid, IPC_RMID, 0 );
    }
    else
#endif
    {
    image = XCreateImage ( dpy, img->dpy_visual,
                   (img->binary_img ? 1 : img->dpy_depth), 
                   (img->binary_img ? XYBitmap : ZPixmap), 
                   0, NULL, width, height, 32, 0);

    if (image != NULL) {
        image->data = (char *)malloc ( image->bytes_per_line * height );
        if ( image->data == NULL) {
        perror ( "malloc image->data" );
        XDestroyImage (image);
        image = NULL;
        }
    }
    }
    return (image);

}

void handle_exposure	(	register image_information *	img,
		int	x,
		int	y,
		int	width,
		int	height,
		int	img_h
	)

void init_color

(

register image_information *

img

)

void init_img_info

(

image_information *

i

)

Definition at line 107 of file getx11.c.

{
    i->window = i->icn_window = NULL;
    i->pixmap = i->icn_pixmap = NULL;
    i->pix_info_window = NULL;
    i->gc = i->icn_gc = NULL;
    i->image = i->icn_image = NULL;
    i->colormap = NULL;
    i->visual_class = -1;
    i->pixmap_failed = False;
    
    i->filename = NULL;
    i->img_num = 0;
    i->title = NULL;
    i->fd = stdin;
    i->img_channels = 0;
    i->dpy_channels = 0;
    i->scan_data = NULL;
    i->map_scanline = NULL;
    i->MAG_scanline = NULL;
    i->gamma = 0.0;
    
    i->x = i->y = 0;
    i->xo = i->yo = 0;
    i->w = i->h = 0;
    i->win_w = i->win_h = 0;
    i->icn_w = i->icn_h = 0;
    i->pix_w = i->pix_h = 0;
    i->icn_factor = 1;

    i->pan_x = i->pan_x = 0;
    i->pan_w = i->pan_h = 0;
    i->mag_fact = 1;
    i->save_mag_fact = 1;
    i->mag_mode = False;
    
    i->binary_img = False;
    i->dither_img = False;
    i->mono_img = False;
    i->rw_cmap = False;
    i->sep_colors = False;
    i->mono_color = False;
    i->color_dpy = True;

    i->in_cmap = NULL;
    i->ncmap = 0;
    i->cmlen = 0;
    i->modN = NULL;
    i->divN = NULL;
    i->dm16 = NULL;
    i->pixel_table = NULL;
    i->x_cmap.red_mask = i->x_cmap.green_mask = i->x_cmap.blue_mask = 1;
    i->x_cmap.red_shift = i->x_cmap.green_shift = i->x_cmap.blue_shift = 0;
    i->x_cmap.pixel_base = 0;
    i->black_pixel = 0;
    i->white_pixel = 1;
#ifdef X_SHARED_MEMORY
    i->shm_img.shmid = -1;
    i->shm_pix.shmid = -1;
#endif
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 121 of file aliastorle.c.

{
  char *inname  = NULL;
  char *outname = NULL;
  FILE *infile;
  FILE *outfile;
  int oflag = 0;
  bitmap_hdr bitmap;

  the_hdr = *rle_hdr_init( (rle_hdr *)NULL );
  /*
   * Get options
   */
  if ( !scanargs( argc, argv, "% v%- o%-outfile!s infile%s",
                  &verbose, &oflag, &outname, &inname ))
    exit( 1 );

  /* An input file name ? */
  rle_names( &the_hdr, cmd_name( argv ), inname, 0 );
  infile= rle_open_f(the_hdr.cmd, inname, "r");


  /*
   * Translate Alias "pix" format into my bitmap.
   */
  read_alias(infile, &bitmap);
  rle_close_f(infile);    /* We finish with this file */

  /*
   * We have a bitmap with the image, so we open the
   * new rle file and write it.
   */
  outfile = rle_open_f(cmd_name(argv), outname, "w");
  write_rle(outfile, &bitmap);
  fclose(outfile);            /* it is not necesary, but ... */

  exit(0);
}

void map_rgb_to_bw	(	image_information *	img,
		rle_pixel **	rows,
		register rle_pixel *	bw_row
	)

void map_rgb_to_rgb	(	image_information *	img,
		rle_pixel **	in_rows,
		rle_pixel **	out_rows
	)

Definition at line 2139 of file map_scan.c.

{
    register rle_pixel *in, *out, *cmap;
    register int w;
    rle_pixel **map;
    int ncolors;
    int rowlen;

    map = img->in_cmap;
    ncolors = img->img_channels;
    rowlen = img->w;

    if ( ncolors < 1 )
    {
    fprintf (stderr, "%s: map_rgb_to_rgb given %d colors\n",
         progname, ncolors);
    exit (1);
    }

    if ( map )
    while ( --ncolors >= 0 )
    {
        in = in_rows[0];
        out = out_rows[0];
        cmap = map[0];
        w = rowlen;

        duff8( w, *out++ = cmap[*in++] );

        in_rows++;
        out_rows++;
        map++;
    }
    else
    while ( --ncolors >= 0 )
    {
        if ( in_rows[0] != out_rows[0] )
        memcpy( out_rows[0], in_rows[0], rowlen );

        in_rows++;
        out_rows++;
    }
}

void MapPixWindow	(	image_information *	img,
		int	use_top
	)

Definition at line 1962 of file x11_stuff.c.

{
    Window hukairz;
    int x, y;
    unsigned int w, h, hunoz, huwanz, font_height;

    XGetGeometry (dpy, img->window, &hukairz, &x, &y, &w, &h, &hunoz, &huwanz);

    if (!pixel_font_info) {
    pixel_font_info = XLoadQueryFont (dpy, "fixed");
    if (!pixel_font_info) {
        fprintf (stderr, "%s: unable to load font '%s'\n",
             progname, "fixed");
        exit (1);
    }
    }

    font_height = pixel_font_info->ascent + pixel_font_info->descent + 4;
    y = (use_top ? 0 : (h - font_height));

    if ( img->pix_info_window == NULL ) {
    XSetFont (dpy, img->gc, pixel_font_info->fid );
    img->pix_info_window = XCreateSimpleWindow(
        dpy, img->window, 0, y, w, font_height, 0, None,
        img->black_pixel );
    }
    else
    XMoveResizeWindow ( dpy, img->pix_info_window, 0, y, w, font_height );

    XMapWindow ( dpy, img->pix_info_window );
}

void open_x_display

(

char *

display_name

)

Definition at line 532 of file x11_stuff.c.

{
    /* Check to see if user explicitly specified the screen with -d. */
    if ( display_name )
    {
    char *dotp = strrchr( display_name, '.' );
    char *colonp = strrchr( display_name, ':' );

    /* If the dot follows the colon, then it's a screen designator. */
    if ( dotp && colonp && dotp > colonp && dotp[1] != '\0' )
        specified_screen = atoi( dotp+1 );
    }

    if (display_name == NULL || *display_name == '\0')
    display_name = getenv("DISPLAY");

    dpy = XOpenDisplay(display_name);

    if (dpy == NULL) {
    fprintf(stderr, "%s: Cant open display %s\n", progname,
        (display_name == NULL) ? "" : display_name);
    exit(1);
    }

#ifdef X_SHARED_MEMORY
    if (do_sharing)
    {
    Status sh_status;
    int sh_major, sh_minor;
    Boolean sh_pixmaps = False;

    sh_status = XShmQueryVersion( dpy, &sh_major, &sh_minor, &sh_pixmaps );
    use_shared_pixmaps = (Boolean)(sh_status && sh_pixmaps);
    }
#endif
    /* Work around bug in X11/NeWS server colormap allocation. */
    if (strcmp("X11/NeWS - Sun Microsystems Inc.", ServerVendor(dpy)) == 0 &&
    VendorRelease(dpy) == 2000)
    no_color_ref_counts = True;

}

void put_X_image	(	image_information *	img,
		Drawable	d,
		GC	gc,
		XImage *	image,
		int	src_x,
		int	src_y,
		int	dest_x,
		int	dest_y,
		unsigned int	width,
		unsigned int	height
	)

Definition at line 446 of file x11_stuff.c.

{
#ifdef X_SHARED_MEMORY
    if ( use_shared_pixmaps && img->image == image && img->shm_img.shmid >= 0 )
    XShmPutImage( dpy, d, gc, image, src_x, src_y, dest_x, dest_y,
              width, height, False );
    else
#endif
    XPutImage( dpy, d, gc, image, src_x, src_y, dest_x, dest_y,
           width, height );
}

int resize_window	(	image_information *	img,
		int	new_w,
		int	new_h
	)

Definition at line 1424 of file getx11.c.

{
    int old_w = img->win_w;
    int old_h = img->win_h;
    int iw = img->w * img->mag_fact;
    int ih = img->h * img->mag_fact;
    int retval = 0;
    
    img->win_w = new_w;
    img->win_h = new_h;
    calc_view_origin( img );

    if ( old_w < iw || new_w < iw || old_h < ih || new_h < ih ) { 
    allocate_ximage( img, True );
    if (img->pixmap)
        allocate_pixmap( img, True );
    retval = 1;
    }
    
    return retval;
}

void set_circle_cursor

(

Window

window

)

Definition at line 70 of file x11_stuff.c.

{
    XDefineCursor( dpy, window, circle_cursor );
    XFlush(dpy);
}

void set_left_ptr_cursor

(

Window

window

)

Definition at line 77 of file x11_stuff.c.

{
    XDefineCursor( dpy, window, left_ptr_cursor );
    XFlush(dpy);
}

void set_timer

(

unsigned

n

)

Definition at line 46 of file timer.c.

{
#ifndef NO_ITIMER
    struct itimerval itv;
    register struct itimerval *itp = &itv;
    if (n == 0)
    {
    ringring = 1;
    return;
    }
    timerclear(&itp->it_interval);
    itp->it_value.tv_sec = n / USPS;
    itp->it_value.tv_usec = n % USPS;
    ofunc = (void (*)())signal(SIGALRM, sleepx);

    ringring = 0;
    (void) setitimer(ITIMER_REAL, itp, (struct itimerval *)0);
#endif
}

void set_watch_cursor

(

Window

window

)

Definition at line 63 of file x11_stuff.c.

{
    XDefineCursor( dpy, window, watch_cursor );
    XFlush(dpy);
}

int shift_match_left	(	Pixel	mask,
		int	high_bit_index
	)

Definition at line 2205 of file map_scan.c.

{
    register int    shift;
    register Pixel  high_bit;

    if (mask == 0) return (0);

    high_bit = 0x80000000;

    for (shift = (32 - high_bit_index); (high_bit & mask) == 0; shift--) {
    high_bit >>= 1;
    }
    return (shift);
}

int shift_match_right

(

Pixel

mask

)

Definition at line 2227 of file map_scan.c.

{
    register int    shift;
    register Pixel  low_bit;

    if (mask == 0) return (0);

    low_bit = 1;

    for (shift = 0; (low_bit & mask) == 0; shift++) {
    low_bit <<= 1;
    }
    return (shift);
}

void UnmapPixWindow

(

image_information *

img

)

Definition at line 2080 of file x11_stuff.c.

{
    XUnmapWindow ( dpy, img->pix_info_window );
}

void wait_timer

(

void

)

Definition at line 72 of file timer.c.

{
#ifndef NO_ITIMER
    while (!ringring)
    sigpause( ~sigmask(SIGALRM));
    signal(SIGALRM, ofunc);
#endif
}

int XAllocColors	(	register Display *	dpy,
		Colormap	cmap,
		XColor *	defs,
		int	ndefs,
		int *	statuses
	)

int XCopyImage	(	XImage *	image,
		int	src_x,
		int	src_y,
		int	width,
		int	height,
		int	dst_x,
		int	dst_y
	)

Definition at line 35 of file XCopyImg.c.

{
    int line_width = image->bytes_per_line;

    if ( width == 0 )
    return False;

    switch ( image->bits_per_pixel )
    {
    case 1:
    return False;

    case 8:
    do {
        char *srcline, *dstline;
        register char *src, *dst;
        register int counter;

        if ( src_y < dst_y )
        {
        srcline = image->data + line_width * (src_y+height-1) +
            src_x;
        dstline = image->data + line_width * (dst_y+height-1) +
            dst_x;

        if ( src_x < dst_x ) {
            dstline += width - 1;
            while ( --height >= 0 ) {
            src = srcline + width - 1;
            dst = dstline;
            counter = width;

            duff8( counter, *dst-- = *src-- );

            srcline -= line_width;
            dstline -= line_width;
            }
        }
        else {
            srcline += width - 1;
            while ( --height >= 0 ) {
            src = srcline - width + 1;
            dst = dstline;
            counter = width;

            duff8( counter, *dst++ = *src++ );

            srcline -= line_width;
            dstline -= line_width;
            }
        }
        }
        else
        {
        srcline = image->data + line_width * src_y + src_x;
        dstline = image->data + line_width * dst_y + dst_x;

        if ( src_x < dst_x ) {

            dstline += width - 1;
            while ( --height >= 0 ) {
            src = srcline + width - 1;
            dst = dstline;
            counter = width;

            duff8( counter, *dst-- = *src-- );

            srcline += line_width;
            dstline += line_width;
            }
        }
        else {
            srcline += width - 1;
            while ( --height >= 0 ) {
            src = srcline - width + 1;
            dst = dstline;
            counter = width;

            duff8( counter, *dst++ = *src++ );

            srcline += line_width;
            dstline += line_width;
            }
        }
        }
    } while (0);
    return True;

    case 32:
    do {
        register long *srcline, *dstline;
        register long *src, *dst;

        if ( src_y < dst_y )
        {
        srcline = (long *) ((char *)image->data +
                    line_width * (src_y+height-1) +
                    src_x * sizeof(long));
        dstline = (long *) ((char *)image->data +
                    line_width * (dst_y+height-1) +
                    dst_x * sizeof(long));

        if ( src_x < dst_x ) {

            dstline += width - 1;
            while ( --height >= 0 ) {
            src = srcline + width - 1;
            dst = dstline;

            while ( src >= srcline )
                *dst-- = *src--;

            srcline -= line_width/sizeof(long);
            dstline -= line_width/sizeof(long);
            }
        }
        else {
            srcline += width - 1;
            while ( --height >= 0 ) {
            src = srcline - width + 1;
            dst = dstline;

            while ( src <= srcline )
                *dst++ = *src++;

            srcline -= line_width/sizeof(long);
            dstline -= line_width/sizeof(long);
            }
        }
        }
        else
        {
        srcline = (long *) ((char *)image->data + line_width * src_y +
                    src_x * sizeof(long));
        dstline = (long *) ((char *)image->data + line_width * dst_y +
                    dst_x * sizeof(long));

        if ( src_x < dst_x ) {

            dstline += width - 1;
            while ( --height >= 0 ) {
            src = srcline + width - 1;
            dst = dstline;

            while ( src >= srcline )
                *dst-- = *src--;

            srcline += line_width/sizeof(long);
            dstline += line_width/sizeof(long);
            }
        }
        else {
            srcline += width - 1;
            while ( --height >= 0 ) {
            src = srcline - width + 1;
            dst = dstline;

            while ( src <= srcline )
                *dst++ = *src++;

            srcline += line_width/sizeof(long);
            dstline += line_width/sizeof(long);
            }
        }
        }
    } while (0);
    return True;
    }
    return False;
}