/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                AAA   N   N  IIIII  M   M   AAA   TTTTT  EEEEE               %

%               A   A  NN  N    I    MM MM  A   A    T    E                   %

%               AAAAA  N N N    I    M M M  AAAAA    T    EEE                 %

%               A   A  N  NN    I    M   M  A   A    T    E                   %

%               A   A  N   N  IIIII  M   M  A   A    T    EEEEE               %

%                                                                             %

%                                                                             %

%              Methods to Interactively Animate an Image Sequence             %

%                                                                             %

%                             Software Design                                 %

%                                  Cristy                                     %

%                                July 1992                                    %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 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                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  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.                                             %

%                                                                             %

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

%

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/animate.h"

#include "MagickCore/animate-private.h"

#include "MagickCore/attribute.h"

#include "MagickCore/client.h"

#include "MagickCore/color.h"

#include "MagickCore/color-private.h"

#include "MagickCore/colorspace.h"

#include "MagickCore/colorspace-private.h"

#include "MagickCore/constitute.h"

#include "MagickCore/delegate.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/geometry.h"

#include "MagickCore/image-private.h"

#include "MagickCore/layer.h"

#include "MagickCore/list.h"

#include "MagickCore/locale-private.h"

#include "MagickCore/log.h"

#include "MagickCore/image.h"

#include "MagickCore/memory_.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/property.h"

#include "MagickCore/resource_.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/timer-private.h"

#include "MagickCore/transform.h"

#include "MagickCore/utility.h"

#include "MagickCore/utility-private.h"

#include "MagickCore/version.h"

#include "MagickCore/widget.h"

#include "MagickCore/widget-private.h"

#include "MagickCore/xwindow.h"

#include "MagickCore/xwindow-private.h"

#if defined(MAGICKCORE_X11_DELEGATE)

/*

  Animate state declarations.

*/

#define AutoReverseAnimationState 0x0004U

#define ForwardAnimationState 0x0008U

#define HighlightState  0x0010U

#define PlayAnimationState 0x0020U

#define RepeatAnimationState 0x0040U

#define StepAnimationState 0x0080U

/*

  Static declarations.

*/

static const char

  AnimateHelp[] =

  {

    "BUTTONS\n"

    "\n"

    "  Press any button to map or unmap the Command widget.\n"

    "\n"

    "COMMAND WIDGET\n"

    "  The Command widget lists a number of sub-menus and commands.\n"

    "  They are\n"

    "\n"

    "    Animate\n"

    "      Open...\n"

    "      Save...\n"

    "      Play\n"

    "      Step\n"

    "      Repeat\n"

    "      Auto Reverse\n"

    "    Speed\n"

    "      Slower\n"

    "      Faster\n"

    "    Direction\n"

    "      Forward\n"

    "      Reverse\n"

    "      Help\n"

    "        Overview\n"

    "        Browse Documentation\n"

    "        About Animate\n"

    "    Image Info\n"

    "    Quit\n"

    "\n"

    "  Menu items with a indented triangle have a sub-menu.  They\n"

    "  are represented above as the indented items.  To access a\n"

    "  sub-menu item, move the pointer to the appropriate menu and\n"

    "  press a button and drag.  When you find the desired sub-menu\n"

    "  item, release the button and the command is executed.  Move\n"

    "  the pointer away from the sub-menu if you decide not to\n"

    "  execute a particular command.\n"

    "\n"

    "KEYBOARD ACCELERATORS\n"

    "  Accelerators are one or two key presses that effect a\n"

    "  particular command.  The keyboard accelerators that\n"

    "  animate(1) understands is:\n"

    "\n"

    "  Ctl+O  Press to open an image from a file.\n"

    "\n"

    "  space  Press to display the next image in the sequence.\n"

    "\n"

    "  <      Press to speed-up the display of the images.  Refer to\n"

    "         -delay for more information.\n"

    "\n"

    "  >      Press to slow the display of the images.  Refer to\n"

    "         -delay for more information.\n"

    "\n"

    "  F1     Press to display helpful information about animate(1).\n"

    "\n"

    "  Find   Press to browse documentation about ImageMagick.\n"

    "\n"

    "  ?      Press to display information about the image.  Press\n"

    "         any key or button to erase the information.\n"

    "\n"

    "         This information is printed: image name;  image size;\n"

    "         and the total number of unique colors in the image.\n"

    "\n"

    "  Ctl-q  Press to discard all images and exit program.\n"

  };

