~ubuntu-branches/ubuntu/precise/imagemagick/precise

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                 IIIII  M   M  PPPP    OOO   RRRR   TTTTT                    %

%                   I    MM MM  P   P  O   O  R   R    T                      %

%                   I    M M M  PPPP   O   O  RRRR     T                      %

%                   I    M   M  P      O   O  R R      T                      %

%                 IIIII  M   M  P       OOO   R  R     T                      %

%                                                                             %

%                                                                             %

%                       Import Image from X11 Screen                          %

%                                                                             %

%                           Software Design                                   %

%                             John Cristy                                     %

%                              July 1992                                      %

%                                                                             %

%                                                                             %

%  Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization      %

%  dedicated to making software imaging solutions freely available.           %

%                                                                             %

%  You may not use this file except in compliance with the License.  You may  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    http://www.imagemagick.org/script/license.php                            %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Use the import program to capture some or all of an X server screen and

%  save the image to a file.

%

*/

/*

  Include declarations.

*/

#include "wand/studio.h"

#include "wand/MagickWand.h"

#include "wand/mogrify-private.h"

#include "magick/xwindow-private.h"

#include "magick/string-private.h"

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   I m p o r t I m a g e C o m m a n d                                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ImportImageCommand() reads an image from any visible window on an X server

%  and outputs it as an image file. You can capture a single window, the

%  entire screen, or any rectangular portion of the screen.  You can use the

%  display utility for redisplay, printing, editing, formatting, archiving,

%  image processing, etc. of the captured image.</dd>

%

%  The target window can be specified by id, name, or may be selected by

%  clicking the mouse in the desired window. If you press a button and then

%  drag, a rectangle will form which expands and contracts as the mouse moves.

%  To save the portion of the screen defined by the rectangle, just release

%  the button. The keyboard bell is rung once at the beginning of the screen

%  capture and twice when it completes.

%

%  The format of the ImportImageCommand method is:

%

