.\" t
.\" @(#)asflip.3		01/28/2021
.TH asflip 3x "AfterStep v.2.2.12" "Jan 28 2021" "AfterStep X11 window manager"
.UC
.SH NAME
\fBasflip\fP\ \- demonstrates flipping image in 90 degree increments
libAfterImage/tutorials/ASFlip
.SH NAMEASFlip


.SH SYNOPSIS
.fi
libAfterImage application for image rotation\&.
.fi

.SH DESCRIPTION
.fi
New steps described in this tutorial are :
ASFlip\&.1\&. Flip value\&.
ASFlip\&.2\&. Rotating ASImage\&.
.fi

.SH SEE ALSO
.fi
Tutorial 1: ASView  \- explanation of basic steps needed to use
                      libAfterImage and some other simple things\&.
Tutorial 2: ASScale \- image scaling basics\&.
Tutorial 3: ASTile  \- image tiling and tinting\&.
Tutorial 4: ASMerge \- scaling and blending of arbitrary number of
                      images\&.
Tutorial 5: ASGrad  \- drawing multipoint linear gradients\&.
.fi

.SH SOURCE
.in +4n

.fi
#include "\&.\&./afterbase\&.h"
#include "\&.\&./afterimage\&.h"
#include "common\&.h"

void usage()
{
    printf( "Usage: asflip [\-h]|[[\-f flip]|[\-m vertical] "
            "[\-g geom] image]");
    printf( "\\nWhere: image \- is image filename\\n");
    printf( "       flip  \- rotation angle in degrees\&. "
            "90, 180 and 270 degrees supported\\n");
    printf( "       geom  \- source image is tiled using this geometry, "
            "prior to rotation\\n");
    printf( "       vertical \- 1 \- mirror image in vertical direction, "
            "0 \- horizontal\\n");
}

