QuickPics1.8

Now you can turn this:                Into this!

  Directory
     Directory
        Image
        Image             ===>        HTML Web Gallery!
     Directory
        Image
        Image

QuickPics is a unix-based application that creates an HTML web gallery
based on the directory structure and the images therein.  All thumbnails
are created by the program using direct calls to the jpeg library for
fast thumbnail creation.  One of my main requirements is that it will not
not have to rely on CGI access to run.  It also does not need require
Perl or other jpeg libraries.  Only the executable 'qp' is needed to
create any gallery of any size.

If you have an image gallery and you are tired of editing all the HTML
pages and resizing thumbnails, try QuickPics.  To see it in action, check
out my QuickPics page!  http://www.retina.net/~stever/QuickPics

by Steve Rider - stever@transmission23.com

Source code for QuickPics can be found at
    http://www.retina.net/~stever/src



 
Table of Contents
-----------------
 1. Introduction
 2. Documentation
 4. Compiling QuickPics
 4. How To Create Image Galleries




1. Introduction
---------------
    This directory and its descendants contain the sources for QuickPics,
    a utility used to generate web-based galleries of images.  The
    information here corresponds to version 1.x, the first public release
    of QuickPics.


2. Documentation
----------------
    The best way to get started with QuickPics is to fire it up against
    a directory which contains directories of pictures.  It will then
    create the necessary configuration files and description files, and
    you will be able to see web pages right away.


3. Compiling QuickPics
----------------------
    QuickPics relies on the jpeg library to do such things as reading
    jpeg images to determine image sizes, and resizing images to create
    thumbnails.

    If you already have jpeglib on your machine, great!  Just edit the
    Makefile in src, and point it to your jpeglib.  You will need to
    run ./configure in the src directory first.

    If not, build QuickPics by typing

        make

    This will configure and build libjpeg.a and QuickPics.  You can type

        make clean

    to clean up intermediate object files to save some room.

    Once the build is complete, you should have an executable named 'qp'
    in the current directory.  This is the only file you will need to run
    QuickPics.  Configuration files are set up in each picture gallery,
    which allows you to use QuickPics on different galleries, each with
    its own configuration.  The configuration file controls html properties
    like page background color, font size and color, and also controls
    quality and sizes of thumbnails.

    Copy the executable 'qp' to a directory in your path, or if you're root
    to somewhere like /usr/local/bin and you're ready to go.



4. How To Create Image Galleries
--------------------------------
    QuickPics creates web pages by looking at the structure of the
    directory specified.  This makes maintaing the gallery incredibly
    simple, since you can just move images around between directories,
    rerun QuickPics and the entire gallery is updated.  Since this is
    a unix-based program, we leave the maintenance for gallery structure
    to well-suited commands like cp, mv, and mkdir :>
  
    These next steps will get your image gallery up and going:

        1) Create a directory you will use as your gallery directory.
           An appropriate name might be 'gallery'.  It would be a good
           idea to create this directory in your public_html directory.

        2) Create any number of subdirectories inside of your gallery
           directory, and move some images into them.  Directory names
           can be anything you like.  The actual names can be set later.

           If you named your picture directory "gallery", listing all
           files in that directory should give you something like this:

               total 3
               drwxr-xr-x   2 stever   0   1024 Apr  4 22:12 work/
               drwxr-xr-x   2 stever   0   1024 Apr  4 22:12 vegas/
               drwxr-xr-x   2 stever   0   1024 Apr  4 22:06 picsofme/

        3) Run QuickPics against your gallery directory.  This can be
           accomplished by specifying the directory name after the command,
           or by simply changing to the gallery directory, and typing: qp .

        4) QuickPics will prompt you for the name of your gallery, and
           the names of each folder that will be used in the web pages.

        5) When QuickPics completes, the gallery is ready for viewing!
           Follow the link shown when QuickPics is finished.  This will
           usually be: gallery/index.html

        6) Finally, you will want to edit folder and image descriptions.
           Each folder contains a file called "info.txt" (unless you've
           changed it in the config).  Edit this file to add descriptions
           to the images.  When you're done, re-run QuickPics, and the
           changes will appear in the gallery.  You may need to hit
           'reload' on your browser.

    That's it!

    To really start tweaking with the gallery, edit the configuration file
    located in the picture directory.

    A very FAST way to use QuickPics is to have it located in your path,
    and while you're working on image descriptions and whatnot, you can
    just type 'qp -T .' from the picture directory, and QuickPics will jam
    through and update the whole gallery without writing thumbnails.  On
    a gallery with more than 1500 images, it took less than 10 seconds
    to completely rewrite all the HTML pages and update the links.  Cool!

    As a side note, folder descriptions and titles can be html tags.  For
    example, instead of a line of text describing your page, you can
    use html to display an image perhaps.

    Also, QuickPics is a recursive system, which means you can have
    subfolders inside of folders, and the entire tree will be made
    navigable.  This gives you the same flexibility in organizing images
    as storing files in subdirectories.

    Finally, if you're thinking "Hey, I'm going to run QuickPics against
    my home directory just for the hell of it!", you may want to think
    twice.  Since QuickPics creates thumbnails and configuration files
    in each directory it encounters, you could end up with a lot of
    garbage on your hands!  Eventually, QuickPics will have a restore
    routine which will remove all QuickPics files and return the
    directory tree back to its original state.  But until then, be aware!


    Send me a line at stever@transmission23.com

    Have fun!


	- Steve  3/4/98