%      MagickBooleanType ImportImageCommand(ImageInfo *image_info,int argc,

%        char **argv,char **metadata,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image_info: the image info.

%

%    o argc: the number of elements in the argument vector.

%

%    o argv: A text array containing the command line arguments.

%

%    o metadata: any metadata is returned here.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static MagickBooleanType ImportUsage(void)

{

  const char

    **p;

  static const char

    *miscellaneous[]=

    {

      "-debug events        display copious debugging information",

      "-help                print program options",

      "-list type           print a list of supported option arguments",

      "-log format          format of debugging information",

      "-version             print version information",

      (char *) NULL

    },

    *operators[]=

    {

      "-annotate geometry text",

      "                     annotate the image with text",

      "-colors value        preferred number of colors in the image",

      "-crop geometry       preferred size and location of the cropped image",

      "-encipher filename   convert plain pixels to cipher pixels",

      "-geometry geometry   preferred size or location of the image",

      "-help                print program options",

      "-monochrome          transform image to black and white",

      "-negate              replace every pixel with its complementary color ",

      "-repage geometry     size and location of an image canvas",

      "-quantize colorspace reduce colors in this colorspace",

      "-resize geometry     resize the image",

      "-rotate degrees      apply Paeth rotation to the image",

      "-strip               strip image of all profiles and comments",

      "-thumbnail geometry  create a thumbnail of the image",

      "-transparent color   make this color transparent within the image",

      "-trim                trim image edges",

      "-type type           image type",

      (char *) NULL

    },

    *settings[]=

    {

      "-adjoin              join images into a single multi-image file",

      "-border              include window border in the output image",

      "-channel type        apply option to select image channels",

      "-colorspace type     alternate image colorspace",

      "-comment string      annotate image with comment",

      "-compress type       type of pixel compression when writing the image",

      "-define format:option",

      "                     define one or more image format options",

      "-density geometry    horizontal and vertical density of the image",

      "-depth value         image depth",

      "-descend             obtain image by descending window hierarchy",

      "-display server      X server to contact",

      "-dispose method      layer disposal method",

      "-dither method       apply error diffusion to image",

      "-delay value         display the next image after pausing",

      "-encipher filename   convert plain pixels to cipher pixels",

      "-endian type         endianness (MSB or LSB) of the image",

      "-encoding type       text encoding type",

      "-filter type         use this filter when resizing an image",

      "-format \"string\"     output formatted image characteristics",

      "-frame               include window manager frame",

      "-gravity direction   which direction to gravitate towards",

      "-identify            identify the format and characteristics of the image",

      "-interlace type      None, Line, Plane, or Partition",

      "-interpolate method  pixel color interpolation method",

      "-label string        assign a label to an image",

      "-limit type value    Area, Disk, Map, or Memory resource limit",

      "-monitor             monitor progress",

      "-page geometry       size and location of an image canvas",

      "-pause value         seconds delay between snapshots",

      "-pointsize value     font point size",

      "-quality value       JPEG/MIFF/PNG compression level",

      "-quiet               suppress all warning messages",

      "-regard-warnings     pay attention to warning messages",

      "-respect-parentheses settings remain in effect until parenthesis boundary",

      "-sampling-factor geometry",

      "                     horizontal and vertical sampling factor",

      "-scene value         image scene number",

      "-screen              select image from root window",

      "-seed value          seed a new sequence of pseudo-random numbers",

      "-set property value  set an image property",

      "-silent              operate silently, i.e. don't ring any bells ",

      "-snaps value         number of screen snapshots",

      "-transparent-color color",

      "                     transparent color",

      "-treedepth value     color tree depth",

      "-verbose             print detailed information about the image",

      "-virtual-pixel method",

      "                     Constant, Edge, Mirror, or Tile",

      "-window id           select window with this id or name",

      (char *) NULL

    };

  (void) printf("Version: %s\n",GetMagickVersion((unsigned long *) NULL));

  (void) printf("Copyright: %s\n",GetMagickCopyright());

  (void) printf("Features: %s\n\n",GetMagickFeatures());

  (void) printf("Usage: %s [options ...] [ file ]\n",

    GetClientName());

  (void) printf("\nImage Settings:\n");

  for (p=settings; *p != (char *) NULL; p++)

    (void) printf("  %s\n",*p);

  (void) printf("\nImage Operators:\n");

  for (p=operators; *p != (char *) NULL; p++)

    (void) printf("  %s\n",*p);

  (void) printf("\nMiscellaneous Options:\n");

  for (p=miscellaneous; *p != (char *) NULL; p++)

    (void) printf("  %s\n",*p);

  (void) printf(

  "\nBy default, 'file' is written in the MIFF image format.  To\n");

  (void) printf(

    "specify a particular image format, precede the filename with an image\n");

  (void) printf(

    "format name and a colon (i.e. ps:image) or specify the image type as\n");

  (void) printf(

    "the filename suffix (i.e. image.ps).  Specify 'file' as '-' for\n");

  (void) printf("standard input or output.\n");

  return(MagickFalse);

}

static inline long MagickMax(const long x,const long y)

{

  if (x > y)

    return(x);

  return(y);

}

WandExport MagickBooleanType ImportImageCommand(ImageInfo *image_info,

  int argc,char **argv,char **wand_unused(metadata),ExceptionInfo *exception)

{

#if defined(MAGICKCORE_X11_DELEGATE)

#define DestroyImport() \

{ \

  XDestroyResourceInfo(&resource_info); \

  if (display != (Display *) NULL) \

    { \

      XCloseDisplay(display); \

      display=(Display *) NULL; \

    } \

  DestroyImageStack(); \

  if (target_window != (char *) NULL) \

    target_window=DestroyString(target_window); \

  for (i=0; i < (long) argc; i++) \

    argv[i]=DestroyString(argv[i]); \

  argv=(char **) RelinquishMagickMemory(argv); \

}

#define ThrowImportException(asperity,tag,option) \

{ \

  (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \

     option); \

  DestroyImport(); \

  return(MagickFalse); \

}

#define ThrowImportInvalidArgumentException(option,argument) \

{ \

  (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \

    "InvalidArgument","`%s': %s",option,argument); \

  DestroyImport(); \

  return(MagickFalse); \

}

  char

    *filename,

    *option,

    *resource_value,

    *server_name,

    *target_window;

  Display

    *display;

  Image

    *image;

  ImageStack

    image_stack[MaxImageStackDepth+1];

  long

    j,

    k,

    snapshots;

  MagickBooleanType

    fire,

    pend;

  MagickStatusType

    status;

  QuantizeInfo

    *quantize_info;

  register long

    i;

  XImportInfo

    ximage_info;

  XResourceInfo

    resource_info;

  XrmDatabase

    resource_database;

  /*

    Set defaults.

  */

  assert(image_info != (ImageInfo *) NULL);

  assert(image_info->signature == MagickSignature);

  if (image_info->debug != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");

  assert(exception != (ExceptionInfo *) NULL);

  if (argc == 2)

    {

      option=argv[1];

      if ((LocaleCompare("version",option+1) == 0) ||

          (LocaleCompare("-version",option+1) == 0))

        {

          (void) fprintf(stdout,"Version: %s\n",

            GetMagickVersion((unsigned long *) NULL));

          (void) fprintf(stdout,"Copyright: %s\n",GetMagickCopyright());

          (void) fprintf(stdout,"Features: %s\n\n",GetMagickFeatures());

          return(MagickFalse);

        }

    }

  display=(Display *) NULL;

  j=1;

  k=0;

  NewImageStack();

  option=(char *) NULL;

  pend=MagickFalse;

  resource_database=(XrmDatabase) NULL;

  (void) ResetMagickMemory(&resource_info,0,sizeof(resource_info));

  server_name=(char *) NULL;

  status=MagickTrue;

  SetNotifyHandlers;

  target_window=(char *) NULL;

  /*

    Check for server name specified on the command line.

  */

  ReadCommandlLine(argc,&argv);

  status=ExpandFilenames(&argc,&argv);

  if (status == MagickFalse)

    ThrowImportException(ResourceLimitError,"MemoryAllocationFailed",

      GetExceptionMessage(errno));

  for (i=1; i < (long) argc; i++)

  {

    /*

      Check command line for server name.

    */

    option=argv[i];

    if (LocaleCompare("display",option+1) == 0)

      {

        /*

          User specified server name.

        */

        i++;

        if (i == (long) argc)

          ThrowImportException(OptionError,"MissingArgument",option);

        server_name=argv[i];

      }

    if ((LocaleCompare("help",option+1) == 0) ||

        (LocaleCompare("-help",option+1) == 0))

      return(ImportUsage());

  }

  /*

    Get user defaults from X resource database.

  */

  display=XOpenDisplay(server_name);

  if (display == (Display *) NULL)

    ThrowImportException(XServerError,"UnableToOpenXServer",

      XDisplayName(server_name));

  (void) XSetErrorHandler(XError);

  resource_database=XGetResourceDatabase(display,GetClientName());

  XGetImportInfo(&ximage_info);

  XGetResourceInfo(image_info,resource_database,GetClientName(),

    &resource_info);

  quantize_info=resource_info.quantize_info;

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "border","False");

  ximage_info.borders=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "delay","0");

  resource_info.delay=(unsigned int) StringToUnsignedLong(resource_value);

  image_info->density=XGetResourceInstance(resource_database,GetClientName(),

    "density",(char *) NULL);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "descend","True");

  ximage_info.descend=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "frame","False");

  ximage_info.frame=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "interlace","none");

  image_info->interlace=UndefinedInterlace;

  if (LocaleCompare("None",resource_value) == 0)

    image_info->interlace=NoInterlace;

  if (LocaleCompare("Line",resource_value) == 0)

    image_info->interlace=LineInterlace;

  if (LocaleCompare("Plane",resource_value) == 0)

    image_info->interlace=PlaneInterlace;

  if (LocaleCompare("Partition",resource_value) == 0)

    image_info->interlace=PartitionInterlace;

  if (image_info->interlace == UndefinedInterlace)

    ThrowImportException(OptionError,"Unrecognized interlace type",

      resource_value);

  image_info->page=XGetResourceInstance(resource_database,GetClientName(),

    "pageGeometry",(char *) NULL);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "pause","0");

  resource_info.pause=(unsigned int) StringToUnsignedLong(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "quality","85");

  image_info->quality=StringToUnsignedLong(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "screen","False");

  ximage_info.screen=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "silent","False");

  ximage_info.silent=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "verbose","False");

  image_info->verbose=IsMagickTrue(resource_value);

  resource_value=XGetResourceInstance(resource_database,GetClientName(),

    "dither","True");

  quantize_info->dither=IsMagickTrue(resource_value);

  snapshots=1;

  status=MagickTrue;

  filename=(char *) NULL;

  /*

    Check command syntax.

  */

  for (i=1; i < (long) argc; i++)

  {

    option=argv[i];

    if (LocaleCompare(option,"(") == 0)

      {

        FireImageStack(MagickFalse,MagickTrue,pend);

        if (k == MaxImageStackDepth)

          ThrowImportException(OptionError,"ParenthesisNestedTooDeeply",

            option);

        PushImageStack();

        continue;

      }

    if (LocaleCompare(option,")") == 0)

      {

        FireImageStack(MagickFalse,MagickTrue,MagickTrue);

        if (k == 0)

          ThrowImportException(OptionError,"UnableToParseExpression",option);

        PopImageStack();

        continue;

      }

    if (IsMagickOption(option) == MagickFalse)

      {

        Image

          *images;

        unsigned long

          scene;

        /*

          Read image from X server.

        */

        FireImageStack(MagickFalse,MagickFalse,pend);

        filename=argv[i];

        if (target_window != (char *) NULL)

          (void) CopyMagickString(image_info->filename,target_window,

            MaxTextExtent);

        for (scene=0; scene < (unsigned long) MagickMax(snapshots,1); scene++)

        {

          (void) sleep(resource_info.pause);

          images=XImportImage(image_info,&ximage_info);

          status&=(images != (Image *) NULL) &&

            (exception->severity < ErrorException);

          if (images == (Image *) NULL)

            continue;

          (void) CopyMagickString(images->filename,filename,MaxTextExtent);

          (void) CopyMagickString(images->magick,"PS",MaxTextExtent);

          images->scene=scene;

          AppendImageStack(images);

        }

        continue;

      }

    pend=image != (Image *) NULL ? MagickTrue : MagickFalse;

    switch(*(option+1))

    {

      case 'a':

      {

        if (LocaleCompare("adjoin",option+1) == 0)

          break;

        if (LocaleCompare("annotate",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) (argc-1))

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            if (i == (long) (argc-1))

              ThrowImportException(OptionError,"MissingArgument",option);

            i++;

            break;

          }

        ThrowImportException(OptionError,"UnrecognizedOption",option);

      }

      case 'b':

      {

        if (LocaleCompare("border",option+1) == 0)

          {

            (void) CopyMagickString(argv[i]+1,"sans",MaxTextExtent);

            ximage_info.borders=(*option == '-') ? MagickTrue : MagickFalse;

            break;

          }

        if (LocaleCompare("bordercolor",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            break;

          }

        ThrowImportException(OptionError,"UnrecognizedOption",option);

      }

      case 'c':

      {

        if (LocaleCompare("cache",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            break;

          }

        if (LocaleCompare("channel",option+1) == 0)

          {

            long

              channel;

            if (*option == '+')

              break;

            i++;

            if (i == (long) (argc-1))

              ThrowImportException(OptionError,"MissingArgument",option);

            channel=ParseChannelOption(argv[i]);

            if (channel < 0)

              ThrowImportException(OptionError,"UnrecognizedChannelType",

                argv[i]);

            break;

          }

        if (LocaleCompare("colors",option+1) == 0)

          {

            quantize_info->number_colors=0;

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            quantize_info->number_colors=StringToUnsignedLong(argv[i]);

            break;

          }

        if (LocaleCompare("colorspace",option+1) == 0)

          {

            long

              colorspace;

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            colorspace=ParseMagickOption(MagickColorspaceOptions,MagickFalse,

              argv[i]);

            if (colorspace < 0)

              ThrowImportException(OptionError,"UnrecognizedColorspace",

                argv[i]);

            break;

          }

        if (LocaleCompare("comment",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            status=SetImageOption(image_info,"comment",argv[i]);

            if (status == MagickFalse)

              ThrowImportException(OptionError,"UnrecognizedOption",argv[i]);

            break;

          }

        if (LocaleCompare("compress",option+1) == 0)

          {

            long

              compress;

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            compress=ParseMagickOption(MagickCompressOptions,MagickFalse,

              argv[i]);

            if (compress < 0)

              ThrowImportException(OptionError,"UnrecognizedImageCompression",

                argv[i]);

            break;

          }

        if (LocaleCompare("concurrent",option+1) == 0)

          break;

        if (LocaleCompare("crop",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            break;

          }

        ThrowImportException(OptionError,"UnrecognizedOption",option);

      }

      case 'd':

      {

        if (LocaleCompare("debug",option+1) == 0)

          {

            long

              event;

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            event=ParseMagickOption(MagickLogEventOptions,MagickFalse,argv[i]);

            if (event < 0)

              ThrowImportException(OptionError,"UnrecognizedEventType",argv[i]);

            (void) SetLogEventMask(argv[i]);

            break;

          }

        if (LocaleCompare("define",option+1) == 0)

          {

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (*option == '+')

              {

                const char

                  *define;

                define=GetImageOption(image_info,argv[i]);

                if (define == (char *) NULL)

                  ThrowImportException(OptionError,"NoSuchOption",argv[i]);

                break;

              }

            break;

          }

        if (LocaleCompare("delay",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            status=SetImageOption(image_info,"delay",argv[i]);

            if (status == MagickFalse)

              ThrowImportException(OptionError,"UnrecognizedOption",argv[i]);

            break;

          }

        if (LocaleCompare("density",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            break;

          }

        if (LocaleCompare("depth",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            if (IsGeometry(argv[i]) == MagickFalse)

              ThrowImportInvalidArgumentException(option,argv[i]);

            break;

          }

        if (LocaleCompare("descend",option+1) == 0)

          {

            ximage_info.descend=(*option == '-') ? MagickTrue : MagickFalse;

            break;

          }

        if (LocaleCompare("display",option+1) == 0)

          {

            if (*option == '+')

              break;

            i++;

            if (i == (long) argc)

              ThrowImportException(OptionError,"MissingArgument",option);

            break;

          }

        if (LocaleCompare("dispose",option+1) == 0)

          {

            long