int main(int argc, char* argv[])
{
    Display *dpy = NULL;
    ASVisual *asv ;
    int screen = 0 , depth = 0 ;
    char *image_file = "rose512\&.jpg" ;
    int flip = FLIP_VERTICAL;
    Bool vertical = False, mirror = False ;
    int tile_x, tile_y, geom_flags = 0;
    unsigned int tile_width, tile_height ;
    ASImage *im = NULL;
    ASImage *flipped_im = NULL ;

    /* see ASView\&.1 : */
    set_application_name( argv[0] );

    if( argc > 1 )
    {
        int i = 1 ;
        if( strcmp( argv[1], "\-h" ) == 0 )
        {
            usage();
            return 0;
        }
        for( i = 1 ; i < argc ; i++ )
        {
            if( argv[i][0] == '\-' && i < argc\-1 )
            {
                switch(argv[i][1])
                {
                    case 'm' :
                        mirror = True;
                        vertical = atoi(argv[i+1]) ;
                        break ;
                    case 'f' :          /* see ASFlip\&.1 */
                        mirror = False;
                        flip = atoi(argv[i+1])/90 ;
                        break ;
                    case 'g' :          /* see ASTile\&.2 : */
                        geom_flags = XParseGeometry( argv[i+1],
                                                     &tile_x, &tile_y,
                                                     &tile_width,
                                                     &tile_height );
                        break ;
                }
                ++i ;
            }else
                image_file = argv[i] ;
        }
    }else
        usage();

#ifndef X_DISPLAY_MISSING
    dpy = XOpenDisplay(NULL);
    _XA_WM_DELETE_WINDOW = XInternAtom( dpy, "WM_DELETE_WINDOW", False);
    screen = DefaultScreen(dpy);
    depth = DefaultDepth( dpy, screen );
#endif
    /* see ASView\&.2 : */
    im = file2ASImage( image_file, 0xFFFFFFFF, SCREEN_GAMMA, 0, getenv("IMAGE_PATH"), NULL );
    if( im == NULL )
        return 1;

    /* Making sure tiling geometry is sane : */
    if( !get_flags(geom_flags, XValue ) )
        tile_x = 0 ;
    if( !get_flags(geom_flags, YValue ) )
        tile_y = 0 ;
    if( !get_flags(geom_flags, WidthValue ) )
    {
        if( !mirror )
            tile_width = (get_flags(flip,FLIP_VERTICAL))?
                            im\->height:im\->width ;
        else
            tile_width = im\->width ;
    }
    if( !get_flags(geom_flags, HeightValue ) )
    {
        if( !mirror )
            tile_height = (get_flags(flip,FLIP_VERTICAL))?
                            im\->width:im\->height;
        else
            tile_height = im\->height ;
    }
    printf( "%s: tiling image \\"%s\\" to %dx%d%+d%+d and then "
            "flipping it by %d degrees\\n",
            get_application_name(), image_file,
            tile_width, tile_height,tile_x, tile_y, flip*90 );

    /* see ASView\&.3 : */
    asv = create_asvisual( dpy, screen, depth, NULL );

    /* see ASFlip\&.2 : */
    if( !mirror )
        flipped_im = flip_asimage(  asv, im,
                                    tile_x, tile_y,
                                    tile_width, tile_height,
                                    flip,
                                    ASA_ASImage, 0, 
                                    ASIMAGE_QUALITY_DEFAULT );
    else
        flipped_im = mirror_asimage(asv, im,
                                    tile_x, tile_y,
                                    tile_width, tile_height,
                                    vertical,
                                    ASA_ASImage, 0, 
                                    ASIMAGE_QUALITY_DEFAULT );
    destroy_asimage( &im );

    if( flipped_im )
    {
#ifndef X_DISPLAY_MISSING
        /* see ASView\&.4 : */
        Window w = create_top_level_window( asv, DefaultRootWindow(dpy), 
                                            32, 32,
                                            tile_width, tile_height, 
                                            1, 0, NULL,
                                            "ASFlip", image_file );
        if( w != None )
        {
            Pixmap p ;

            XMapRaised   (dpy, w);
            /* see ASView\&.5 : */
            p = asimage2pixmap( asv, DefaultRootWindow(dpy), flipped_im,
                                NULL, True );
            destroy_asimage( &flipped_im );
            /* see common\&.c: set_window_background_and_free() : */
            p = set_window_background_and_free( w, p );
            /* see common\&.c: wait_closedown() : */
        }
        wait_closedown(w);
        dpy = NULL;
#else
        /* writing result into the file */
        ASImage2file( flipped_im, NULL, "asflip\&.jpg", ASIT_Jpeg, NULL );
        destroy_asimage( &flipped_im );
#endif
    }
    return 0 ;
}
.fi

.in
libAfterImage/tutorials/ASFlip\&.1 [6\&.1]
.SH SYNOPSIS
.fi
Step 1\&. Flip value\&.
.fi

.SH DESCRIPTION
.fi
libAfterImage provides facility for rotating images in 90 degree
increments \- flipping essentially\&. Accordingly flip parameter could
have 4 values \- 0, \-90, \-180, \-270 degrees\&.
.fi

.SH EXAMPLE
.fi
    flip = atoi(argv[2])/90;
.fi

.SH SEE ALSO
.fi
flip
.fi
libAfterImage/tutorials/ASFlip\&.2 [6\&.2]
.SH SYNOPSIS
.fi
Step 2\&. Flipping ASImage\&.
.fi

.SH DESCRIPTION
.fi
Flipping can actually be combined with offset and tiling\&. Original
image gets tiled to supplied rectangle, and then gets rotated to
requested degree\&.
.fi

.SH EXAMPLE
.fi
    flipped_im = flip_asimage(asv, im,
                                  tile_x, tile_y,
                                  tile_width, tile_height,
                                  flip,
                                  ASA_XImage,0, 
                                  ASIMAGE_QUALITY_DEFAULT );
        destroy_asimage( &im );
.fi

.SH NOTES
.fi
As far as we need to render rotated image right away \- we set to_xim
parameter to True, so that image will be rotated into XImage\&. Right
after rotation is done \- we can destroy original image\&.
.fi

.SH SEE ALSO
.fi
flip_asimage()
.fi