prototypes.h File Reference

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.

References B, bw, flip, fnam, forceham, G, ifd, IFFBase, infile, IntuitionBase, isham, mktemp(), nused, optarg, optind, R, s1, s2, s3, sd, sh, sw, tfd, tfile, threescreens, vp1, vp2, vp3, and width.

{
  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);
}

Here is the call graph for this function:

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.

References ofunc, and ringring.

{
#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;
}