/*

  Constant declarations.

*/

static const char

  *PageSizes[] =

  {

    "Letter",

    "Tabloid",

    "Ledger",

    "Legal",

    "Statement",

    "Executive",

    "A3",

    "A4",

    "A5",

    "B4",

    "B5",

    "Folio",

    "Quarto",

    "10x14",

    (char *) NULL

  };

static const unsigned char

  HighlightBitmap[8] =

  {

    (unsigned char) 0xaa,

    (unsigned char) 0x55,

    (unsigned char) 0xaa,

    (unsigned char) 0x55,

    (unsigned char) 0xaa,

    (unsigned char) 0x55,

    (unsigned char) 0xaa,

    (unsigned char) 0x55

  },

  ShadowBitmap[8] =

  {

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00,

    (unsigned char) 0x00

  };

/*

  Enumeration declarations.

*/

typedef enum

{

  OpenCommand,

  SaveCommand,

  PlayCommand,

  StepCommand,

  RepeatCommand,

  AutoReverseCommand,

  SlowerCommand,

  FasterCommand,

  ForwardCommand,

  ReverseCommand,

  HelpCommand,

  BrowseDocumentationCommand,

  VersionCommand,

  InfoCommand,

  QuitCommand,

  StepBackwardCommand,

  StepForwardCommand,

  NullCommand

} AnimateCommand;

/*

  Stipples.

*/

#define HighlightWidth  8

#define HighlightHeight  8

#define ShadowWidth  8

#define ShadowHeight  8

/*

  Forward declarations.

*/

static Image

  *XMagickCommand(Display *,XResourceInfo *,XWindows *,const AnimateCommand,

    Image **,MagickStatusType *,ExceptionInfo *);

static MagickBooleanType

  XSaveImage(Display *,XResourceInfo *,XWindows *,Image *,ExceptionInfo *);

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   A n i m a t e I m a g e s                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  AnimateImages() repeatedly displays an image sequence to any X window

%  screen.  It returns a value other than 0 if successful.  Check the

%  exception member of image to determine the reason for any failure.

%

%  The format of the AnimateImages method is:

%

%      MagickBooleanType AnimateImages(const ImageInfo *image_info,

%        Image *images,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image_info: the image info.

%

%    o image: the image.

%

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

%

*/

MagickExport MagickBooleanType AnimateImages(const ImageInfo *image_info,

  Image *images,ExceptionInfo *exception)

{

  char

    *argv[1];

  Display

    *display;

  MagickStatusType

    status;

  XrmDatabase

    resource_database;

  XResourceInfo

    resource_info;

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

  assert(image_info->signature == MagickCoreSignature);

  assert(images != (Image *) NULL);

  assert(images->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);

  display=XOpenDisplay(image_info->server_name);

  if (display == (Display *) NULL)

    {

      (void) ThrowMagickException(exception,GetMagickModule(),XServerError,

        "UnableToOpenXServer","`%s'",XDisplayName(image_info->server_name));

      return(MagickFalse);

    }

  if (exception->severity != UndefinedException)

    CatchException(exception);

  (void) XSetErrorHandler(XError);

  resource_database=XGetResourceDatabase(display,GetClientName());

  (void) memset(&resource_info,0,sizeof(XResourceInfo));

  XGetResourceInfo(image_info,resource_database,GetClientName(),&resource_info);

  if (image_info->page != (char *) NULL)

    resource_info.image_geometry=AcquireString(image_info->page);

  resource_info.immutable=MagickTrue;

  argv[0]=AcquireString(GetClientName());

  (void) XAnimateImages(display,&resource_info,argv,1,images,exception);

  (void) SetErrorHandler((ErrorHandler) NULL);

  (void) SetWarningHandler((WarningHandler) NULL);

  argv[0]=DestroyString(argv[0]);

  (void) XCloseDisplay(display);

  XDestroyResourceInfo(&resource_info);

  status=exception->severity == UndefinedException ? MagickTrue : MagickFalse;

  return(status != 0 ? MagickTrue : MagickFalse);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

+   X M a g i c k C o m m a n d                                               %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  XMagickCommand() makes a transform to the image or Image window as specified

%  by a user menu button or keyboard command.

%

%  The format of the XMagickCommand method is:

%

%      Image *XMagickCommand(Display *display,XResourceInfo *resource_info,

%        XWindows *windows,const AnimateCommand animate_command,Image **image,

%        MagickStatusType *state,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o display: Specifies a connection to an X server; returned from

%      XOpenDisplay.

%

%    o resource_info: Specifies a pointer to a X11 XResourceInfo structure.

%

%    o windows: Specifies a pointer to a XWindows structure.

%

%    o image: the image;  XMagickCommand

%      may transform the image and return a new image pointer.

%

%    o state: Specifies a MagickStatusType;  XMagickCommand may return a

%      modified state.

%

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

%

%

*/

static Image *XMagickCommand(Display *display,XResourceInfo *resource_info,

  XWindows *windows,const AnimateCommand animate_command,Image **image,

  MagickStatusType *state,ExceptionInfo *exception)

{

  Image

    *nexus;

  MagickBooleanType

    proceed;

  MagickStatusType

    status;

  XTextProperty

    window_name;

  /*

    Process user command.

  */

  nexus=NewImageList();

  switch (animate_command)

  {

    case OpenCommand:

    {

      char

        **filelist;

      Image

        *images,

        *next;

      ImageInfo

        *read_info;

      int

        number_files;

      int

        i;

      static char

        filenames[MagickPathExtent] = "*";

      if (resource_info->immutable != MagickFalse)

        break;

      /*

        Request file name from user.

      */

      XFileBrowserWidget(display,windows,"Animate",filenames);

      if (*filenames == '\0')

        return((Image *) NULL);

      /*

        Expand the filenames.

      */

      filelist=(char **) AcquireMagickMemory(sizeof(char *));

      if (filelist == (char **) NULL)

        {

          ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",

            filenames);

          return((Image *) NULL);

        }

      number_files=1;

      filelist[0]=filenames;

      status=ExpandFilenames(&number_files,&filelist);

      if ((status == MagickFalse) || (number_files == 0))

        {

          for (i=0; i < number_files; i++)

            filelist[i]=DestroyString(filelist[i]);

          filelist=(char **) RelinquishMagickMemory(filelist);

          if (number_files == 0)

            {

              ThrowXWindowException(ImageError,"NoImagesWereLoaded",filenames);

              return((Image *) NULL);

            }

          ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",

            filenames);

          return((Image *) NULL);

        }

      read_info=CloneImageInfo(resource_info->image_info);

      images=NewImageList();

      XSetCursorState(display,windows,MagickTrue);

      XCheckRefreshWindows(display,windows);

      for (i=0; i < number_files; i++)

      {

        (void) CopyMagickString(read_info->filename,filelist[i],MagickPathExtent);

        filelist[i]=DestroyString(filelist[i]);

        *read_info->magick='\0';

        next=ReadImage(read_info,exception);

        CatchException(exception);

        if (next != (Image *) NULL)

          AppendImageToList(&images,next);

        if (number_files <= 5)

          continue;

        proceed=SetImageProgress(images,LoadImageTag,i,(MagickSizeType)

          number_files);

        if (proceed == MagickFalse)

          break;

      }

      filelist=(char **) RelinquishMagickMemory(filelist);

      read_info=DestroyImageInfo(read_info);

      if (images == (Image *) NULL)

        {

          XSetCursorState(display,windows,MagickFalse);

          ThrowXWindowException(ImageError,"NoImagesWereLoaded",filenames);

          return((Image *) NULL);

        }

      nexus=GetFirstImageInList(images);

      *state|=ExitState;

      break;

    }

    case PlayCommand:

    {

      char

        basename[MagickPathExtent],

        name[MagickPathExtent];

      int

        status;

      /*

        Window name is the base of the filename.

      */

      *state|=PlayAnimationState;

      *state&=(~AutoReverseAnimationState);

      GetPathComponent((*image)->magick_filename,BasePath,basename);

      (void) FormatLocaleString(name,MagickPathExtent,"%s: %s",

        MagickPackageName,basename);

      (void) CloneString(&windows->image.name,name);

      if (resource_info->title != (char *) NULL)

        {

          char

            *title;

          title=InterpretImageProperties(resource_info->image_info,*image,

            resource_info->title,exception);

          (void) CloneString(&windows->image.name,title);

          title=DestroyString(title);

        }

      status=XStringListToTextProperty(&windows->image.name,1,&window_name);

      if (status == 0)

        break;

      XSetWMName(display,windows->image.id,&window_name);

      (void) XFree((void *) window_name.value);

      break;

    }

    case StepCommand:

    case StepBackwardCommand:

    case StepForwardCommand:

    {

      *state|=StepAnimationState;

      *state&=(~PlayAnimationState);

      if (animate_command == StepBackwardCommand)

        *state&=(~ForwardAnimationState);

      if (animate_command == StepForwardCommand)

        *state|=ForwardAnimationState;

      break;

    }

    case RepeatCommand:

    {

      *state|=RepeatAnimationState;

      *state&=(~AutoReverseAnimationState);

      *state|=PlayAnimationState;

      break;

    }

    case AutoReverseCommand:

    {

      *state|=AutoReverseAnimationState;

      *state&=(~RepeatAnimationState);

      *state|=PlayAnimationState;

      break;

    }

    case SaveCommand:

    {

      /*

        Save image.

      */

      status=XSaveImage(display,resource_info,windows,*image,exception);

      if (status == MagickFalse)

        {

          char

            message[MagickPathExtent];

          (void) FormatLocaleString(message,MagickPathExtent,"%s:%s",

            exception->reason != (char *) NULL ? exception->reason : "",

            exception->description != (char *) NULL ? exception->description :

            "");

          XNoticeWidget(display,windows,"Unable to save file:",message);

          break;

        }

      break;

    }

    case SlowerCommand:

    {

      resource_info->delay++;

      break;

    }

    case FasterCommand:

    {

      if (resource_info->delay == 0)

        break;

      resource_info->delay--;

      break;

    }

    case ForwardCommand:

    {

      *state=ForwardAnimationState;

      *state&=(~AutoReverseAnimationState);

      break;

    }

    case ReverseCommand:

    {

      *state&=(~ForwardAnimationState);

      *state&=(~AutoReverseAnimationState);

      break;

    }

    case InfoCommand:

    {

      XDisplayImageInfo(display,resource_info,windows,(Image *) NULL,*image,

        exception);

      break;

    }

    case HelpCommand:

    {

      /*

        User requested help.

      */

      XTextViewHelp(display,resource_info,windows,MagickFalse,

        "Help Viewer - Animate",AnimateHelp);

      break;

    }

    case BrowseDocumentationCommand:

    {

      Atom

        mozilla_atom;

      Window

        mozilla_window,

        root_window;

      /*

        Browse the ImageMagick documentation.

      */

      root_window=XRootWindow(display,XDefaultScreen(display));

      mozilla_atom=XInternAtom(display,"_MOZILLA_VERSION",MagickFalse);

      mozilla_window=XWindowByProperty(display,root_window,mozilla_atom);

      if (mozilla_window != (Window) NULL)

        {

          char

            command[MagickPathExtent];

          /*

            Display documentation using Netscape remote control.

          */

          (void) FormatLocaleString(command,MagickPathExtent,

            "openurl(%s,new-tab)",MagickAuthoritativeURL);

          mozilla_atom=XInternAtom(display,"_MOZILLA_COMMAND",MagickFalse);

          (void) XChangeProperty(display,mozilla_window,mozilla_atom,

            XA_STRING,8,PropModeReplace,(unsigned char *) command,

            (int) strlen(command));

          XSetCursorState(display,windows,MagickFalse);

          break;

        }

      XSetCursorState(display,windows,MagickTrue);

      XCheckRefreshWindows(display,windows);

      status=InvokeDelegate(resource_info->image_info,*image,"browse",

        (char *) NULL,exception);

      if (status == MagickFalse)

        XNoticeWidget(display,windows,"Unable to browse documentation",

          (char *) NULL);

      XDelay(display,1500);

      XSetCursorState(display,windows,MagickFalse);

      break;

    }

    case VersionCommand:

    {

      XNoticeWidget(display,windows,GetMagickVersion((size_t *) NULL),

        GetMagickCopyright());

      break;

    }

    case QuitCommand:

    {

      /*

        exit program

      */

      if (resource_info->confirm_exit == MagickFalse)

        XClientMessage(display,windows->image.id,windows->im_protocols,

          windows->im_exit,CurrentTime);

      else

        {

          int

            status;

          /*

            Confirm program exit.

          */

          status=XConfirmWidget(display,windows,"Do you really want to exit",

            resource_info->client_name);

          if (status != 0)

            XClientMessage(display,windows->image.id,windows->im_protocols,

              windows->im_exit,CurrentTime);

        }

      break;

    }

    default:

      break;

  }

  return(nexus);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

+   X A n i m a t e B a c k g r o u n d I m a g e                             %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  XAnimateBackgroundImage() animates an image sequence in the background of

%  a window.

%

%  The format of the XAnimateBackgroundImage method is:

%

%      void XAnimateBackgroundImage(Display *display,

%        XResourceInfo *resource_info,Image *images,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o display: Specifies a connection to an X server;  returned from

%      XOpenDisplay.

%

%    o resource_info: Specifies a pointer to a X11 XResourceInfo structure.

%

%    o images: the image list.

%

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

%

*/

#if defined(__cplusplus) || defined(c_plusplus)

extern "C" {

#endif

static int SceneCompare(const void *x,const void *y)

{

  const Image

    **image_1,

    **image_2;

  image_1=(const Image **) x;

  image_2=(const Image **) y;

  return((int) ((*image_1)->scene-(*image_2)->scene));

}

#if defined(__cplusplus) || defined(c_plusplus)

}

#endif

MagickExport void XAnimateBackgroundImage(Display *display,

  XResourceInfo *resource_info,Image *images,ExceptionInfo *exception)

{

  char

    geometry[MagickPathExtent],

    visual_type[MagickPathExtent];

  Image

    *coalesce_image,

    *display_image,

    **image_list;

  int

    scene;

  MagickStatusType

    status;

  RectangleInfo

    geometry_info;

  ssize_t

    i;

  size_t

    delay,

    number_scenes;

  ssize_t

    iterations;

  static XPixelInfo

    pixel;

  static XStandardColormap

    *map_info;

  static XVisualInfo

    *visual_info = (XVisualInfo *) NULL;

  static XWindowInfo

    window_info;

  unsigned int

    height,

    width;

  Window

    root_window;

  XEvent

    event;

  XGCValues

    context_values;

  XResourceInfo

    resources;

  XWindowAttributes

    window_attributes;

  /*

    Determine target window.

  */

  assert(images != (Image *) NULL);

  assert(images->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);

  resources=(*resource_info);

  window_info.id=(Window) NULL;

  root_window=XRootWindow(display,XDefaultScreen(display));

  if (LocaleCompare(resources.window_id,"root") == 0)

    window_info.id=root_window;

  else

    {

      if (isdigit((int) ((unsigned char) *resources.window_id)) != 0)

        window_info.id=XWindowByID(display,root_window,

          (Window) strtol((char *) resources.window_id,(char **) NULL,0));

      if (window_info.id == (Window) NULL)

        window_info.id=

          XWindowByName(display,root_window,resources.window_id);

    }

  if (window_info.id == (Window) NULL)

    {

      ThrowXWindowException(XServerError,"NoWindowWithSpecifiedIDExists",

        resources.window_id);

      return;

    }

  /*

    Determine window visual id.

  */

  window_attributes.width=XDisplayWidth(display,XDefaultScreen(display));

  window_attributes.height=XDisplayHeight(display,XDefaultScreen(display));

  (void) CopyMagickString(visual_type,"default",MagickPathExtent);

  status=XGetWindowAttributes(display,window_info.id,&window_attributes) != 0 ?

    MagickTrue : MagickFalse;

  if (status != MagickFalse)

    (void) FormatLocaleString(visual_type,MagickPathExtent,"0x%lx",

      XVisualIDFromVisual(window_attributes.visual));

  if (visual_info == (XVisualInfo *) NULL)

    {

      /*

        Allocate standard colormap.

      */

      map_info=XAllocStandardColormap();

      if (map_info == (XStandardColormap *) NULL)

        ThrowXWindowFatalException(ResourceLimitFatalError,

          "MemoryAllocationFailed",images->filename);

      map_info->colormap=(Colormap) NULL;

      pixel.pixels=(unsigned long *) NULL;

      /*

        Initialize visual info.

      */

      resources.map_type=(char *) NULL;

      resources.visual_type=visual_type;

      visual_info=XBestVisualInfo(display,map_info,&resources);

      if (visual_info == (XVisualInfo *) NULL)

        ThrowXWindowFatalException(XServerFatalError,"UnableToGetVisual",

          images->filename);

      /*

        Initialize window info.

      */

      window_info.ximage=(XImage *) NULL;

      window_info.matte_image=(XImage *) NULL;

      window_info.pixmap=(Pixmap) NULL;

      window_info.matte_pixmap=(Pixmap) NULL;

    }

  /*

    Free previous root colors.

  */

  if (window_info.id == root_window)

    XDestroyWindowColors(display,root_window);

  coalesce_image=CoalesceImages(images,exception);

  if (coalesce_image == (Image *) NULL)

    ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",

      images->filename);

  images=coalesce_image;

  if (resources.map_type == (char *) NULL)

    if ((visual_info->klass != TrueColor) &&

        (visual_info->klass != DirectColor))

      {

        Image

          *next;

        /*

          Determine if the sequence of images has the identical colormap.

        */

        for (next=images; next != (Image *) NULL; )

        {

          next->alpha_trait=UndefinedPixelTrait;

          if ((next->storage_class == DirectClass) ||

              (next->colors != images->colors) ||

              (next->colors > (size_t) visual_info->colormap_size))

            break;

          for (i=0; i < (ssize_t) images->colors; i++)

            if (IsPixelInfoEquivalent(next->colormap+i,images->colormap+i) == MagickFalse)

              break;

          if (i < (ssize_t) images->colors)

            break;

          next=GetNextImageInList(next);

        }

        if (next != (Image *) NULL)

          (void) RemapImages(resources.quantize_info,images,(Image *) NULL,

            exception);

      }

  /*

    Sort images by increasing scene number.

  */

  number_scenes=GetImageListLength(images);

  image_list=ImageListToArray(images,exception);

  if (image_list == (Image **) NULL)

    ThrowXWindowFatalException(ResourceLimitFatalError,

      "MemoryAllocationFailed",images->filename);

  for (i=0; i < (ssize_t) number_scenes; i++)

    if (image_list[i]->scene == 0)

      break;

  if (i == (ssize_t) number_scenes)

    qsort((void *) image_list,number_scenes,sizeof(Image *),SceneCompare);

  /*

    Initialize Standard Colormap.

  */

  resources.colormap=SharedColormap;

  display_image=image_list[0];

  for (scene=0; scene < (int) number_scenes; scene++)

  {

    if ((resource_info->map_type != (char *) NULL) ||

        (visual_info->klass == TrueColor) ||

        (visual_info->klass == DirectColor))

      (void) SetImageType(image_list[scene],image_list[scene]->alpha_trait ==

        BlendPixelTrait ? TrueColorType : TrueColorAlphaType,exception);

    if ((display_image->columns < image_list[scene]->columns) &&

        (display_image->rows < image_list[scene]->rows))

      display_image=image_list[scene];

  }

  if ((resource_info->map_type != (char *) NULL) ||

      (visual_info->klass == TrueColor) || (visual_info->klass == DirectColor))

    (void) SetImageType(display_image,display_image->alpha_trait !=

      BlendPixelTrait ? TrueColorType : TrueColorAlphaType,exception);

  XMakeStandardColormap(display,visual_info,&resources,display_image,map_info,

    &pixel,exception);

  /*

    Graphic context superclass.

  */

  context_values.background=pixel.background_color.pixel;

  context_values.foreground=pixel.foreground_color.pixel;

  pixel.annotate_context=XCreateGC(display,window_info.id,(unsigned long)

    (GCBackground | GCForeground),&context_values);

  if (pixel.annotate_context == (GC) NULL)

    ThrowXWindowFatalException(XServerFatalError,"UnableToCreateGraphicContext",

      images->filename);

  /*

    Initialize Image window attributes.

  */

  XGetWindowInfo(display,visual_info,map_info,&pixel,(XFontStruct *) NULL,

    &resources,&window_info);

  /*

    Create the X image.

  */

  window_info.width=(unsigned int) image_list[0]->columns;

  window_info.height=(unsigned int) image_list[0]->rows;

  if ((image_list[0]->columns != window_info.width) ||

      (image_list[0]->rows != window_info.height))

    ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXImage",

      image_list[0]->filename);

  (void) FormatLocaleString(geometry,MagickPathExtent,"%ux%u+0+0>",

    window_attributes.width,window_attributes.height);

  geometry_info.width=window_info.width;

  geometry_info.height=window_info.height;

  geometry_info.x=(ssize_t) window_info.x;

  geometry_info.y=(ssize_t) window_info.y;

  (void) ParseMetaGeometry(geometry,&geometry_info.x,&geometry_info.y,

    &geometry_info.width,&geometry_info.height);

  window_info.width=(unsigned int) geometry_info.width;

  window_info.height=(unsigned int) geometry_info.height;

  window_info.x=(int) geometry_info.x;

  window_info.y=(int) geometry_info.y;

  status=XMakeImage(display,&resources,&window_info,image_list[0],

    window_info.width,window_info.height,exception);

  if (status == MagickFalse)

    ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXImage",

      images->filename);

  window_info.x=0;

  window_info.y=0;

  if (resource_info->debug != MagickFalse)

    {

      (void) LogMagickEvent(X11Event,GetMagickModule(),

        "Image: %s[%.20g] %.20gx%.20g ",image_list[0]->filename,(double)

        image_list[0]->scene,(double) image_list[0]->columns,(double)

        image_list[0]->rows);

      if (image_list[0]->colors != 0)

        (void) LogMagickEvent(X11Event,GetMagickModule(),"%.20gc ",(double)

          image_list[0]->colors);

      (void) LogMagickEvent(X11Event,GetMagickModule(),"%s",

        image_list[0]->magick);

    }

  /*

    Adjust image dimensions as specified by backdrop or geometry options.

  */

  width=window_info.width;

  height=window_info.height;

  if (resources.backdrop != MagickFalse)

    {

      /*

        Center image on window.

      */

      window_info.x=(int) (window_attributes.width/2)-

        (window_info.ximage->width/2);

      window_info.y=(int) (window_attributes.height/2)-

        (window_info.ximage->height/2);

      width=(unsigned int) window_attributes.width;

      height=(unsigned int) window_attributes.height;

    }

  if (resources.image_geometry != (char *) NULL)

    {

      char

        default_geometry[MagickPathExtent];

      int

        flags,

        gravity;

      XSizeHints

        *size_hints;

      /*

        User specified geometry.

      */

      size_hints=XAllocSizeHints();

      if (size_hints == (XSizeHints *) NULL)

        ThrowXWindowFatalException(ResourceLimitFatalError,

          "MemoryAllocationFailed",images->filename);

      size_hints->flags=0L;

      (void) FormatLocaleString(default_geometry,MagickPathExtent,"%ux%u",width,

        height);

      flags=XWMGeometry(display,visual_info->screen,resources.image_geometry,

        default_geometry,window_info.border_width,size_hints,&window_info.x,

        &window_info.y,(int *) &width,(int *) &height,&gravity);

      if (((flags & (XValue | YValue))) != 0)

        {

          width=(unsigned int) window_attributes.width;

          height=(unsigned int) window_attributes.height;

        }

      (void) XFree((void *) size_hints);

    }

  /*

    Create the X pixmap.

  */

  window_info.pixmap=XCreatePixmap(display,window_info.id,(unsigned int) width,

    (unsigned int) height,window_info.depth);

  if (window_info.pixmap == (Pixmap) NULL)

    ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXPixmap",

      images->filename);

  /*

    Display pixmap on the window.

  */

  if (((unsigned int) width > window_info.width) ||

      ((unsigned int) height > window_info.height))

    (void) XFillRectangle(display,window_info.pixmap,

      window_info.annotate_context,0,0,(unsigned int) width,

      (unsigned int) height);

  (void) XPutImage(display,window_info.pixmap,window_info.annotate_context,

    window_info.ximage,0,0,window_info.x,window_info.y,window_info.width,

    window_info.height);

  (void) XSetWindowBackgroundPixmap(display,window_info.id,window_info.pixmap);

  (void) XClearWindow(display,window_info.id);

  /*

    Initialize image pixmaps structure.

  */

  window_info.pixmaps=(Pixmap *) AcquireQuantumMemory(number_scenes,

    sizeof(*window_info.pixmaps));

  window_info.matte_pixmaps=(Pixmap *) AcquireQuantumMemory(number_scenes,

    sizeof(*window_info.matte_pixmaps));

  if ((window_info.pixmaps == (Pixmap *) NULL) ||

      (window_info.matte_pixmaps == (Pixmap *) NULL))

    ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",

      images->filename);

  window_info.pixmaps[0]=window_info.pixmap;

  window_info.matte_pixmaps[0]=window_info.pixmap;

  for (scene=1; scene < (int) number_scenes; scene++)

  {

    unsigned int

      columns,

      rows;

    /*

      Create X image.

    */

    window_info.pixmap=(Pixmap) NULL;

    window_info.matte_pixmap=(Pixmap) NULL;

    if ((resources.map_type != (char *) NULL) ||

        (visual_info->klass == TrueColor) ||

        (visual_info->klass == DirectColor))

      if (image_list[scene]->storage_class == PseudoClass)

        XGetPixelInfo(display,visual_info,map_info,&resources,

          image_list[scene],window_info.pixel_info);

    columns=(unsigned int) image_list[scene]->columns;

    rows=(unsigned int) image_list[scene]->rows;

    if ((image_list[scene]->columns != columns) ||

        (image_list[scene]->rows != rows))

      ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXImage",

        image_list[scene]->filename);

    status=XMakeImage(display,&resources,&window_info,image_list[scene],

      columns,rows,exception);

    if (status == MagickFalse)

      ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXImage",

        images->filename);

    if (resource_info->debug != MagickFalse)

      {

        (void) LogMagickEvent(X11Event,GetMagickModule(),

          "Image: [%.20g] %s %.20gx%.20g ",(double) image_list[scene]->scene,

          image_list[scene]->filename,(double) columns,(double) rows);

        if (image_list[scene]->colors != 0)

          (void) LogMagickEvent(X11Event,GetMagickModule(),"%.20gc ",(double)

            image_list[scene]->colors);

        (void) LogMagickEvent(X11Event,GetMagickModule(),"%s",

          image_list[scene]->magick);

      }

    /*

      Create the X pixmap.

    */

    window_info.pixmap=XCreatePixmap(display,window_info.id,width,height,

      window_info.depth);

    if (window_info.pixmap == (Pixmap) NULL)

      ThrowXWindowFatalException(XServerFatalError,"UnableToCreateXPixmap",

        images->filename);

    /*

      Display pixmap on the window.

    */

    if ((width > window_info.width) || (height > window_info.height))

      (void) XFillRectangle(display,window_info.pixmap,

        window_info.annotate_context,0,0,width,height);

    (void) XPutImage(display,window_info.pixmap,window_info.annotate_context,

      window_info.ximage,0,0,window_info.x,window_info.y,window_info.width,

      window_info.height);

    (void) XSetWindowBackgroundPixmap(display,window_info.id,

      window_info.pixmap);

    (void) XClearWindow(display,window_info.id);

    window_info.pixmaps[scene]=window_info.pixmap;

    window_info.matte_pixmaps[scene]=window_info.matte_pixmap;

    if (image_list[scene]->alpha_trait)

      (void) XClearWindow(display,window_info.id);

    delay=1000*image_list[scene]->delay/(size_t) MagickMax(

      image_list[scene]->ticks_per_second,1L);

    XDelay(display,resources.delay*(delay == 0 ? 10 : delay));

  }

  window_info.pixel_info=(&pixel);

  /*

    Display pixmap on the window.

  */