Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ImageMagick / 173cc0a7caf38d865e79c0825140edf9c3aa5c64 / . / MagickCore / xwindow.c
blob: f85e9de112b47ef87facf19b18f633b95dbf4e00 [file] [log] [blame]
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X X W W IIIII N N DDDD OOO W W %
% X X W W I NN N D D O O W W %
% X W W I N N N D D O O W W %
% X X W W W I N NN D D O O W W W %
% X X W W IIIII N N DDDD OOO W W %
% %
% %
% MagickCore X11 Utility Methods %
% %
% Software Design %
% Cristy %
% July 1992 %
% %
% %
% Copyright 1999-2017 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://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. %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
/*
Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/animate.h"
#include "MagickCore/artifact.h"
#include "MagickCore/blob.h"
#include "MagickCore/cache.h"
#include "MagickCore/client.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colormap.h"
#include "MagickCore/composite.h"
#include "MagickCore/constitute.h"
#include "MagickCore/display.h"
#include "MagickCore/distort.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
#include "MagickCore/geometry.h"
#include "MagickCore/identify.h"
#include "MagickCore/image.h"
#include "MagickCore/image-private.h"
#include "MagickCore/list.h"
#include "MagickCore/locale_.h"
#include "MagickCore/log.h"
#include "MagickCore/magick.h"
#include "MagickCore/memory_.h"
#include "MagickCore/monitor.h"
#include "MagickCore/nt-base-private.h"
#include "MagickCore/option.h"
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/quantize.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/resource_.h"
#include "MagickCore/resize.h"
#include "MagickCore/statistic.h"
#include "MagickCore/string_.h"
#include "MagickCore/string-private.h"
#include "MagickCore/transform.h"
#include "MagickCore/transform-private.h"
#include "MagickCore/token.h"
#include "MagickCore/utility.h"
#include "MagickCore/utility-private.h"
#include "MagickCore/widget.h"
#include "MagickCore/widget-private.h"
#include "MagickCore/xwindow.h"
#include "MagickCore/xwindow-private.h"
#include "MagickCore/version.h"
#if defined(__BEOS__)
#include <OS.h>
#endif
#if defined(MAGICKCORE_X11_DELEGATE)
#include <X11/Xproto.h>
#include <X11/Xlocale.h>
#if defined(MAGICK_HAVE_POLL)
# include <sys/poll.h>
#endif
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
#if defined(MAGICKCORE_HAVE_MACHINE_PARAM_H)
# include <machine/param.h>
#endif
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
#endif
#if defined(MAGICKCORE_HAVE_SHAPE)
#include <X11/extensions/shape.h>
#endif
/*
X defines.
*/
#define XBlueGamma(color) ClampToQuantum(blue_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) blue_gamma)* \
QuantumRange)))
#define XGammaPacket(map,color) (size_t) (map->base_pixel+ \
((ScaleQuantumToShort(XRedGamma((color)->red))*map->red_max/65535L)* \
map->red_mult)+ \
((ScaleQuantumToShort(XGreenGamma((color)->green))*map->green_max/65535L)* \
map->green_mult)+ \
((ScaleQuantumToShort(XBlueGamma((color)->blue))*map->blue_max/65535L)* \
map->blue_mult))
#define XGammaPixel(image,map,color) (size_t) (map->base_pixel+ \
((ScaleQuantumToShort(XRedGamma(GetPixelRed(image,color)))*map->red_max/65535L)* \
map->red_mult)+ \
((ScaleQuantumToShort(XGreenGamma(GetPixelGreen(image,color)))*map->green_max/65535L)* \
map->green_mult)+ \
((ScaleQuantumToShort(XBlueGamma(GetPixelBlue(image,color)))*map->blue_max/65535L)* \
map->blue_mult))
#define XGreenGamma(color) ClampToQuantum(green_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) green_gamma)* \
QuantumRange)))
#define XRedGamma(color) ClampToQuantum(red_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) red_gamma)* \
QuantumRange)))
#define XStandardPixel(map,color) (size_t) (map->base_pixel+ \
(((color)->red*map->red_max/65535L)*map->red_mult)+ \
(((color)->green*map->green_max/65535L)*map->green_mult)+ \
(((color)->blue*map->blue_max/65535L)*map->blue_mult))
#define AccentuateModulate ScaleCharToQuantum(80)
#define HighlightModulate ScaleCharToQuantum(125)
#define ShadowModulate ScaleCharToQuantum(135)
#define DepthModulate ScaleCharToQuantum(185)
#define TroughModulate ScaleCharToQuantum(110)
#define XLIB_ILLEGAL_ACCESS 1
#undef ForgetGravity
#undef NorthWestGravity
#undef NorthGravity
#undef NorthEastGravity
#undef WestGravity
#undef CenterGravity
#undef EastGravity
#undef SouthWestGravity
#undef SouthGravity
#undef SouthEastGravity
#undef StaticGravity
#undef index
#if defined(hpux9)
#define XFD_SET int
#else
#define XFD_SET fd_set
#endif
/*
Enumeration declarations.
*/
typedef enum
{
#undef DoRed
DoRed = 0x0001,
#undef DoGreen
DoGreen = 0x0002,
#undef DoBlue
DoBlue = 0x0004,
DoMatte = 0x0008
} XColorFlags;
/*
Typedef declarations.
*/
typedef struct _DiversityPacket
{
Quantum
red,
green,
blue;
unsigned short
index;
size_t
count;
} DiversityPacket;
/*
Constant declaractions.
*/
static MagickBooleanType
xerror_alert = MagickFalse;
/*
Method prototypes.
*/
static const char
*XVisualClassName(const int);
static double
blue_gamma = 1.0,
green_gamma = 1.0,
red_gamma = 1.0;
static MagickBooleanType
XMakePixmap(Display *,const XResourceInfo *,XWindowInfo *);
static void
XMakeImageLSBFirst(const XResourceInfo *,const XWindowInfo *,Image *,
XImage *,XImage *,ExceptionInfo *),
XMakeImageMSBFirst(const XResourceInfo *,const XWindowInfo *,Image *,
XImage *,XImage *,ExceptionInfo *);
static Window
XSelectWindow(Display *,RectangleInfo *);
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% D e s t r o y X R e s o u r c e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DestroyXResources() destroys any X resources.
%
% The format of the DestroyXResources method is:
%
% void DestroyXResources()
%
% A description of each parameter follows:
%
*/
MagickExport void DestroyXResources(void)
{
register int
i;
unsigned int
number_windows;
XWindowInfo
*magick_windows[MaxXWindows];
XWindows
*windows;
DestroyXWidget();
windows=XSetWindows((XWindows *) ~0);
if ((windows == (XWindows *) NULL) || (windows->display == (Display *) NULL))
return;
number_windows=0;
magick_windows[number_windows++]=(&windows->context);
magick_windows[number_windows++]=(&windows->group_leader);
magick_windows[number_windows++]=(&windows->backdrop);
magick_windows[number_windows++]=(&windows->icon);
magick_windows[number_windows++]=(&windows->image);
magick_windows[number_windows++]=(&windows->info);
magick_windows[number_windows++]=(&windows->magnify);
magick_windows[number_windows++]=(&windows->pan);
magick_windows[number_windows++]=(&windows->command);
magick_windows[number_windows++]=(&windows->widget);
magick_windows[number_windows++]=(&windows->popup);
for (i=0; i < (int) number_windows; i++)
{
if (magick_windows[i]->mapped != MagickFalse)
{
(void) XWithdrawWindow(windows->display,magick_windows[i]->id,
magick_windows[i]->screen);
magick_windows[i]->mapped=MagickFalse;
}
if (magick_windows[i]->name != (char *) NULL)
magick_windows[i]->name=(char *)
RelinquishMagickMemory(magick_windows[i]->name);
if (magick_windows[i]->icon_name != (char *) NULL)
magick_windows[i]->icon_name=(char *)
RelinquishMagickMemory(magick_windows[i]->icon_name);
if (magick_windows[i]->cursor != (Cursor) NULL)
{
(void) XFreeCursor(windows->display,magick_windows[i]->cursor);
magick_windows[i]->cursor=(Cursor) NULL;
}
if (magick_windows[i]->busy_cursor != (Cursor) NULL)
{
(void) XFreeCursor(windows->display,magick_windows[i]->busy_cursor);
magick_windows[i]->busy_cursor=(Cursor) NULL;
}
if (magick_windows[i]->highlight_stipple != (Pixmap) NULL)
{
(void) XFreePixmap(windows->display,
magick_windows[i]->highlight_stipple);
magick_windows[i]->highlight_stipple=(Pixmap) NULL;
}
if (magick_windows[i]->shadow_stipple != (Pixmap) NULL)
{
(void) XFreePixmap(windows->display,magick_windows[i]->shadow_stipple);
magick_windows[i]->shadow_stipple=(Pixmap) NULL;
}
if (magick_windows[i]->ximage != (XImage *) NULL)
{
XDestroyImage(magick_windows[i]->ximage);
magick_windows[i]->ximage=(XImage *) NULL;
}
if (magick_windows[i]->pixmap != (Pixmap) NULL)
{
(void) XFreePixmap(windows->display,magick_windows[i]->pixmap);
magick_windows[i]->pixmap=(Pixmap) NULL;
}
if (magick_windows[i]->id != (Window) NULL)
{
(void) XDestroyWindow(windows->display,magick_windows[i]->id);
magick_windows[i]->id=(Window) NULL;
}
if (magick_windows[i]->destroy != MagickFalse)
{
if (magick_windows[i]->image != (Image *) NULL)
{
magick_windows[i]->image=DestroyImage(magick_windows[i]->image);
magick_windows[i]->image=NewImageList();
}
if (magick_windows[i]->matte_pixmap != (Pixmap) NULL)
{
(void) XFreePixmap(windows->display,
magick_windows[i]->matte_pixmap);
magick_windows[i]->matte_pixmap=(Pixmap) NULL;
}
}
if (magick_windows[i]->segment_info != (void *) NULL)
{
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
XShmSegmentInfo
*segment_info;
segment_info=(XShmSegmentInfo *) magick_windows[i]->segment_info;
if (segment_info != (XShmSegmentInfo *) NULL)
if (segment_info[0].shmid >= 0)
{
if (segment_info[0].shmaddr != NULL)
(void) shmdt(segment_info[0].shmaddr);
(void) shmctl(segment_info[0].shmid,IPC_RMID,0);
segment_info[0].shmaddr=NULL;
segment_info[0].shmid=(-1);
}
#endif
magick_windows[i]->segment_info=(void *)
RelinquishMagickMemory(magick_windows[i]->segment_info);
}
}
windows->icon_resources=(XResourceInfo *)
RelinquishMagickMemory(windows->icon_resources);
if (windows->icon_pixel != (XPixelInfo *) NULL)
{
if (windows->icon_pixel->pixels != (unsigned long *) NULL)
windows->icon_pixel->pixels=(unsigned long *)
RelinquishMagickMemory(windows->icon_pixel->pixels);
if (windows->icon_pixel->annotate_context != (GC) NULL)
XFreeGC(windows->display,windows->icon_pixel->annotate_context);
windows->icon_pixel=(XPixelInfo *)
RelinquishMagickMemory(windows->icon_pixel);
}
if (windows->pixel_info != (XPixelInfo *) NULL)
{
if (windows->pixel_info->pixels != (unsigned long *) NULL)
windows->pixel_info->pixels=(unsigned long *)
RelinquishMagickMemory(windows->pixel_info->pixels);
if (windows->pixel_info->annotate_context != (GC) NULL)
XFreeGC(windows->display,windows->pixel_info->annotate_context);
if (windows->pixel_info->widget_context != (GC) NULL)
XFreeGC(windows->display,windows->pixel_info->widget_context);
if (windows->pixel_info->highlight_context != (GC) NULL)
XFreeGC(windows->display,windows->pixel_info->highlight_context);
windows->pixel_info=(XPixelInfo *)
RelinquishMagickMemory(windows->pixel_info);
}
if (windows->font_info != (XFontStruct *) NULL)
{
XFreeFont(windows->display,windows->font_info);
windows->font_info=(XFontStruct *) NULL;
}
if (windows->class_hints != (XClassHint *) NULL)
{
if (windows->class_hints->res_name != (char *) NULL)
windows->class_hints->res_name=DestroyString(
windows->class_hints->res_name);
if (windows->class_hints->res_class != (char *) NULL)
windows->class_hints->res_class=DestroyString(
windows->class_hints->res_class);
XFree(windows->class_hints);
windows->class_hints=(XClassHint *) NULL;
}
if (windows->manager_hints != (XWMHints *) NULL)
{
XFree(windows->manager_hints);
windows->manager_hints=(XWMHints *) NULL;
}
if (windows->map_info != (XStandardColormap *) NULL)
{
XFree(windows->map_info);
windows->map_info=(XStandardColormap *) NULL;
}
if (windows->icon_map != (XStandardColormap *) NULL)
{
XFree(windows->icon_map);
windows->icon_map=(XStandardColormap *) NULL;
}
if (windows->visual_info != (XVisualInfo *) NULL)
{
XFree(windows->visual_info);
windows->visual_info=(XVisualInfo *) NULL;
}
if (windows->icon_visual != (XVisualInfo *) NULL)
{
XFree(windows->icon_visual);
windows->icon_visual=(XVisualInfo *) NULL;
}
(void) XSetWindows((XWindows *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X A n n o t a t e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XAnnotateImage() annotates the image with text.
%
% The format of the XAnnotateImage method is:
%
% MagickBooleanType XAnnotateImage(Display *display,
% const XPixelInfo *pixel,XAnnotateInfo *annotate_info,Image *image,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
% o annotate_info: Specifies a pointer to a XAnnotateInfo structure.
%
% o image: the image.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XAnnotateImage(Display *display,
const XPixelInfo *pixel,XAnnotateInfo *annotate_info,Image *image,
ExceptionInfo *exception)
{
CacheView
*annotate_view;
GC
annotate_context;
Image
*annotate_image;
int
x,
y;
PixelTrait
alpha_trait;
Pixmap
annotate_pixmap;
unsigned int
depth,
height,
width;
Window
root_window;
XGCValues
context_values;
XImage
*annotate_ximage;
/*
Initialize annotated image.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(pixel != (XPixelInfo *) NULL);
assert(annotate_info != (XAnnotateInfo *) NULL);
assert(image != (Image *) NULL);
/*
Initialize annotated pixmap.
*/
root_window=XRootWindow(display,XDefaultScreen(display));
depth=(unsigned int) XDefaultDepth(display,XDefaultScreen(display));
annotate_pixmap=XCreatePixmap(display,root_window,annotate_info->width,
annotate_info->height,depth);
if (annotate_pixmap == (Pixmap) NULL)
return(MagickFalse);
/*
Initialize graphics info.
*/
context_values.background=0;
context_values.foreground=(size_t) (~0);
context_values.font=annotate_info->font_info->fid;
annotate_context=XCreateGC(display,root_window,(unsigned long)
(GCBackground | GCFont | GCForeground),&context_values);
if (annotate_context == (GC) NULL)
return(MagickFalse);
/*
Draw text to pixmap.
*/
(void) XDrawImageString(display,annotate_pixmap,annotate_context,0,
(int) annotate_info->font_info->ascent,annotate_info->text,
(int) strlen(annotate_info->text));
(void) XFreeGC(display,annotate_context);
/*
Initialize annotated X image.
*/
annotate_ximage=XGetImage(display,annotate_pixmap,0,0,annotate_info->width,
annotate_info->height,AllPlanes,ZPixmap);
if (annotate_ximage == (XImage *) NULL)
return(MagickFalse);
(void) XFreePixmap(display,annotate_pixmap);
/*
Initialize annotated image.
*/
annotate_image=AcquireImage((ImageInfo *) NULL,exception);
if (annotate_image == (Image *) NULL)
return(MagickFalse);
annotate_image->columns=annotate_info->width;
annotate_image->rows=annotate_info->height;
/*
Transfer annotated X image to image.
*/
width=(unsigned int) image->columns;
height=(unsigned int) image->rows;
x=0;
y=0;
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
(void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,(ssize_t) x,
(ssize_t) y,&annotate_image->background_color,exception);
if (annotate_info->stencil == ForegroundStencil)
annotate_image->alpha_trait=BlendPixelTrait;
annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
for (y=0; y < (int) annotate_image->rows; y++)
{
register int
x;
register Quantum
*magick_restrict q;
q=GetCacheViewAuthenticPixels(annotate_view,0,(ssize_t) y,
annotate_image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) annotate_image->columns; x++)
{
SetPixelAlpha(annotate_image,OpaqueAlpha,q);
if (XGetPixel(annotate_ximage,x,y) == 0)
{
/*
Set this pixel to the background color.
*/
SetPixelRed(annotate_image,ScaleShortToQuantum(
pixel->box_color.red),q);
SetPixelGreen(annotate_image,ScaleShortToQuantum(
pixel->box_color.green),q);
SetPixelBlue(annotate_image,ScaleShortToQuantum(
pixel->box_color.blue),q);
if ((annotate_info->stencil == ForegroundStencil) ||
(annotate_info->stencil == OpaqueStencil))
SetPixelAlpha(annotate_image,TransparentAlpha,q);
}
else
{
/*
Set this pixel to the pen color.
*/
SetPixelRed(annotate_image,ScaleShortToQuantum(
pixel->pen_color.red),q);
SetPixelGreen(annotate_image,ScaleShortToQuantum(
pixel->pen_color.green),q);
SetPixelBlue(annotate_image,ScaleShortToQuantum(
pixel->pen_color.blue),q);
if (annotate_info->stencil == BackgroundStencil)
SetPixelAlpha(annotate_image,TransparentAlpha,q);
}
q+=GetPixelChannels(annotate_image);
}
if (SyncCacheViewAuthenticPixels(annotate_view,exception) == MagickFalse)
break;
}
annotate_view=DestroyCacheView(annotate_view);
XDestroyImage(annotate_ximage);
/*
Determine annotate geometry.
*/
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
if ((width != (unsigned int) annotate_image->columns) ||
(height != (unsigned int) annotate_image->rows))
{
char
image_geometry[MagickPathExtent];
/*
Scale image.
*/
(void) FormatLocaleString(image_geometry,MagickPathExtent,"%ux%u",
width,height);
(void) TransformImage(&annotate_image,(char *) NULL,image_geometry,
exception);
}
if (annotate_info->degrees != 0.0)
{
Image
*rotate_image;
int
rotations;
double
normalized_degrees;
/*
Rotate image.
*/
rotate_image=RotateImage(annotate_image,annotate_info->degrees,exception);
if (rotate_image == (Image *) NULL)
return(MagickFalse);
annotate_image=DestroyImage(annotate_image);
annotate_image=rotate_image;
/*
Annotation is relative to the degree of rotation.
*/
normalized_degrees=annotate_info->degrees;
while (normalized_degrees < -45.0)
normalized_degrees+=360.0;
for (rotations=0; normalized_degrees > 45.0; rotations++)
normalized_degrees-=90.0;
switch (rotations % 4)
{
default:
case 0:
break;
case 1:
{
/*
Rotate 90 degrees.
*/
x-=(int) annotate_image->columns/2;
y+=(int) annotate_image->columns/2;
break;
}
case 2:
{
/*
Rotate 180 degrees.
*/
x=x-(int) annotate_image->columns;
break;
}
case 3:
{
/*
Rotate 270 degrees.
*/
x=x-(int) annotate_image->columns/2;
y=y-(int) (annotate_image->rows-(annotate_image->columns/2));
break;
}
}
}
/*
Composite text onto the image.
*/
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
alpha_trait=image->alpha_trait;
(void) CompositeImage(image,annotate_image,
annotate_image->alpha_trait != UndefinedPixelTrait ? OverCompositeOp :
CopyCompositeOp,MagickTrue,(ssize_t) x,(ssize_t) y,exception);
image->alpha_trait=alpha_trait;
annotate_image=DestroyImage(annotate_image);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X B e s t F o n t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XBestFont() returns the "best" font. "Best" is defined as a font specified
% in the X resource database or a font such that the text width displayed
% with the font does not exceed the specified maximum width.
%
% The format of the XBestFont method is:
%
% XFontStruct *XBestFont(Display *display,
% const XResourceInfo *resource_info,const MagickBooleanType text_font)
%
% A description of each parameter follows:
%
% o font: XBestFont returns a pointer to a XFontStruct structure.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o text_font: True is font should be mono-spaced (typewriter style).
%
*/
static char **FontToList(char *font)
{
char
**fontlist;
register char
*p,
*q;
register int
i;
unsigned int
fonts;
if (font == (char *) NULL)
return((char **) NULL);
/*
Convert string to an ASCII list.
*/
fonts=1U;
for (p=font; *p != '\0'; p++)
if ((*p == ':') || (*p == ';') || (*p == ','))
fonts++;
fontlist=(char **) AcquireQuantumMemory((size_t) fonts+1UL,sizeof(*fontlist));
if (fontlist == (char **) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",font);
return((char **) NULL);
}
p=font;
for (i=0; i < (int) fonts; i++)
{
for (q=p; *q != '\0'; q++)
if ((*q == ':') || (*q == ';') || (*q == ','))
break;
fontlist[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+1UL,
sizeof(*fontlist[i]));
if (fontlist[i] == (char *) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",font);
return((char **) NULL);
}
(void) CopyMagickString(fontlist[i],p,(size_t) (q-p+1));
p=q+1;
}
fontlist[i]=(char *) NULL;
return(fontlist);
}
MagickPrivate XFontStruct *XBestFont(Display *display,
const XResourceInfo *resource_info,const MagickBooleanType text_font)
{
static const char
*Fonts[]=
{
"-*-helvetica-medium-r-normal--12-*-*-*-*-*-iso8859-1",
"-*-arial-medium-r-normal--12-*-*-*-*-*-iso8859-1",
"-*-helvetica-medium-r-normal--12-*-*-*-*-*-iso8859-15",
"-*-arial-medium-r-normal--12-*-*-*-*-*-iso8859-15",
"-*-helvetica-medium-r-normal--12-*-*-*-*-*-*-*",
"-*-arial-medium-r-normal--12-*-*-*-*-*-*-*",
"variable",
"fixed",
(char *) NULL
},
*TextFonts[]=
{
"-*-courier-medium-r-normal-*-12-*-*-*-*-*-iso8859-1",
"-*-courier-medium-r-normal-*-12-*-*-*-*-*-iso8859-15",
"-*-fixed-medium-r-normal-*-12-*-*-*-*-*-*-*",
"fixed",
(char *) NULL
};
char
*font_name;
register const char
**p;
XFontStruct
*font_info;
font_info=(XFontStruct *) NULL;
font_name=resource_info->font;
if (text_font != MagickFalse)
font_name=resource_info->text_font;
if ((font_name != (char *) NULL) && (*font_name != '\0'))
{
char
**fontlist;
register int
i;
/*
Load preferred font specified in the X resource database.
*/
fontlist=FontToList(font_name);
if (fontlist != (char **) NULL)
{
for (i=0; fontlist[i] != (char *) NULL; i++)
{
if (font_info == (XFontStruct *) NULL)
font_info=XLoadQueryFont(display,fontlist[i]);
fontlist[i]=DestroyString(fontlist[i]);
}
fontlist=(char **) RelinquishMagickMemory(fontlist);
}
if (font_info == (XFontStruct *) NULL)
ThrowXWindowException(XServerError,"UnableToLoadFont",font_name);
}
/*
Load fonts from list of fonts until one is found.
*/
p=Fonts;
if (text_font != MagickFalse)
p=TextFonts;
if (XDisplayHeight(display,XDefaultScreen(display)) >= 748)
p++;
while (*p != (char *) NULL)
{
if (font_info != (XFontStruct *) NULL)
break;
font_info=XLoadQueryFont(display,(char *) *p);
p++;
}
return(font_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X B e s t I c o n S i z e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XBestIconSize() returns the "best" icon size. "Best" is defined as an icon
% size that maintains the aspect ratio of the image. If the window manager
% has preferred icon sizes, one of the preferred sizes is used.
%
% The format of the XBestIconSize method is:
%
% void XBestIconSize(Display *display,XWindowInfo *window,Image *image)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o image: the image.
%
*/
MagickPrivate void XBestIconSize(Display *display,XWindowInfo *window,
Image *image)
{
int
i,
number_sizes;
double
scale_factor;
unsigned int
height,
icon_height,
icon_width,
width;
Window
root_window;
XIconSize
*icon_size,
*size_list;
/*
Determine if the window manager has specified preferred icon sizes.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (XWindowInfo *) NULL);
assert(image != (Image *) NULL);
window->width=MaxIconSize;
window->height=MaxIconSize;
icon_size=(XIconSize *) NULL;
number_sizes=0;
root_window=XRootWindow(display,window->screen);
if (XGetIconSizes(display,root_window,&size_list,&number_sizes) != 0)
if ((number_sizes > 0) && (size_list != (XIconSize *) NULL))
icon_size=size_list;
if (icon_size == (XIconSize *) NULL)
{
/*
Window manager does not restrict icon size.
*/
icon_size=XAllocIconSize();
if (icon_size == (XIconSize *) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
return;
}
icon_size->min_width=1;
icon_size->max_width=MaxIconSize;
icon_size->min_height=1;
icon_size->max_height=MaxIconSize;
icon_size->width_inc=1;
icon_size->height_inc=1;
}
/*
Determine aspect ratio of image.
*/
width=(unsigned int) image->columns;
height=(unsigned int) image->rows;
i=0;
if (window->crop_geometry)
(void) XParseGeometry(window->crop_geometry,&i,&i,&width,&height);
/*
Look for an icon size that maintains the aspect ratio of image.
*/
scale_factor=(double) icon_size->max_width/width;
if (scale_factor > ((double) icon_size->max_height/height))
scale_factor=(double) icon_size->max_height/height;
icon_width=(unsigned int) icon_size->min_width;
while ((int) icon_width < icon_size->max_width)
{
if (icon_width >= (unsigned int) (scale_factor*width+0.5))
break;
icon_width+=icon_size->width_inc;
}
icon_height=(unsigned int) icon_size->min_height;
while ((int) icon_height < icon_size->max_height)
{
if (icon_height >= (unsigned int) (scale_factor*height+0.5))
break;
icon_height+=icon_size->height_inc;
}
(void) XFree((void *) icon_size);
window->width=icon_width;
window->height=icon_height;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X B e s t P i x e l %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XBestPixel() returns a pixel from an array of pixels that is closest to the
% requested color. If the color array is NULL, the colors are obtained from
% the X server.
%
% The format of the XBestPixel method is:
%
% void XBestPixel(Display *display,const Colormap colormap,XColor *colors,
% unsigned int number_colors,XColor *color)
%
% A description of each parameter follows:
%
% o pixel: XBestPixel returns the pixel value closest to the requested
% color.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o colormap: Specifies the ID of the X server colormap.
%
% o colors: Specifies an array of XColor structures.
%
% o number_colors: Specifies the number of XColor structures in the
% color definition array.
%
% o color: Specifies the desired RGB value to find in the colors array.
%
*/
MagickPrivate void XBestPixel(Display *display,const Colormap colormap,
XColor *colors,unsigned int number_colors,XColor *color)
{
MagickBooleanType
query_server;
PixelInfo
pixel;
double
min_distance;
register double
distance;
register int
i,
j;
Status
status;
/*
Find closest representation for the requested RGB color.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(color != (XColor *) NULL);
status=XAllocColor(display,colormap,color);
if (status != False)
return;
query_server=colors == (XColor *) NULL ? MagickTrue : MagickFalse;
if (query_server != MagickFalse)
{
/*
Read X server colormap.
*/
colors=(XColor *) AcquireQuantumMemory(number_colors,sizeof(*colors));
if (colors == (XColor *) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
"...");
return;
}
for (i=0; i < (int) number_colors; i++)
colors[i].pixel=(size_t) i;
if (number_colors > 256)
number_colors=256;
(void) XQueryColors(display,colormap,colors,(int) number_colors);
}
min_distance=3.0*((double) QuantumRange+1.0)*((double)
QuantumRange+1.0);
j=0;
for (i=0; i < (int) number_colors; i++)
{
pixel.red=colors[i].red-(double) color->red;
distance=pixel.red*pixel.red;
if (distance > min_distance)
continue;
pixel.green=colors[i].green-(double) color->green;
distance+=pixel.green*pixel.green;
if (distance > min_distance)
continue;
pixel.blue=colors[i].blue-(double) color->blue;
distance+=pixel.blue*pixel.blue;
if (distance > min_distance)
continue;
min_distance=distance;
color->pixel=colors[i].pixel;
j=i;
}
(void) XAllocColor(display,colormap,&colors[j]);
if (query_server != MagickFalse)
colors=(XColor *) RelinquishMagickMemory(colors);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X B e s t V i s u a l I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XBestVisualInfo() returns visual information for a visual that is the "best"
% the server supports. "Best" is defined as:
%
% 1. Restrict the visual list to those supported by the default screen.
%
% 2. If a visual type is specified, restrict the visual list to those of
% that type.
%
% 3. If a map type is specified, choose the visual that matches the id
% specified by the Standard Colormap.
%
% 4 From the list of visuals, choose one that can display the most
% simultaneous colors. If more than one visual can display the same
% number of simultaneous colors, one is chosen based on a rank.
%
% The format of the XBestVisualInfo method is:
%
% XVisualInfo *XBestVisualInfo(Display *display,
% XStandardColormap *map_info,XResourceInfo *resource_info)
%
% A description of each parameter follows:
%
% o visual_info: XBestVisualInfo returns a pointer to a X11 XVisualInfo
% structure.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o map_info: If map_type is specified, this structure is initialized
% with info from the Standard Colormap.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickPrivate XVisualInfo *XBestVisualInfo(Display *display,
XStandardColormap *map_info,XResourceInfo *resource_info)
{
#define MaxStandardColormaps 7
#define XVisualColormapSize(visual_info) MagickMin((unsigned int) (\
(visual_info->klass == TrueColor) || (visual_info->klass == DirectColor) ? \
visual_info->red_mask | visual_info->green_mask | visual_info->blue_mask : \
(unsigned long) visual_info->colormap_size),1UL << visual_info->depth)
char
*map_type,
*visual_type;
int
visual_mask;
register int
i;
size_t
one;
static int
number_visuals;
static XVisualInfo
visual_template;
XVisualInfo
*visual_info,
*visual_list;
/*
Restrict visual search by screen number.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(map_info != (XStandardColormap *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
map_type=resource_info->map_type;
visual_type=resource_info->visual_type;
visual_mask=VisualScreenMask;
visual_template.screen=XDefaultScreen(display);
visual_template.depth=XDefaultDepth(display,XDefaultScreen(display));
one=1;
if ((resource_info->immutable != MagickFalse) && (resource_info->colors != 0))
if (resource_info->colors <= (one << (size_t) visual_template.depth))
visual_mask|=VisualDepthMask;
if (visual_type != (char *) NULL)
{
/*
Restrict visual search by class or visual id.
*/
if (LocaleCompare("staticgray",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=StaticGray;
}
else
if (LocaleCompare("grayscale",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=GrayScale;
}
else
if (LocaleCompare("staticcolor",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=StaticColor;
}
else
if (LocaleCompare("pseudocolor",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=PseudoColor;
}
else
if (LocaleCompare("truecolor",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=TrueColor;
}
else
if (LocaleCompare("directcolor",visual_type) == 0)
{
visual_mask|=VisualClassMask;
visual_template.klass=DirectColor;
}
else
if (LocaleCompare("default",visual_type) == 0)
{
visual_mask|=VisualIDMask;
visual_template.visualid=XVisualIDFromVisual(
XDefaultVisual(display,XDefaultScreen(display)));
}
else
if (isdigit((int) ((unsigned char) *visual_type)) != 0)
{
visual_mask|=VisualIDMask;
visual_template.visualid=
strtol(visual_type,(char **) NULL,0);
}
else
ThrowXWindowException(XServerError,
"UnrecognizedVisualSpecifier",visual_type);
}
/*
Get all visuals that meet our criteria so far.
*/
number_visuals=0;
visual_list=XGetVisualInfo(display,visual_mask,&visual_template,
&number_visuals);
visual_mask=VisualScreenMask | VisualIDMask;
if ((number_visuals == 0) || (visual_list == (XVisualInfo *) NULL))
{
/*
Failed to get visual; try using the default visual.
*/
ThrowXWindowException(XServerWarning,"UnableToGetVisual",visual_type);
visual_template.visualid=XVisualIDFromVisual(XDefaultVisual(display,
XDefaultScreen(display)));
visual_list=XGetVisualInfo(display,visual_mask,&visual_template,
&number_visuals);
if ((number_visuals == 0) || (visual_list == (XVisualInfo *) NULL))
return((XVisualInfo *) NULL);
ThrowXWindowException(XServerWarning,"UsingDefaultVisual",
XVisualClassName(visual_list->klass));
}
resource_info->color_recovery=MagickFalse;
if ((map_info != (XStandardColormap *) NULL) && (map_type != (char *) NULL))
{
Atom
map_property;
char
map_name[MagickPathExtent];
int
j,
number_maps;
Status
status;
Window
root_window;
XStandardColormap
*map_list;
/*
Choose a visual associated with a standard colormap.
*/
root_window=XRootWindow(display,XDefaultScreen(display));
status=False;
number_maps=0;
if (LocaleCompare(map_type,"list") != 0)
{
/*
User specified Standard Colormap.
*/
(void) FormatLocaleString((char *) map_name,MagickPathExtent,
"RGB_%s_MAP",map_type);
LocaleUpper(map_name);
map_property=XInternAtom(display,(char *) map_name,MagickTrue);
if (map_property != (Atom) NULL)
status=XGetRGBColormaps(display,root_window,&map_list,&number_maps,
map_property);
}
else
{
static const char
*colormap[MaxStandardColormaps]=
{
"_HP_RGB_SMOOTH_MAP_LIST",
"RGB_BEST_MAP",
"RGB_DEFAULT_MAP",
"RGB_GRAY_MAP",
"RGB_RED_MAP",
"RGB_GREEN_MAP",
"RGB_BLUE_MAP",
};
/*
Choose a standard colormap from a list.
*/
for (i=0; i < MaxStandardColormaps; i++)
{
map_property=XInternAtom(display,(char *) colormap[i],MagickTrue);
if (map_property == (Atom) NULL)
continue;
status=XGetRGBColormaps(display,root_window,&map_list,&number_maps,
map_property);
if (status != False)
break;
}
resource_info->color_recovery=i == 0 ? MagickTrue : MagickFalse;
}
if (status == False)
{
ThrowXWindowException(XServerError,"UnableToGetStandardColormap",
map_type);
return((XVisualInfo *) NULL);
}
/*
Search all Standard Colormaps and visuals for ids that match.
*/
*map_info=map_list[0];
#if !defined(PRE_R4_ICCCM)
visual_template.visualid=XVisualIDFromVisual(visual_list[0].visual);
for (i=0; i < number_maps; i++)
for (j=0; j < number_visuals; j++)
if (map_list[i].visualid ==
XVisualIDFromVisual(visual_list[j].visual))
{
*map_info=map_list[i];
visual_template.visualid=XVisualIDFromVisual(
visual_list[j].visual);
break;
}
if (map_info->visualid != visual_template.visualid)
{
ThrowXWindowException(XServerError,
"UnableToMatchVisualToStandardColormap",map_type);
return((XVisualInfo *) NULL);
}
#endif
if (map_info->colormap == (Colormap) NULL)
{
ThrowXWindowException(XServerError,"StandardColormapIsNotInitialized",
map_type);
return((XVisualInfo *) NULL);
}
(void) XFree((void *) map_list);
}
else
{
static const unsigned int
rank[]=
{
StaticGray,
GrayScale,
StaticColor,
DirectColor,
TrueColor,
PseudoColor
};
XVisualInfo
*p;
/*
Pick one visual that displays the most simultaneous colors.
*/
visual_info=visual_list;
p=visual_list;
for (i=1; i < number_visuals; i++)
{
p++;
if (XVisualColormapSize(p) > XVisualColormapSize(visual_info))
visual_info=p;
else
if (XVisualColormapSize(p) == XVisualColormapSize(visual_info))
if (rank[p->klass] > rank[visual_info->klass])
visual_info=p;
}
visual_template.visualid=XVisualIDFromVisual(visual_info->visual);
}
(void) XFree((void *) visual_list);
/*
Retrieve only one visual by its screen & id number.
*/
visual_info=XGetVisualInfo(display,visual_mask,&visual_template,
&number_visuals);
if ((number_visuals == 0) || (visual_info == (XVisualInfo *) NULL))
return((XVisualInfo *) NULL);
return(visual_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X C h e c k D e f i n e C u r s o r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XCheckDefineCursor() prevents cursor changes on the root window.
%
% The format of the XXCheckDefineCursor method is:
%
% XCheckDefineCursor(display,window,cursor)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: the window.
%
% o cursor: the cursor.
%
*/
MagickPrivate int XCheckDefineCursor(Display *display,Window window,
Cursor cursor)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
if (window == XRootWindow(display,XDefaultScreen(display)))
return(0);
return(XDefineCursor(display,window,cursor));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X C h e c k R e f r e s h W i n d o w s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XCheckRefreshWindows() checks the X server for exposure events for a
% particular window and updates the areassociated with the exposure event.
%
% The format of the XCheckRefreshWindows method is:
%
% void XCheckRefreshWindows(Display *display,XWindows *windows)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o windows: Specifies a pointer to a XWindows structure.
%
*/
MagickPrivate void XCheckRefreshWindows(Display *display,XWindows *windows)
{
Window
id;
XEvent
event;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(windows != (XWindows *) NULL);
XDelay(display,SuspendTime);
id=windows->command.id;
while (XCheckTypedWindowEvent(display,id,Expose,&event) != MagickFalse)
(void) XCommandWidget(display,windows,(char const **) NULL,&event);
id=windows->image.id;
while (XCheckTypedWindowEvent(display,id,Expose,&event) != MagickFalse)
XRefreshWindow(display,&windows->image,&event);
XDelay(display,SuspendTime << 1);
id=windows->command.id;
while (XCheckTypedWindowEvent(display,id,Expose,&event) != MagickFalse)
(void) XCommandWidget(display,windows,(char const **) NULL,&event);
id=windows->image.id;
while (XCheckTypedWindowEvent(display,id,Expose,&event) != MagickFalse)
XRefreshWindow(display,&windows->image,&event);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X C l i e n t M e s s a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XClientMessage() sends a reason to a window with XSendEvent. The reason is
% initialized with a particular protocol type and atom.
%
% The format of the XClientMessage function is:
%
% XClientMessage(display,window,protocol,reason,timestamp)
%
% A description of each parameter follows:
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window structure.
%
% o protocol: Specifies an atom value.
%
% o reason: Specifies an atom value which is the reason to send.
%
% o timestamp: Specifies a value of type Time.
%
*/
MagickPrivate void XClientMessage(Display *display,const Window window,
const Atom protocol,const Atom reason,const Time timestamp)
{
XClientMessageEvent
client_event;
assert(display != (Display *) NULL);
client_event.type=ClientMessage;
client_event.window=window;
client_event.message_type=protocol;
client_event.format=32;
client_event.data.l[0]=(long) reason;
client_event.data.l[1]=(long) timestamp;
(void) XSendEvent(display,window,MagickFalse,NoEventMask,(XEvent *) &client_event);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X C l i e n t W i n d o w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XClientWindow() finds a window, at or below the specified window, which has
% a WM_STATE property. If such a window is found, it is returned, otherwise
% the argument window is returned.
%
% The format of the XClientWindow function is:
%
% client_window=XClientWindow(display,target_window)
%
% A description of each parameter follows:
%
% o client_window: XClientWindow returns a window, at or below the specified
% window, which has a WM_STATE property otherwise the argument
% target_window is returned.
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o target_window: Specifies the window to find a WM_STATE property.
%
*/
static Window XClientWindow(Display *display,Window target_window)
{
Atom
state,
type;
int
format;
Status
status;
unsigned char
*data;
unsigned long
after,
number_items;
Window
client_window;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
state=XInternAtom(display,"WM_STATE",MagickTrue);
if (state == (Atom) NULL)
return(target_window);
type=(Atom) NULL;
status=XGetWindowProperty(display,target_window,state,0L,0L,MagickFalse,
(Atom) AnyPropertyType,&type,&format,&number_items,&after,&data);
if ((status == Success) && (type != (Atom) NULL))
return(target_window);
client_window=XWindowByProperty(display,target_window,state);
if (client_window == (Window) NULL)
return(target_window);
return(client_window);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X C o m p o n e n t T e r m i n u s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XComponentTerminus() destroys the module component.
%
% The format of the XComponentTerminus method is:
%
% XComponentTerminus(void)
%
*/
MagickPrivate void XComponentTerminus(void)
{
DestroyXResources();
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X C o n f i g u r e I m a g e C o l o r m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XConfigureImageColormap() creates a new X colormap.
%
% The format of the XConfigureImageColormap method is:
%
% void XConfigureImageColormap(Display *display,
% XResourceInfo *resource_info,XWindows *windows,Image *image,
% 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.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate void XConfigureImageColormap(Display *display,
XResourceInfo *resource_info,XWindows *windows,Image *image,
ExceptionInfo *exception)
{
Colormap
colormap;
/*
Make standard colormap.
*/
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
XMakeStandardColormap(display,windows->visual_info,resource_info,image,
windows->map_info,windows->pixel_info,exception);
colormap=windows->map_info->colormap;
(void) XSetWindowColormap(display,windows->image.id,colormap);
(void) XSetWindowColormap(display,windows->command.id,colormap);
(void) XSetWindowColormap(display,windows->widget.id,colormap);
if (windows->magnify.mapped != MagickFalse)
(void) XSetWindowColormap(display,windows->magnify.id,colormap);
if (windows->pan.mapped != MagickFalse)
(void) XSetWindowColormap(display,windows->pan.id,colormap);
XSetCursorState(display,windows,MagickFalse);
XClientMessage(display,windows->image.id,windows->im_protocols,
windows->im_update_colormap,CurrentTime);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X C o n s t r a i n W i n d o w P o s i t i o n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XConstrainWindowPosition() assures a window is positioned within the X
% server boundaries.
%
% The format of the XConstrainWindowPosition method is:
%
% void XConstrainWindowPosition(Display *display,XWindowInfo *window_info)
%
% A description of each parameter follows:
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o window_info: Specifies a pointer to a XWindowInfo structure.
%
*/
MagickPrivate void XConstrainWindowPosition(Display *display,
XWindowInfo *window_info)
{
int
limit;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window_info != (XWindowInfo *) NULL);
limit=XDisplayWidth(display,window_info->screen)-window_info->width;
if (window_info->x < 0)
window_info->x=0;
else
if (window_info->x > (int) limit)
window_info->x=(int) limit;
limit=XDisplayHeight(display,window_info->screen)-window_info->height;
if (window_info->y < 0)
window_info->y=0;
else
if (window_info->y > limit)
window_info->y=limit;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X D e l a y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDelay() suspends program execution for the number of milliseconds
% specified.
%
% The format of the Delay method is:
%
% void XDelay(Display *display,const size_t milliseconds)
%
% A description of each parameter follows:
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o milliseconds: Specifies the number of milliseconds to delay before
% returning.
%
*/
MagickPrivate void XDelay(Display *display,const size_t milliseconds)
{
assert(display != (Display *) NULL);
(void) XFlush(display);
MagickDelay(milliseconds);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X D e s t r o y R e s o u r c e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDestroyResourceInfo() frees memory associated with the XResourceInfo
% structure.
%
% The format of the XDestroyResourceInfo method is:
%
% void XDestroyResourceInfo(XResourceInfo *resource_info)
%
% A description of each parameter follows:
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickExport void XDestroyResourceInfo(XResourceInfo *resource_info)
{
if (resource_info->image_geometry != (char *) NULL)
resource_info->image_geometry=(char *)
RelinquishMagickMemory(resource_info->image_geometry);
if (resource_info->quantize_info != (QuantizeInfo *) NULL)
resource_info->quantize_info=DestroyQuantizeInfo(
resource_info->quantize_info);
if (resource_info->client_name != (char *) NULL)
resource_info->client_name=(char *)
RelinquishMagickMemory(resource_info->client_name);
if (resource_info->name != (char *) NULL)
resource_info->name=DestroyString(resource_info->name);
(void) ResetMagickMemory(resource_info,0,sizeof(*resource_info));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X D e s t r o y W i n d o w C o l o r s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDestroyWindowColors() frees X11 color resources previously saved on a
% window by XRetainWindowColors or programs like xsetroot.
%
% The format of the XDestroyWindowColors method is:
%
% void XDestroyWindowColors(Display *display,Window window)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window structure.
%
*/
MagickPrivate void XDestroyWindowColors(Display *display,Window window)
{
Atom
property,
type;
int
format;
Status
status;
unsigned char
*data;
unsigned long
after,
length;
/*
If there are previous resources on the root window, destroy them.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
property=XInternAtom(display,"_XSETROOT_ID",MagickFalse);
if (property == (Atom) NULL)
{
ThrowXWindowException(XServerError,"UnableToCreateProperty",
"_XSETROOT_ID");
return;
}
status=XGetWindowProperty(display,window,property,0L,1L,MagickTrue,
(Atom) AnyPropertyType,&type,&format,&length,&after,&data);
if (status != Success)
return;
if ((type == XA_PIXMAP) && (format == 32) && (length == 1) && (after == 0))
{
(void) XKillClient(display,(XID) (*((Pixmap *) data)));
(void) XDeleteProperty(display,window,property);
}
if (type != None)
(void) XFree((void *) data);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X D i s p l a y I m a g e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDisplayImageInfo() displays information about an X image.
%
% The format of the XDisplayImageInfo method is:
%
% void XDisplayImageInfo(Display *display,
% const XResourceInfo *resource_info,XWindows *windows,Image *undo_image,
% Image *image,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 undo_image: the undo image.
%
% o image: the image.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate void XDisplayImageInfo(Display *display,
const XResourceInfo *resource_info,XWindows *windows,Image *undo_image,
Image *image,ExceptionInfo *exception)
{
char
filename[MagickPathExtent],
*text,
**textlist;
FILE
*file;
int
unique_file;
register ssize_t
i;
size_t
number_pixels;
ssize_t
bytes;
unsigned int
levels;
/*
Write info about the X server to a file.
*/
assert(display != (Display *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(windows != (XWindows *) NULL);
assert(image != (Image *) NULL);
if (image->debug)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
file=(FILE *) NULL;
unique_file=AcquireUniqueFileResource(filename);
if (unique_file != -1)
file=fdopen(unique_file,"w");
if ((unique_file == -1) || (file == (FILE *) NULL))
{
XNoticeWidget(display,windows,"Unable to display image info",filename);
return;
}
if (resource_info->gamma_correct != MagickFalse)
if (resource_info->display_gamma != (char *) NULL)
(void) FormatLocaleFile(file,"Display\n gamma: %s\n\n",
resource_info->display_gamma);
/*
Write info about the X image to a file.
*/
(void) FormatLocaleFile(file,"X\n visual: %s\n",
XVisualClassName((int) windows->image.storage_class));
(void) FormatLocaleFile(file," depth: %d\n",windows->image.ximage->depth);
if (windows->visual_info->colormap_size != 0)
(void) FormatLocaleFile(file," colormap size: %d\n",
windows->visual_info->colormap_size);
if (resource_info->colormap== SharedColormap)
(void) FormatLocaleFile(file," colormap type: Shared\n");
else
(void) FormatLocaleFile(file," colormap type: Private\n");
(void) FormatLocaleFile(file," geometry: %dx%d\n",
windows->image.ximage->width,windows->image.ximage->height);
if (windows->image.crop_geometry != (char *) NULL)
(void) FormatLocaleFile(file," crop geometry: %s\n",
windows->image.crop_geometry);
if (windows->image.pixmap == (Pixmap) NULL)
(void) FormatLocaleFile(file," type: X Image\n");
else
(void) FormatLocaleFile(file," type: Pixmap\n");
if (windows->image.shape != MagickFalse)
(void) FormatLocaleFile(file," non-rectangular shape: True\n");
else
(void) FormatLocaleFile(file," non-rectangular shape: False\n");
if (windows->image.shared_memory != MagickFalse)
(void) FormatLocaleFile(file," shared memory: True\n");
else
(void) FormatLocaleFile(file," shared memory: False\n");
(void) FormatLocaleFile(file,"\n");
if (resource_info->font != (char *) NULL)
(void) FormatLocaleFile(file,"Font: %s\n\n",resource_info->font);
if (resource_info->text_font != (char *) NULL)
(void) FormatLocaleFile(file,"Text font: %s\n\n",resource_info->text_font);
/*
Write info about the undo cache to a file.
*/
bytes=0;
for (levels=0; undo_image != (Image *) NULL; levels++)
{
number_pixels=undo_image->list->columns*undo_image->list->rows;
bytes+=number_pixels*sizeof(PixelInfo);
undo_image=GetPreviousImageInList(undo_image);
}
(void) FormatLocaleFile(file,"Undo Edit Cache\n levels: %u\n",levels);
(void) FormatLocaleFile(file," bytes: %.20gmb\n",(double)
((bytes+(1 << 19)) >> 20));
(void) FormatLocaleFile(file," limit: %.20gmb\n\n",(double)
resource_info->undo_cache);
/*
Write info about the image to a file.
*/
(void) IdentifyImage(image,file,MagickTrue,exception);
(void) fclose(file);
text=FileToString(filename,~0UL,exception);
(void) RelinquishUniqueFileResource(filename);
if (text == (char *) NULL)
{
XNoticeWidget(display,windows,"MemoryAllocationFailed",
"UnableToDisplayImageInfo");
return;
}
textlist=StringToList(text);
if (textlist != (char **) NULL)
{
char
title[MagickPathExtent];
/*
Display information about the image in the Text View widget.
*/
(void) XWithdrawWindow(display,windows->info.id,windows->info.screen);
(void) FormatLocaleString(title,MagickPathExtent,"Image Info: %s",
image->filename);
XTextViewWidget(display,resource_info,windows,MagickTrue,title,
(char const **) textlist);
for (i=0; textlist[i] != (char *) NULL; i++)
textlist[i]=DestroyString(textlist[i]);
textlist=(char **) RelinquishMagickMemory(textlist);
}
text=DestroyString(text);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X D i t h e r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDitherImage() dithers the reference image as required by the HP Color
% Recovery algorithm. The color values are quantized to 3 bits of red and
% green, and 2 bits of blue (3/3/2) and can be used as indices into a 8-bit X
% standard colormap.
%
% The format of the XDitherImage method is:
%
% void XDitherImage(Image *image,XImage *ximage,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o ximage: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
% o exception: return any errors or warnings in this structure.
%
*/
static void XDitherImage(Image *image,XImage *ximage,ExceptionInfo *exception)
{
static const short int
dither_red[2][16]=
{
{-16, 4, -1, 11,-14, 6, -3, 9,-15, 5, -2, 10,-13, 7, -4, 8},
{ 15, -5, 0,-12, 13, -7, 2,-10, 14, -6, 1,-11, 12, -8, 3, -9}
},
dither_green[2][16]=
{
{ 11,-15, 7, -3, 8,-14, 4, -2, 10,-16, 6, -4, 9,-13, 5, -1},
{-12, 14, -8, 2, -9, 13, -5, 1,-11, 15, -7, 3,-10, 12, -6, 0}
},
dither_blue[2][16]=
{
{ -3, 9,-13, 7, -1, 11,-15, 5, -4, 8,-14, 6, -2, 10,-16, 4},
{ 2,-10, 12, -8, 0,-12, 14, -6, 3, -9, 13, -7, 1,-11, 15, -5}
};
CacheView
*image_view;
int
value,
y;
PixelInfo
color;
register char
*q;
register const Quantum
*p;
register int
i,
j,
x;
unsigned int
scanline_pad;
register size_t
pixel;
unsigned char
*blue_map[2][16],
*green_map[2][16],
*red_map[2][16];
/*
Allocate and initialize dither maps.
*/
for (i=0; i < 2; i++)
for (j=0; j < 16; j++)
{
red_map[i][j]=(unsigned char *) AcquireQuantumMemory(256UL,
sizeof(*red_map));
green_map[i][j]=(unsigned char *) AcquireQuantumMemory(256UL,
sizeof(*green_map));
blue_map[i][j]=(unsigned char *) AcquireQuantumMemory(256UL,
sizeof(*blue_map));
if ((red_map[i][j] == (unsigned char *) NULL) ||
(green_map[i][j] == (unsigned char *) NULL) ||
(blue_map[i][j] == (unsigned char *) NULL))
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
return;
}
}
/*
Initialize dither tables.
*/
for (i=0; i < 2; i++)
for (j=0; j < 16; j++)
for (x=0; x < 256; x++)
{
value=x-16;
if (x < 48)
value=x/2+8;
value+=dither_red[i][j];
red_map[i][j][x]=(unsigned char)
((value < 0) ? 0 : (value > 255) ? 255 : value);
value=x-16;
if (x < 48)
value=x/2+8;
value+=dither_green[i][j];
green_map[i][j][x]=(unsigned char)
((value < 0) ? 0 : (value > 255) ? 255 : value);
value=x-32;
if (x < 112)
value=x/2+24;
value+=((size_t) dither_blue[i][j] << 1);
blue_map[i][j][x]=(unsigned char)
((value < 0) ? 0 : (value > 255) ? 255 : value);
}
/*
Dither image.
*/
scanline_pad=(unsigned int) (ximage->bytes_per_line-
((size_t) (ximage->width*ximage->bits_per_pixel) >> 3));
i=0;
j=0;
q=ximage->data;
image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (int) image->rows; y++)
{
p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) y,image->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
{
color.red=(double) ClampToQuantum((double) (red_map[i][j][
(int) ScaleQuantumToChar(GetPixelRed(image,p))] << 8));
color.green=(double) ClampToQuantum((double) (green_map[i][j][
(int) ScaleQuantumToChar(GetPixelGreen(image,p))] << 8));
color.blue=(double) ClampToQuantum((double) (blue_map[i][j][
(int) ScaleQuantumToChar(GetPixelBlue(image,p))] << 8));
pixel=(size_t) (((size_t) color.red & 0xe0) |
(((size_t) color.green & 0xe0) >> 3) |
(((size_t) color.blue & 0xc0) >> 6));
*q++=(char) pixel;
p+=GetPixelChannels(image);
j++;
if (j == 16)
j=0;
}
q+=scanline_pad;
i++;
if (i == 2)
i=0;
}
image_view=DestroyCacheView(image_view);
/*
Free allocated memory.
*/
for (i=0; i < 2; i++)
for (j=0; j < 16; j++)
{
green_map[i][j]=(unsigned char *) RelinquishMagickMemory(green_map[i][j]);
blue_map[i][j]=(unsigned char *) RelinquishMagickMemory(blue_map[i][j]);
red_map[i][j]=(unsigned char *) RelinquishMagickMemory(red_map[i][j]);
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X D r a w I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XDrawImage() draws a line on the image.
%
% The format of the XDrawImage method is:
%
% MagickBooleanType XDrawImage(Display *display,const XPixelInfo *pixel,
% XDrawInfo *draw_info,Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
% o draw_info: Specifies a pointer to a XDrawInfo structure.
%
% o image: the image.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XDrawImage(Display *display,
const XPixelInfo *pixel,XDrawInfo *draw_info,Image *image,
ExceptionInfo *exception)
{
CacheView
*draw_view;
GC
draw_context;
Image
*draw_image;
int
x,
y;
PixelTrait
alpha_trait;
Pixmap
draw_pixmap;
unsigned int
depth,
height,
width;
Window
root_window;
XGCValues
context_values;
XImage
*draw_ximage;
/*
Initialize drawd image.
*/
assert(display != (Display *) NULL);
assert(pixel != (XPixelInfo *) NULL);
assert(draw_info != (XDrawInfo *) NULL);
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
/*
Initialize drawd pixmap.
*/
root_window=XRootWindow(display,XDefaultScreen(display));
depth=(unsigned int) XDefaultDepth(display,XDefaultScreen(display));
draw_pixmap=XCreatePixmap(display,root_window,draw_info->width,
draw_info->height,depth);
if (draw_pixmap == (Pixmap) NULL)
return(MagickFalse);
/*
Initialize graphics info.
*/
context_values.background=(size_t) (~0);
context_values.foreground=0;
context_values.line_width=(int) draw_info->line_width;
draw_context=XCreateGC(display,root_window,(size_t)
(GCBackground | GCForeground | GCLineWidth),&context_values);
if (draw_context == (GC) NULL)
return(MagickFalse);
/*
Clear pixmap.
*/
(void) XFillRectangle(display,draw_pixmap,draw_context,0,0,draw_info->width,
draw_info->height);
/*
Draw line to pixmap.
*/
(void) XSetBackground(display,draw_context,0);
(void) XSetForeground(display,draw_context,(size_t) (~0));
if (draw_info->stipple != (Pixmap) NULL)
{
(void) XSetFillStyle(display,draw_context,FillOpaqueStippled);
(void) XSetStipple(display,draw_context,draw_info->stipple);
}
switch (draw_info->element)
{
case PointElement:
default:
{
(void) XDrawLines(display,draw_pixmap,draw_context,
draw_info->coordinate_info,(int) draw_info->number_coordinates,
CoordModeOrigin);
break;
}
case LineElement:
{
(void) XDrawLine(display,draw_pixmap,draw_context,draw_info->line_info.x1,
draw_info->line_info.y1,draw_info->line_info.x2,
draw_info->line_info.y2);
break;
}
case RectangleElement:
{
(void) XDrawRectangle(display,draw_pixmap,draw_context,
(int) draw_info->rectangle_info.x,(int) draw_info->rectangle_info.y,
(unsigned int) draw_info->rectangle_info.width,
(unsigned int) draw_info->rectangle_info.height);
break;
}
case FillRectangleElement:
{
(void) XFillRectangle(display,draw_pixmap,draw_context,
(int) draw_info->rectangle_info.x,(int) draw_info->rectangle_info.y,
(unsigned int) draw_info->rectangle_info.width,
(unsigned int) draw_info->rectangle_info.height);
break;
}
case CircleElement:
case EllipseElement:
{
(void) XDrawArc(display,draw_pixmap,draw_context,
(int) draw_info->rectangle_info.x,(int) draw_info->rectangle_info.y,
(unsigned int) draw_info->rectangle_info.width,
(unsigned int) draw_info->rectangle_info.height,0,360*64);
break;
}
case FillCircleElement:
case FillEllipseElement:
{
(void) XFillArc(display,draw_pixmap,draw_context,
(int) draw_info->rectangle_info.x,(int) draw_info->rectangle_info.y,
(unsigned int) draw_info->rectangle_info.width,
(unsigned int) draw_info->rectangle_info.height,0,360*64);
break;
}
case PolygonElement:
{
XPoint
*coordinate_info;
coordinate_info=draw_info->coordinate_info;
(void) XDrawLines(display,draw_pixmap,draw_context,coordinate_info,
(int) draw_info->number_coordinates,CoordModeOrigin);
(void) XDrawLine(display,draw_pixmap,draw_context,
coordinate_info[draw_info->number_coordinates-1].x,
coordinate_info[draw_info->number_coordinates-1].y,
coordinate_info[0].x,coordinate_info[0].y);
break;
}
case FillPolygonElement:
{
(void) XFillPolygon(display,draw_pixmap,draw_context,
draw_info->coordinate_info,(int) draw_info->number_coordinates,Complex,
CoordModeOrigin);
break;
}
}
(void) XFreeGC(display,draw_context);
/*
Initialize X image.
*/
draw_ximage=XGetImage(display,draw_pixmap,0,0,draw_info->width,
draw_info->height,AllPlanes,ZPixmap);
if (draw_ximage == (XImage *) NULL)
return(MagickFalse);
(void) XFreePixmap(display,draw_pixmap);
/*
Initialize draw image.
*/
draw_image=AcquireImage((ImageInfo *) NULL,exception);
if (draw_image == (Image *) NULL)
return(MagickFalse);
draw_image->columns=draw_info->width;
draw_image->rows=draw_info->height;
/*
Transfer drawn X image to image.
*/
width=(unsigned int) image->columns;
height=(unsigned int) image->rows;
x=0;
y=0;
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
(void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,(ssize_t) x,
(ssize_t) y,&draw_image->background_color,exception);
if (SetImageStorageClass(draw_image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
draw_image->alpha_trait=BlendPixelTrait;
draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
x;
register Quantum
*magick_restrict q;
q=QueueCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,
1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) draw_image->columns; x++)
{
if (XGetPixel(draw_ximage,x,y) == 0)
{
/*
Set this pixel to the background color.
*/
SetPixelViaPixelInfo(draw_image,&draw_image->background_color,q);
SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
OpaqueStencil ? TransparentAlpha : OpaqueAlpha),q);
}
else
{
/*
Set this pixel to the pen color.
*/
SetPixelRed(draw_image,ScaleShortToQuantum(
pixel->pen_color.red),q);
SetPixelGreen(draw_image,ScaleShortToQuantum(
pixel->pen_color.green),q);
SetPixelBlue(draw_image,ScaleShortToQuantum(
pixel->pen_color.blue),q);
SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
OpaqueStencil ? OpaqueAlpha : TransparentAlpha),q);
}
q+=GetPixelChannels(draw_image);
}
if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
}
draw_view=DestroyCacheView(draw_view);
XDestroyImage(draw_ximage);
/*
Determine draw geometry.
*/
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
if ((width != (unsigned int) draw_image->columns) ||
(height != (unsigned int) draw_image->rows))
{
char
image_geometry[MagickPathExtent];
/*
Scale image.
*/
(void) FormatLocaleString(image_geometry,MagickPathExtent,"%ux%u",
width,height);
(void) TransformImage(&draw_image,(char *) NULL,image_geometry,
exception);
}
if (draw_info->degrees != 0.0)
{
Image
*rotate_image;
int
rotations;
double
normalized_degrees;
/*
Rotate image.
*/
rotate_image=RotateImage(draw_image,draw_info->degrees,exception);
if (rotate_image == (Image *) NULL)
return(MagickFalse);
draw_image=DestroyImage(draw_image);
draw_image=rotate_image;
/*
Annotation is relative to the degree of rotation.
*/
normalized_degrees=draw_info->degrees;
while (normalized_degrees < -45.0)
normalized_degrees+=360.0;
for (rotations=0; normalized_degrees > 45.0; rotations++)
normalized_degrees-=90.0;
switch (rotations % 4)
{
default:
case 0:
break;
case 1:
{
/*
Rotate 90 degrees.
*/
x=x-(int) draw_image->columns/2;
y=y+(int) draw_image->columns/2;
break;
}
case 2:
{
/*
Rotate 180 degrees.
*/
x=x-(int) draw_image->columns;
break;
}
case 3:
{
/*
Rotate 270 degrees.
*/
x=x-(int) draw_image->columns/2;
y=y-(int) (draw_image->rows-(draw_image->columns/2));
break;
}
}
}
/*
Composite text onto the image.
*/
draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
x;
register Quantum
*magick_restrict q;
q=GetCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,1,
exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) draw_image->columns; x++)
{
if (GetPixelAlpha(image,q) != TransparentAlpha)
SetPixelAlpha(draw_image,OpaqueAlpha,q);
q+=GetPixelChannels(draw_image);
}
if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
}
draw_view=DestroyCacheView(draw_view);
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
if (draw_info->stencil == TransparentStencil)
(void) CompositeImage(image,draw_image,CopyAlphaCompositeOp,MagickTrue,
(ssize_t) x,(ssize_t) y,exception);
else
{
alpha_trait=image->alpha_trait;
(void) CompositeImage(image,draw_image,OverCompositeOp,MagickTrue,
(ssize_t) x,(ssize_t) y,exception);
image->alpha_trait=alpha_trait;
}
draw_image=DestroyImage(draw_image);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X E r r o r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XError() ignores BadWindow errors for XQueryTree and XGetWindowAttributes,
% and ignores BadDrawable errors for XGetGeometry, and ignores BadValue errors
% for XQueryColor. It returns MagickFalse in those cases. Otherwise it
% returns True.
%
% The format of the XError function is:
%
% int XError(display,error)
%
% A description of each parameter follows:
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o error: Specifies the error event.
%
*/
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
MagickExport int XError(Display *display,XErrorEvent *error)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(error != (XErrorEvent *) NULL);
xerror_alert=MagickTrue;
switch (error->request_code)
{
case X_GetGeometry:
{
if ((int) error->error_code == BadDrawable)
return(MagickFalse);
break;
}
case X_GetWindowAttributes:
case X_QueryTree:
{
if ((int) error->error_code == BadWindow)
return(MagickFalse);
break;
}
case X_QueryColors:
{
if ((int) error->error_code == BadValue)
return(MagickFalse);
break;
}
}
return(MagickTrue);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X F r e e R e s o u r c e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XFreeResources() frees X11 resources.
%
% The format of the XFreeResources method is:
%
% void XFreeResources(Display *display,XVisualInfo *visual_info,
% XStandardColormap *map_info,XPixelInfo *pixel,XFontStruct *font_info,
% XResourceInfo *resource_info,XWindowInfo *window_info)
% resource_info,window_info)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o map_info: If map_type is specified, this structure is initialized
% with info from the Standard Colormap.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
% o font_info: Specifies a pointer to a XFontStruct structure.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o window_info: Specifies a pointer to a X11 XWindowInfo structure.
%
*/
MagickPrivate void XFreeResources(Display *display,XVisualInfo *visual_info,
XStandardColormap *map_info,XPixelInfo *pixel,XFontStruct *font_info,
XResourceInfo *resource_info,XWindowInfo *window_info)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
if (window_info != (XWindowInfo *) NULL)
{
/*
Free X image.
*/
if (window_info->ximage != (XImage *) NULL)
XDestroyImage(window_info->ximage);
if (window_info->id != (Window) NULL)
{
/*
Free destroy window and free cursors.
*/
if (window_info->id != XRootWindow(display,visual_info->screen))
(void) XDestroyWindow(display,window_info->id);
if (window_info->annotate_context != (GC) NULL)
(void) XFreeGC(display,window_info->annotate_context);
if (window_info->highlight_context != (GC) NULL)
(void) XFreeGC(display,window_info->highlight_context);
if (window_info->widget_context != (GC) NULL)
(void) XFreeGC(display,window_info->widget_context);
if (window_info->cursor != (Cursor) NULL)
(void) XFreeCursor(display,window_info->cursor);
window_info->cursor=(Cursor) NULL;
if (window_info->busy_cursor != (Cursor) NULL)
(void) XFreeCursor(display,window_info->busy_cursor);
window_info->busy_cursor=(Cursor) NULL;
}
}
/*
Free font.
*/
if (font_info != (XFontStruct *) NULL)
{
(void) XFreeFont(display,font_info);
font_info=(XFontStruct *) NULL;
}
if (map_info != (XStandardColormap *) NULL)
{
/*
Free X Standard Colormap.
*/
if (resource_info->map_type == (char *) NULL)
(void) XFreeStandardColormap(display,visual_info,map_info,pixel);
(void) XFree((void *) map_info);
}
/*
Free X visual info.
*/
if (visual_info != (XVisualInfo *) NULL)
(void) XFree((void *) visual_info);
if (resource_info->close_server != MagickFalse)
(void) XCloseDisplay(display);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X F r e e S t a n d a r d C o l o r m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XFreeStandardColormap() frees an X11 colormap.
%
% The format of the XFreeStandardColormap method is:
%
% void XFreeStandardColormap(Display *display,
% const XVisualInfo *visual_info,XStandardColormap *map_info,
% XPixelInfo *pixel)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o map_info: If map_type is specified, this structure is initialized
% with info from the Standard Colormap.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
*/
MagickPrivate void XFreeStandardColormap(Display *display,
const XVisualInfo *visual_info,XStandardColormap *map_info,XPixelInfo *pixel)
{
/*
Free colormap.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(visual_info != (XVisualInfo *) NULL);
assert(map_info != (XStandardColormap *) NULL);
(void) XFlush(display);
if (map_info->colormap != (Colormap) NULL)
{
if (map_info->colormap != XDefaultColormap(display,visual_info->screen))
(void) XFreeColormap(display,map_info->colormap);
else
if (pixel != (XPixelInfo *) NULL)
if ((visual_info->klass != TrueColor) &&
(visual_info->klass != DirectColor))
(void) XFreeColors(display,map_info->colormap,pixel->pixels,
(int) pixel->colors,0);
}
map_info->colormap=(Colormap) NULL;
if (pixel != (XPixelInfo *) NULL)
{
if (pixel->pixels != (unsigned long *) NULL)
pixel->pixels=(unsigned long *) RelinquishMagickMemory(pixel->pixels);
pixel->pixels=(unsigned long *) NULL;
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t A n n o t a t e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetAnnotateInfo() initializes the AnnotateInfo structure.
%
% The format of the XGetAnnotateInfo method is:
%
% void XGetAnnotateInfo(XAnnotateInfo *annotate_info)
%
% A description of each parameter follows:
%
% o annotate_info: Specifies a pointer to a XAnnotateInfo structure.
%
*/
MagickPrivate void XGetAnnotateInfo(XAnnotateInfo *annotate_info)
{
/*
Initialize annotate structure.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(annotate_info != (XAnnotateInfo *) NULL);
annotate_info->x=0;
annotate_info->y=0;
annotate_info->width=0;
annotate_info->height=0;
annotate_info->stencil=ForegroundStencil;
annotate_info->degrees=0.0;
annotate_info->font_info=(XFontStruct *) NULL;
annotate_info->text=(char *) NULL;
*annotate_info->geometry='\0';
annotate_info->previous=(XAnnotateInfo *) NULL;
annotate_info->next=(XAnnotateInfo *) NULL;
(void) XSupportsLocale();
(void) XSetLocaleModifiers("");
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t M a p I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetMapInfo() initializes the XStandardColormap structure.
%
% The format of the XStandardColormap method is:
%
% void XGetMapInfo(const XVisualInfo *visual_info,const Colormap colormap,
% XStandardColormap *map_info)
%
% A description of each parameter follows:
%
% o colormap: Specifies the ID of the X server colormap.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o map_info: Specifies a pointer to a X11 XStandardColormap structure.
%
*/
MagickPrivate void XGetMapInfo(const XVisualInfo *visual_info,
const Colormap colormap,XStandardColormap *map_info)
{
/*
Initialize map info.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(visual_info != (XVisualInfo *) NULL);
assert(map_info != (XStandardColormap *) NULL);
map_info->colormap=colormap;
map_info->red_max=visual_info->red_mask;
map_info->red_mult=(size_t) (map_info->red_max != 0 ? 1 : 0);
if (map_info->red_max != 0)
while ((map_info->red_max & 0x01) == 0)
{
map_info->red_max>>=1;
map_info->red_mult<<=1;
}
map_info->green_max=visual_info->green_mask;
map_info->green_mult=(size_t) (map_info->green_max != 0 ? 1 : 0);
if (map_info->green_max != 0)
while ((map_info->green_max & 0x01) == 0)
{
map_info->green_max>>=1;
map_info->green_mult<<=1;
}
map_info->blue_max=visual_info->blue_mask;
map_info->blue_mult=(size_t) (map_info->blue_max != 0 ? 1 : 0);
if (map_info->blue_max != 0)
while ((map_info->blue_max & 0x01) == 0)
{
map_info->blue_max>>=1;
map_info->blue_mult<<=1;
}
map_info->base_pixel=0;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t P i x e l I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetPixelInfo() initializes the PixelInfo structure.
%
% The format of the XGetPixelInfo method is:
%
% void XGetPixelInfo(Display *display,const XVisualInfo *visual_info,
% const XStandardColormap *map_info,const XResourceInfo *resource_info,
% Image *image,XPixelInfo *pixel)
% pixel)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o map_info: If map_type is specified, this structure is initialized
% with info from the Standard Colormap.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o image: the image.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
*/
MagickPrivate void XGetPixelInfo(Display *display,
const XVisualInfo *visual_info,const XStandardColormap *map_info,
const XResourceInfo *resource_info,Image *image,XPixelInfo *pixel)
{
static const char
*PenColors[MaxNumberPens]=
{
"#000000000000", /* black */
"#00000000ffff", /* blue */
"#0000ffffffff", /* cyan */
"#0000ffff0000", /* green */
"#bdbdbdbdbdbd", /* gray */
"#ffff00000000", /* red */
"#ffff0000ffff", /* magenta */
"#ffffffff0000", /* yellow */
"#ffffffffffff", /* white */
"#bdbdbdbdbdbd", /* gray */
"#bdbdbdbdbdbd" /* gray */
};
Colormap
colormap;
extern const char
BorderColor[],
ForegroundColor[];
register ssize_t
i;
Status
status;
unsigned int
packets;
/*
Initialize pixel info.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(visual_info != (XVisualInfo *) NULL);
assert(map_info != (XStandardColormap *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(pixel != (XPixelInfo *) NULL);
pixel->colors=0;
if (image != (Image *) NULL)
if (image->storage_class == PseudoClass)
pixel->colors=(ssize_t) image->colors;
packets=(unsigned int)
MagickMax((int) pixel->colors,visual_info->colormap_size)+MaxNumberPens;
if (pixel->pixels != (unsigned long *) NULL)
pixel->pixels=(unsigned long *) RelinquishMagickMemory(pixel->pixels);
pixel->pixels=(unsigned long *) AcquireQuantumMemory(packets,
sizeof(*pixel->pixels));
if (pixel->pixels == (unsigned long *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,"UnableToGetPixelInfo",
image->filename);
/*
Set foreground color.
*/
colormap=map_info->colormap;
(void) XParseColor(display,colormap,(char *) ForegroundColor,
&pixel->foreground_color);
status=XParseColor(display,colormap,resource_info->foreground_color,
&pixel->foreground_color);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->foreground_color);
pixel->foreground_color.pixel=
XStandardPixel(map_info,&pixel->foreground_color);
pixel->foreground_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set background color.
*/
(void) XParseColor(display,colormap,"#d6d6d6d6d6d6",&pixel->background_color);
status=XParseColor(display,colormap,resource_info->background_color,
&pixel->background_color);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->background_color);
pixel->background_color.pixel=
XStandardPixel(map_info,&pixel->background_color);
pixel->background_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set border color.
*/
(void) XParseColor(display,colormap,(char *) BorderColor,
&pixel->border_color);
status=XParseColor(display,colormap,resource_info->border_color,
&pixel->border_color);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->border_color);
pixel->border_color.pixel=XStandardPixel(map_info,&pixel->border_color);
pixel->border_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set matte color.
*/
pixel->matte_color=pixel->background_color;
if (resource_info->matte_color != (char *) NULL)
{
/*
Matte color is specified as a X resource or command line argument.
*/
status=XParseColor(display,colormap,resource_info->matte_color,
&pixel->matte_color);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->matte_color);
pixel->matte_color.pixel=XStandardPixel(map_info,&pixel->matte_color);
pixel->matte_color.flags=(char) (DoRed | DoGreen | DoBlue);
}
/*
Set highlight color.
*/
pixel->highlight_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(HighlightModulate))/65535L+
(ScaleQuantumToShort((Quantum) (QuantumRange-HighlightModulate))));
pixel->highlight_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(HighlightModulate))/65535L+
(ScaleQuantumToShort((Quantum) (QuantumRange-HighlightModulate))));
pixel->highlight_color.blue=(unsigned short) (((double)
pixel->matte_color.blue*ScaleQuantumToShort(HighlightModulate))/65535L+
(ScaleQuantumToShort((Quantum) (QuantumRange-HighlightModulate))));
pixel->highlight_color.pixel=XStandardPixel(map_info,&pixel->highlight_color);
pixel->highlight_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set shadow color.
*/
pixel->shadow_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(ShadowModulate))/65535L);
pixel->shadow_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(ShadowModulate))/65535L);
pixel->shadow_color.blue=(unsigned short) (((double)
pixel->matte_color.blue*ScaleQuantumToShort(ShadowModulate))/65535L);
pixel->shadow_color.pixel=XStandardPixel(map_info,&pixel->shadow_color);
pixel->shadow_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set depth color.
*/
pixel->depth_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(DepthModulate))/65535L);
pixel->depth_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(DepthModulate))/65535L);
pixel->depth_color.blue=(unsigned short) (((double)
pixel->matte_color.blue*ScaleQuantumToShort(DepthModulate))/65535L);
pixel->depth_color.pixel=XStandardPixel(map_info,&pixel->depth_color);
pixel->depth_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set trough color.
*/
pixel->trough_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(TroughModulate))/65535L);
pixel->trough_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(TroughModulate))/65535L);
pixel->trough_color.blue=(unsigned short) (((double)
pixel->matte_color.blue*ScaleQuantumToShort(TroughModulate))/65535L);
pixel->trough_color.pixel=XStandardPixel(map_info,&pixel->trough_color);
pixel->trough_color.flags=(char) (DoRed | DoGreen | DoBlue);
/*
Set pen color.
*/
for (i=0; i < MaxNumberPens; i++)
{
(void) XParseColor(display,colormap,(char *) PenColors[i],
&pixel->pen_colors[i]);
status=XParseColor(display,colormap,resource_info->pen_colors[i],
&pixel->pen_colors[i]);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->pen_colors[i]);
pixel->pen_colors[i].pixel=XStandardPixel(map_info,&pixel->pen_colors[i]);
pixel->pen_colors[i].flags=(char) (DoRed | DoGreen | DoBlue);
}
pixel->box_color=pixel->background_color;
pixel->pen_color=pixel->foreground_color;
pixel->box_index=0;
pixel->pen_index=1;
if (image != (Image *) NULL)
{
if ((resource_info->gamma_correct != MagickFalse) &&
(image->gamma != 0.0))
{
GeometryInfo
geometry_info;
MagickStatusType
flags;
/*
Initialize map relative to display and image gamma.
*/
flags=ParseGeometry(resource_info->display_gamma,&geometry_info);
red_gamma=geometry_info.rho;
green_gamma=geometry_info.sigma;
if ((flags & SigmaValue) == 0)
green_gamma=red_gamma;
blue_gamma=geometry_info.xi;
if ((flags & XiValue) == 0)
blue_gamma=red_gamma;
red_gamma*=image->gamma;
green_gamma*=image->gamma;
blue_gamma*=image->gamma;
}
if (image->storage_class == PseudoClass)
{
/*
Initialize pixel array for images of type PseudoClass.
*/
for (i=0; i < (ssize_t) image->colors; i++)
pixel->pixels[i]=XGammaPacket(map_info,image->colormap+i);
for (i=0; i < MaxNumberPens; i++)
pixel->pixels[image->colors+i]=pixel->pen_colors[i].pixel;
pixel->colors+=MaxNumberPens;
}
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t R e s o u r c e C l a s s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetResourceClass() queries the X server for the specified resource name or
% class. If the resource name or class is not defined in the database, the
% supplied default value is returned.
%
% The format of the XGetResourceClass method is:
%
% char *XGetResourceClass(XrmDatabase database,const char *client_name,
% const char *keyword,char *resource_default)
%
% A description of each parameter follows:
%
% o database: Specifies a resource database; returned from
% XrmGetStringDatabase.
%
% o client_name: Specifies the application name used to retrieve resource
% info from the X server database.
%
% o keyword: Specifies the keyword of the value being retrieved.
%
% o resource_default: Specifies the default value to return if the query
% fails to find the specified keyword/class.
%
*/
MagickExport char *XGetResourceClass(XrmDatabase database,
const char *client_name,const char *keyword,char *resource_default)
{
char
resource_class[MagickPathExtent],
resource_name[MagickPathExtent];
static char
*resource_type;
Status
status;
XrmValue
resource_value;
if (database == (XrmDatabase) NULL)
return(resource_default);
*resource_name='\0';
*resource_class='\0';
if (keyword != (char *) NULL)
{
int
c,
k;
/*
Initialize resource keyword and class.
*/
(void) FormatLocaleString(resource_name,MagickPathExtent,"%s.%s",
client_name,keyword);
c=(int) (*client_name);
if ((c >= XK_a) && (c <= XK_z))
c-=(XK_a-XK_A);
else
if ((c >= XK_agrave) && (c <= XK_odiaeresis))
c-=(XK_agrave-XK_Agrave);
else
if ((c >= XK_oslash) && (c <= XK_thorn))
c-=(XK_oslash-XK_Ooblique);
k=(int) (*keyword);
if ((k >= XK_a) && (k <= XK_z))
k-=(XK_a-XK_A);
else
if ((k >= XK_agrave) && (k <= XK_odiaeresis))
k-=(XK_agrave-XK_Agrave);
else
if ((k >= XK_oslash) && (k <= XK_thorn))
k-=(XK_oslash-XK_Ooblique);
(void) FormatLocaleString(resource_class,MagickPathExtent,"%c%s.%c%s",c,
client_name+1,k,keyword+1);
}
status=XrmGetResource(database,resource_name,resource_class,&resource_type,
&resource_value);
if (status == False)
return(resource_default);
return(resource_value.addr);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t R e s o u r c e D a t a b a s e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetResourceDatabase() creates a new resource database and initializes it.
%
% The format of the XGetResourceDatabase method is:
%
% XrmDatabase XGetResourceDatabase(Display *display,
% const char *client_name)
%
% A description of each parameter follows:
%
% o database: XGetResourceDatabase() returns the database after it is
% initialized.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o client_name: Specifies the application name used to retrieve resource
% info from the X server database.
%
*/
MagickExport XrmDatabase XGetResourceDatabase(Display *display,
const char *client_name)
{
char
filename[MagickPathExtent];
int
c;
register const char
*p;
XrmDatabase
resource_database,
server_database;
if (display == (Display *) NULL)
return((XrmDatabase) NULL);
assert(client_name != (char *) NULL);
/*
Initialize resource database.
*/
XrmInitialize();
(void) XGetDefault(display,(char *) client_name,"dummy");
resource_database=XrmGetDatabase(display);
/*
Combine application database.
*/
if (client_name != (char *) NULL)
{
/*
Get basename of client.
*/
p=client_name+(strlen(client_name)-1);
while ((p > client_name) && (*p != '/'))
p--;
if (*p == '/')
client_name=p+1;
}
c=(int) (*client_name);
if ((c >= XK_a) && (c <= XK_z))
c-=(XK_a-XK_A);
else
if ((c >= XK_agrave) && (c <= XK_odiaeresis))
c-=(XK_agrave-XK_Agrave);
else
if ((c >= XK_oslash) && (c <= XK_thorn))
c-=(XK_oslash-XK_Ooblique);
#if defined(X11_APPLICATION_PATH)
(void) FormatLocaleString(filename,MagickPathExtent,"%s%c%s",
X11_APPLICATION_PATH,c,client_name+1);
(void) XrmCombineFileDatabase(filename,&resource_database,MagickFalse);
#endif
if (XResourceManagerString(display) != (char *) NULL)
{
/*
Combine server database.
*/
server_database=XrmGetStringDatabase(XResourceManagerString(display));
XrmCombineDatabase(server_database,&resource_database,MagickFalse);
}
/*
Merge user preferences database.
*/
#if defined(X11_PREFERENCES_PATH)
(void) FormatLocaleString(filename,MagickPathExtent,"%s%src",
X11_PREFERENCES_PATH,client_name);
ExpandFilename(filename);
(void) XrmCombineFileDatabase(filename,&resource_database,MagickFalse);
#endif
return(resource_database);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t R e s o u r c e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetResourceInfo(image_info,) initializes the ResourceInfo structure.
%
% The format of the XGetResourceInfo method is:
%
% void XGetResourceInfo(const ImageInfo *image_info,XrmDatabase database,
% const char *client_name,XResourceInfo *resource_info)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o database: Specifies a resource database; returned from
% XrmGetStringDatabase.
%
% o client_name: Specifies the application name used to retrieve
% resource info from the X server database.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickExport void XGetResourceInfo(const ImageInfo *image_info,
XrmDatabase database,const char *client_name,XResourceInfo *resource_info)
{
char
*directory,
*resource_value;
extern const char
BorderColor[],
ForegroundColor[];
/*
Initialize resource info fields.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(resource_info != (XResourceInfo *) NULL);
(void) ResetMagickMemory(resource_info,0,sizeof(*resource_info));
resource_info->resource_database=database;
resource_info->image_info=(ImageInfo *) image_info;
(void) SetImageInfoProgressMonitor(resource_info->image_info,
XMagickProgressMonitor,(void *) NULL);
resource_info->quantize_info=CloneQuantizeInfo((QuantizeInfo *) NULL);
resource_info->close_server=MagickTrue;
resource_info->client_name=AcquireString(client_name);
resource_value=XGetResourceClass(database,client_name,"backdrop",
(char *) "False");
resource_info->backdrop=IsStringTrue(resource_value);
resource_info->background_color=XGetResourceInstance(database,client_name,
"background",(char *) "#d6d6d6d6d6d6");
resource_info->border_color=XGetResourceInstance(database,client_name,
"borderColor",BorderColor);
resource_value=XGetResourceClass(database,client_name,"borderWidth",
(char *) "2");
resource_info->border_width=(unsigned int) StringToUnsignedLong(
resource_value);
resource_value=XGetResourceClass(database,client_name,"colormap",
(char *) "shared");
resource_info->colormap=UndefinedColormap;
if (LocaleCompare("private",resource_value) == 0)
resource_info->colormap=PrivateColormap;
if (LocaleCompare("shared",resource_value) == 0)
resource_info->colormap=SharedColormap;
if (resource_info->colormap == UndefinedColormap)
ThrowXWindowException(OptionError,"UnrecognizedColormapType",
resource_value);
resource_value=XGetResourceClass(database,client_name,
"colorRecovery",(char *) "False");
resource_info->color_recovery=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"confirmExit",
(char *) "False");
resource_info->confirm_exit=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"confirmEdit",
(char *) "False");
resource_info->confirm_edit=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"delay",(char *) "1");
resource_info->delay=(unsigned int) StringToUnsignedLong(resource_value);
resource_info->display_gamma=XGetResourceClass(database,client_name,
"displayGamma",(char *) "2.2");
resource_value=XGetResourceClass(database,client_name,"displayWarnings",
(char *) "True");
resource_info->display_warnings=IsStringTrue(resource_value);
resource_info->font=XGetResourceClass(database,client_name,"font",
(char *) NULL);
resource_info->font=XGetResourceClass(database,client_name,"fontList",
resource_info->font);
resource_info->font_name[0]=XGetResourceClass(database,client_name,"font1",
(char *) "fixed");
resource_info->font_name[1]=XGetResourceClass(database,client_name,"font2",
(char *) "variable");
resource_info->font_name[2]=XGetResourceClass(database,client_name,"font3",
(char *) "5x8");
resource_info->font_name[3]=XGetResourceClass(database,client_name,"font4",
(char *) "6x10");
resource_info->font_name[4]=XGetResourceClass(database,client_name,"font5",
(char *) "7x13bold");
resource_info->font_name[5]=XGetResourceClass(database,client_name,"font6",
(char *) "8x13bold");
resource_info->font_name[6]=XGetResourceClass(database,client_name,"font7",
(char *) "9x15bold");
resource_info->font_name[7]=XGetResourceClass(database,client_name,"font8",
(char *) "10x20");
resource_info->font_name[8]=XGetResourceClass(database,client_name,"font9",
(char *) "12x24");
resource_info->font_name[9]=XGetResourceClass(database,client_name,"font0",
(char *) "fixed");
resource_info->font_name[10]=XGetResourceClass(database,client_name,"font0",
(char *) "fixed");
resource_info->foreground_color=XGetResourceInstance(database,client_name,
"foreground",ForegroundColor);
resource_value=XGetResourceClass(database,client_name,"gammaCorrect",
(char *) "False");
resource_info->gamma_correct=IsStringTrue(resource_value);
resource_info->image_geometry=ConstantString(XGetResourceClass(database,
client_name,"geometry",(char *) NULL));
resource_value=XGetResourceClass(database,client_name,"gravity",
(char *) "Center");
resource_info->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
MagickFalse,resource_value);
directory=getcwd(resource_info->home_directory,MagickPathExtent);
(void) directory;
resource_info->icon_geometry=XGetResourceClass(database,client_name,
"iconGeometry",(char *) NULL);
resource_value=XGetResourceClass(database,client_name,"iconic",
(char *) "False");
resource_info->iconic=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"immutable",
LocaleCompare(client_name,"PerlMagick") == 0 ? (char *) "True" :
(char *) "False");
resource_info->immutable=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"magnify",
(char *) "3");
resource_info->magnify=(unsigned int) StringToUnsignedLong(resource_value);
resource_info->map_type=XGetResourceClass(database,client_name,"map",
(char *) NULL);
resource_info->matte_color=XGetResourceInstance(database,client_name,
"mattecolor",(char *) NULL);
resource_info->name=ConstantString(XGetResourceClass(database,client_name,
"name",(char *) NULL));
resource_info->pen_colors[0]=XGetResourceClass(database,client_name,"pen1",
(char *) "black");
resource_info->pen_colors[1]=XGetResourceClass(database,client_name,"pen2",
(char *) "blue");
resource_info->pen_colors[2]=XGetResourceClass(database,client_name,"pen3",
(char *) "cyan");
resource_info->pen_colors[3]=XGetResourceClass(database,client_name,"pen4",
(char *) "green");
resource_info->pen_colors[4]=XGetResourceClass(database,client_name,"pen5",
(char *) "gray");
resource_info->pen_colors[5]=XGetResourceClass(database,client_name,"pen6",
(char *) "red");
resource_info->pen_colors[6]=XGetResourceClass(database,client_name,"pen7",
(char *) "magenta");
resource_info->pen_colors[7]=XGetResourceClass(database,client_name,"pen8",
(char *) "yellow");
resource_info->pen_colors[8]=XGetResourceClass(database,client_name,"pen9",
(char *) "white");
resource_info->pen_colors[9]=XGetResourceClass(database,client_name,"pen0",
(char *) "gray");
resource_info->pen_colors[10]=XGetResourceClass(database,client_name,"pen0",
(char *) "gray");
resource_value=XGetResourceClass(database,client_name,"pause",(char *) "0");
resource_info->pause=(unsigned int) StringToUnsignedLong(resource_value);
resource_value=XGetResourceClass(database,client_name,"quantum",(char *) "1");
resource_info->quantum=StringToLong(resource_value);
resource_info->text_font=XGetResourceClass(database,client_name,(char *)
"font",(char *) "fixed");
resource_info->text_font=XGetResourceClass(database,client_name,
"textFontList",resource_info->text_font);
resource_info->title=XGetResourceClass(database,client_name,"title",
(char *) NULL);
resource_value=XGetResourceClass(database,client_name,"undoCache",
(char *) "256");
resource_info->undo_cache=(unsigned int) StringToUnsignedLong(resource_value);
resource_value=XGetResourceClass(database,client_name,"update",
(char *) "False");
resource_info->update=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"usePixmap",
(char *) "True");
resource_info->use_pixmap=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"sharedMemory",
(char *) "True");
resource_info->use_shared_memory=IsStringTrue(resource_value);
resource_info->visual_type=XGetResourceClass(database,client_name,"visual",
(char *) NULL);
resource_info->window_group=XGetResourceClass(database,client_name,
"windowGroup",(char *) NULL);
resource_info->window_id=XGetResourceClass(database,client_name,"window",
(char *) NULL);
resource_info->write_filename=XGetResourceClass(database,client_name,
"writeFilename",(char *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t R e s o u r c e I n s t a n c e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetResourceInstance() queries the X server for the specified resource name.
% If the resource name is not defined in the database, the supplied default
% value is returned.
%
% The format of the XGetResourceInstance method is:
%
% char *XGetResourceInstance(XrmDatabase database,const char *client_name,
% const char *keyword,const char *resource_default)
%
% A description of each parameter follows:
%
% o database: Specifies a resource database; returned from
% XrmGetStringDatabase.
%
% o client_name: Specifies the application name used to retrieve
% resource info from the X server database.
%
% o keyword: Specifies the keyword of the value being retrieved.
%
% o resource_default: Specifies the default value to return if the query
% fails to find the specified keyword/class.
%
*/
MagickExport char *XGetResourceInstance(XrmDatabase database,
const char *client_name,const char *keyword,const char *resource_default)
{
char
*resource_type,
resource_name[MagickPathExtent];
Status
status;
XrmValue
resource_value;
if (database == (XrmDatabase) NULL)
return((char *) resource_default);
*resource_name='\0';
if (keyword != (char *) NULL)
(void) FormatLocaleString(resource_name,MagickPathExtent,"%s.%s",client_name,
keyword);
status=XrmGetResource(database,resource_name,"ImageMagick",&resource_type,
&resource_value);
if (status == False)
return((char *) resource_default);
return(resource_value.addr);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t S c r e e n D e n s i t y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetScreenDensity() returns the density of the X server screen in
% dots-per-inch.
%
% The format of the XGetScreenDensity method is:
%
% char *XGetScreenDensity(Display *display)
%
% A description of each parameter follows:
%
% o density: XGetScreenDensity() returns the density of the X screen in
% dots-per-inch.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
*/
MagickExport char *XGetScreenDensity(Display *display)
{
char
density[MagickPathExtent];
double
x_density,
y_density;
/*
Set density as determined by screen size.
*/
x_density=((((double) DisplayWidth(display,XDefaultScreen(display)))*25.4)/
((double) DisplayWidthMM(display,XDefaultScreen(display))));
y_density=((((double) DisplayHeight(display,XDefaultScreen(display)))*25.4)/
((double) DisplayHeightMM(display,XDefaultScreen(display))));
(void) FormatLocaleString(density,MagickPathExtent,"%gx%g",x_density,
y_density);
return(GetPageGeometry(density));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X G e t S u b w i n d o w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetSubwindow() returns the subwindow of a window chosen the user with the
% pointer and a button press.
%
% The format of the XGetSubwindow method is:
%
% Window XGetSubwindow(Display *display,Window window,int x,int y)
%
% A description of each parameter follows:
%
% o subwindow: XGetSubwindow() returns NULL if no subwindow is found
% otherwise the subwindow is returned.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window.
%
% o x: the x coordinate of the pointer relative to the origin of the
% window.
%
% o y: the y coordinate of the pointer relative to the origin of the
% window.
%
*/
static Window XGetSubwindow(Display *display,Window window,int x,int y)
{
int
x_offset,
y_offset;
Status
status;
Window
source_window,
target_window;
assert(display != (Display *) NULL);
source_window=XRootWindow(display,XDefaultScreen(display));
if (window == (Window) NULL)
return(source_window);
target_window=window;
for ( ; ; )
{
status=XTranslateCoordinates(display,source_window,window,x,y,
&x_offset,&y_offset,&target_window);
if (status != True)
break;
if (target_window == (Window) NULL)
break;
source_window=window;
window=target_window;
x=x_offset;
y=y_offset;
}
if (target_window == (Window) NULL)
target_window=window;
return(target_window);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t W i n d o w C o l o r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetWindowColor() returns the color of a pixel interactively chosen from the
% X server.
%
% The format of the XGetWindowColor method is:
%
% MagickBooleanType XGetWindowColor(Display *display,XWindows *windows,
% char *name,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o windows: Specifies a pointer to a XWindows structure.
%
% o name: the name of the color if found in the X Color Database is
% returned in this character string.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XGetWindowColor(Display *display,
XWindows *windows,char *name,ExceptionInfo *exception)
{
int
x,
y;
PixelInfo
pixel;
RectangleInfo
crop_info;
Status
status;
Window
child,
client_window,
root_window,
target_window;
XColor
color;
XImage
*ximage;
XWindowAttributes
window_attributes;
/*
Choose a pixel from the X server.
*/
assert(display != (Display *) NULL);
assert(name != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
*name='\0';
target_window=XSelectWindow(display,&crop_info);
if (target_window == (Window) NULL)
return(MagickFalse);
root_window=XRootWindow(display,XDefaultScreen(display));
client_window=target_window;
if (target_window != root_window)
{
unsigned int
d;
/*
Get client window.
*/
status=XGetGeometry(display,target_window,&root_window,&x,&x,&d,&d,&d,&d);
if (status != False)
{
client_window=XClientWindow(display,target_window);
target_window=client_window;
}
}
/*
Verify window is viewable.
*/
status=XGetWindowAttributes(display,target_window,&window_attributes);
if ((status == False) || (window_attributes.map_state != IsViewable))
return(MagickFalse);
/*
Get window X image.
*/
(void) XTranslateCoordinates(display,root_window,target_window,
(int) crop_info.x,(int) crop_info.y,&x,&y,&child);
ximage=XGetImage(display,target_window,x,y,1,1,AllPlanes,ZPixmap);
if (ximage == (XImage *) NULL)
return(MagickFalse);
color.pixel=XGetPixel(ximage,0,0);
XDestroyImage(ximage);
/*
Match color against the color database.
*/
(void) XQueryColor(display,window_attributes.colormap,&color);
pixel.red=(double) ScaleShortToQuantum(color.red);
pixel.green=(double) ScaleShortToQuantum(color.green);
pixel.blue=(double) ScaleShortToQuantum(color.blue);
pixel.alpha=OpaqueAlpha;
(void) QueryColorname(windows->image.image,&pixel,X11Compliance,name,
exception);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X G e t W i n d o w I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetWindowImage() reads an image from the target X window and returns it.
% XGetWindowImage() optionally descends the window hierarchy and overlays the
% target image with each child image in an optimized fashion. Any child
% window that have the same visual, colormap, and are contained by its parent
% are exempted.
%
% The format of the XGetWindowImage method is:
%
% Image *XGetWindowImage(Display *display,const Window window,
% const unsigned int borders,const unsigned int level,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies the window to obtain the image from.
%
% o borders: Specifies whether borders pixels are to be saved with
% the image.
%
% o level: Specifies an unsigned integer representing the level of
% decent in the window hierarchy. This value must be zero or one on
% the initial call to XGetWindowImage. A value of zero returns after
% one call. A value of one causes the function to descend the window
% hierarchy and overlay the target image with each subwindow image.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *XGetWindowImage(Display *display,const Window window,
const unsigned int borders,const unsigned int level,ExceptionInfo *exception)
{
typedef struct _ColormapInfo
{
Colormap
colormap;
XColor
*colors;
struct _ColormapInfo
*next;
} ColormapInfo;
typedef struct _WindowInfo
{
Window
window,
parent;
Visual
*visual;
Colormap
colormap;
XSegment
bounds;
RectangleInfo
crop_info;
} WindowInfo;
int
display_height,
display_width,
id,
x_offset,
y_offset;
Quantum
index;
RectangleInfo
crop_info;
register int
i;
static ColormapInfo
*colormap_info = (ColormapInfo *) NULL;
static int
max_windows = 0,
number_windows = 0;
static WindowInfo
*window_info;
Status
status;
Window
child,
root_window;
XWindowAttributes
window_attributes;
/*
Verify window is viewable.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
status=XGetWindowAttributes(display,window,&window_attributes);
if ((status == False) || (window_attributes.map_state != IsViewable))
return((Image *) NULL);
/*
Cropping rectangle is relative to root window.
*/
root_window=XRootWindow(display,XDefaultScreen(display));
(void) XTranslateCoordinates(display,window,root_window,0,0,&x_offset,
&y_offset,&child);
crop_info.x=(ssize_t) x_offset;
crop_info.y=(ssize_t) y_offset;
crop_info.width=(size_t) window_attributes.width;
crop_info.height=(size_t) window_attributes.height;
if (borders != MagickFalse)
{
/*
Include border in image.
*/
crop_info.x-=(ssize_t) window_attributes.border_width;
crop_info.y-=(ssize_t) window_attributes.border_width;
crop_info.width+=(size_t) (window_attributes.border_width << 1);
crop_info.height+=(size_t) (window_attributes.border_width << 1);
}
/*
Crop to root window.
*/
if (crop_info.x < 0)
{
crop_info.width+=crop_info.x;
crop_info.x=0;
}
if (crop_info.y < 0)
{
crop_info.height+=crop_info.y;
crop_info.y=0;
}
display_width=XDisplayWidth(display,XDefaultScreen(display));
if ((int) (crop_info.x+crop_info.width) > display_width)
crop_info.width=(size_t) (display_width-crop_info.x);
display_height=XDisplayHeight(display,XDefaultScreen(display));
if ((int) (crop_info.y+crop_info.height) > display_height)
crop_info.height=(size_t) (display_height-crop_info.y);
/*
Initialize window info attributes.
*/
if (number_windows >= max_windows)
{
/*
Allocate or resize window info buffer.
*/
max_windows+=1024;
if (window_info == (WindowInfo *) NULL)
window_info=(WindowInfo *) AcquireQuantumMemory((size_t) max_windows,
sizeof(*window_info));
else
window_info=(WindowInfo *) ResizeQuantumMemory(window_info,(size_t)
max_windows,sizeof(*window_info));
}
if (window_info == (WindowInfo *) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed","...");
return((Image *) NULL);
}
id=number_windows++;
window_info[id].window=window;
window_info[id].visual=window_attributes.visual;
window_info[id].colormap=window_attributes.colormap;
window_info[id].bounds.x1=(short) crop_info.x;
window_info[id].bounds.y1=(short) crop_info.y;
window_info[id].bounds.x2=(short) (crop_info.x+(int) crop_info.width-1);
window_info[id].bounds.y2=(short) (crop_info.y+(int) crop_info.height-1);
crop_info.x-=x_offset;
crop_info.y-=y_offset;
window_info[id].crop_info=crop_info;
if (level != 0)
{
unsigned int
number_children;
Window
*children;
/*
Descend the window hierarchy.
*/
status=XQueryTree(display,window,&root_window,&window_info[id].parent,
&children,&number_children);
for (i=0; i < id; i++)
if ((window_info[i].window == window_info[id].parent) &&
(window_info[i].visual == window_info[id].visual) &&
(window_info[i].colormap == window_info[id].colormap))
{
if ((window_info[id].bounds.x1 < window_info[i].bounds.x1) ||
(window_info[id].bounds.x2 > window_info[i].bounds.x2) ||
(window_info[id].bounds.y1 < window_info[i].bounds.y1) ||
(window_info[id].bounds.y2 > window_info[i].bounds.y2))
{
/*
Eliminate windows not circumscribed by their parent.
*/
number_windows--;
break;
}
}
if ((status == True) && (number_children != 0))
{
for (i=0; i < (int) number_children; i++)
(void) XGetWindowImage(display,children[i],MagickFalse,level+1,
exception);
(void) XFree((void *) children);
}
}
if (level <= 1)
{
CacheView
*composite_view;
ColormapInfo
*next;
Image
*composite_image,
*image;
int
y;
MagickBooleanType
import;
register int
j,
x;
register Quantum
*magick_restrict q;
register size_t
pixel;
unsigned int
number_colors;
XColor
*colors;
XImage
*ximage;
/*
Get X image for each window in the list.
*/
image=NewImageList();
for (id=0; id < number_windows; id++)
{
/*
Does target window intersect top level window?
*/
import=((window_info[id].bounds.x2 >= window_info[0].bounds.x1) &&
(window_info[id].bounds.x1 <= window_info[0].bounds.x2) &&
(window_info[id].bounds.y2 >= window_info[0].bounds.y1) &&
(window_info[id].bounds.y1 <= window_info[0].bounds.y2)) ?
MagickTrue : MagickFalse;
/*
Is target window contained by another window with the same colormap?
*/
for (j=0; j < id; j++)
if ((window_info[id].visual == window_info[j].visual) &&
(window_info[id].colormap == window_info[j].colormap))
{
if ((window_info[id].bounds.x1 >= window_info[j].bounds.x1) &&
(window_info[id].bounds.x2 <= window_info[j].bounds.x2) &&
(window_info[id].bounds.y1 >= window_info[j].bounds.y1) &&
(window_info[id].bounds.y2 <= window_info[j].bounds.y2))
import=MagickFalse;
}
if (import == MagickFalse)
continue;
/*
Get X image.
*/
ximage=XGetImage(display,window_info[id].window,(int)
window_info[id].crop_info.x,(int) window_info[id].crop_info.y,
(unsigned int) window_info[id].crop_info.width,(unsigned int)
window_info[id].crop_info.height,AllPlanes,ZPixmap);
if (ximage == (XImage *) NULL)
continue;
/*
Initialize window colormap.
*/
number_colors=0;
colors=(XColor *) NULL;
if (window_info[id].colormap != (Colormap) NULL)
{
ColormapInfo
*p;
/*
Search colormap list for window colormap.
*/
number_colors=(unsigned int) window_info[id].visual->map_entries;
for (p=colormap_info; p != (ColormapInfo *) NULL; p=p->next)
if (p->colormap == window_info[id].colormap)
break;
if (p == (ColormapInfo *) NULL)
{
/*
Get the window colormap.
*/
colors=(XColor *) AcquireQuantumMemory(number_colors,
sizeof(*colors));
if (colors == (XColor *) NULL)
{
XDestroyImage(ximage);
return((Image *) NULL);
}
if ((window_info[id].visual->klass != DirectColor) &&
(window_info[id].visual->klass != TrueColor))
for (i=0; i < (int) number_colors; i++)
{
colors[i].pixel=(size_t) i;
colors[i].pad='\0';
}
else
{
size_t
blue,
blue_bit,
green,
green_bit,
red,
red_bit;
/*
DirectColor or TrueColor visual.
*/
red=0;
green=0;
blue=0;
red_bit=window_info[id].visual->red_mask &
(~(window_info[id].visual->red_mask)+1);
green_bit=window_info[id].visual->green_mask &
(~(window_info[id].visual->green_mask)+1);
blue_bit=window_info[id].visual->blue_mask &
(~(window_info[id].visual->blue_mask)+1);
for (i=0; i < (int) number_colors; i++)
{
colors[i].pixel=(unsigned long) (red | green | blue);
colors[i].pad='\0';
red+=red_bit;
if (red > window_info[id].visual->red_mask)
red=0;
green+=green_bit;
if (green > window_info[id].visual->green_mask)
green=0;
blue+=blue_bit;
if (blue > window_info[id].visual->blue_mask)
blue=0;
}
}
(void) XQueryColors(display,window_info[id].colormap,colors,
(int) number_colors);
/*
Append colormap to colormap list.
*/
p=(ColormapInfo *) AcquireMagickMemory(sizeof(*p));
if (p == (ColormapInfo *) NULL)
return((Image *) NULL);
p->colormap=window_info[id].colormap;
p->colors=colors;
p->next=colormap_info;
colormap_info=p;
}
colors=p->colors;
}
/*
Allocate image structure.
*/
composite_image=AcquireImage((ImageInfo *) NULL,exception);
if (composite_image == (Image *) NULL)
{
XDestroyImage(ximage);
return((Image *) NULL);
}
/*
Convert X image to MIFF format.
*/
if ((window_info[id].visual->klass != TrueColor) &&
(window_info[id].visual->klass != DirectColor))
composite_image->storage_class=PseudoClass;
composite_image->columns=(size_t) ximage->width;
composite_image->rows=(size_t) ximage->height;
composite_view=AcquireAuthenticCacheView(composite_image,exception);
switch (composite_image->storage_class)
{
case DirectClass:
default:
{
register size_t
color,
index;
size_t
blue_mask,
blue_shift,
green_mask,
green_shift,
red_mask,
red_shift;
/*
Determine shift and mask for red, green, and blue.
*/
red_mask=window_info[id].visual->red_mask;
red_shift=0;
while ((red_mask != 0) && ((red_mask & 0x01) == 0))
{
red_mask>>=1;
red_shift++;
}
green_mask=window_info[id].visual->green_mask;
green_shift=0;
while ((green_mask != 0) && ((green_mask & 0x01) == 0))
{
green_mask>>=1;
green_shift++;
}
blue_mask=window_info[id].visual->blue_mask;
blue_shift=0;
while ((blue_mask != 0) && ((blue_mask & 0x01) == 0))
{
blue_mask>>=1;
blue_shift++;
}
/*
Convert X image to DirectClass packets.
*/
if ((number_colors != 0) &&
(window_info[id].visual->klass == DirectColor))
for (y=0; y < (int) composite_image->rows; y++)
{
q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
composite_image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) composite_image->columns; x++)
{
pixel=XGetPixel(ximage,x,y);
index=(pixel >> red_shift) & red_mask;
SetPixelRed(composite_image,
ScaleShortToQuantum(colors[index].red),q);
index=(pixel >> green_shift) & green_mask;
SetPixelGreen(composite_image,
ScaleShortToQuantum(colors[index].green),q);
index=(pixel >> blue_shift) & blue_mask;
SetPixelBlue(composite_image,
ScaleShortToQuantum(colors[index].blue),q);
q+=GetPixelChannels(composite_image);
}
status=SyncCacheViewAuthenticPixels(composite_view,exception);
if (status == MagickFalse)
break;
}
else
for (y=0; y < (int) composite_image->rows; y++)
{
q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
composite_image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) composite_image->columns; x++)
{
pixel=XGetPixel(ximage,x,y);
color=(pixel >> red_shift) & red_mask;
if (red_mask != 0)
color=(65535UL*color)/red_mask;
SetPixelRed(composite_image,ScaleShortToQuantum(
(unsigned short) color),q);
color=(pixel >> green_shift) & green_mask;
if (green_mask != 0)
color=(65535UL*color)/green_mask;
SetPixelGreen(composite_image,ScaleShortToQuantum(
(unsigned short) color),q);
color=(pixel >> blue_shift) & blue_mask;
if (blue_mask != 0)
color=(65535UL*color)/blue_mask;
SetPixelBlue(composite_image,ScaleShortToQuantum(
(unsigned short) color),q);
q+=GetPixelChannels(composite_image);
}
status=SyncCacheViewAuthenticPixels(composite_view,exception);
if (status == MagickFalse)
break;
}
break;
}
case PseudoClass:
{
/*
Create colormap.
*/
status=AcquireImageColormap(composite_image,number_colors,
exception);
if (status == MagickFalse)
{
XDestroyImage(ximage);
composite_image=DestroyImage(composite_image);
return((Image *) NULL);
}
for (i=0; i < (int) composite_image->colors; i++)
{
composite_image->colormap[colors[i].pixel].red=(double)
ScaleShortToQuantum(colors[i].red);
composite_image->colormap[colors[i].pixel].green=(double)
ScaleShortToQuantum(colors[i].green);
composite_image->colormap[colors[i].pixel].blue=(double)
ScaleShortToQuantum(colors[i].blue);
}
/*
Convert X image to PseudoClass packets.
*/
for (y=0; y < (int) composite_image->rows; y++)
{
q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
composite_image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (int) composite_image->columns; x++)
{
index=(Quantum) XGetPixel(ximage,x,y);
SetPixelIndex(composite_image,index,q);
SetPixelViaPixelInfo(composite_image,
composite_image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(composite_image);
}
status=SyncCacheViewAuthenticPixels(composite_view,exception);
if (status == MagickFalse)
break;
}
break;
}
}
composite_view=DestroyCacheView(composite_view);
XDestroyImage(ximage);
if (image == (Image *) NULL)
{
image=composite_image;
continue;
}
/*
Composite any children in back-to-front order.
*/
(void) XTranslateCoordinates(display,window_info[id].window,window,0,0,
&x_offset,&y_offset,&child);
x_offset-=(int) crop_info.x;
if (x_offset < 0)
x_offset=0;
y_offset-=(int) crop_info.y;
if (y_offset < 0)
y_offset=0;
(void) CompositeImage(image,composite_image,CopyCompositeOp,MagickTrue,
(ssize_t) x_offset,(ssize_t) y_offset,exception);
composite_image=DestroyImage(composite_image);
}
/*
Relinquish resources.
*/
while (colormap_info != (ColormapInfo *) NULL)
{
next=colormap_info->next;
colormap_info->colors=(XColor *) RelinquishMagickMemory(
colormap_info->colors);
colormap_info=(ColormapInfo *) RelinquishMagickMemory(colormap_info);
colormap_info=next;
}
/*
Relinquish resources and restore initial state.
*/
window_info=(WindowInfo *) RelinquishMagickMemory(window_info);
max_windows=0;
number_windows=0;
colormap_info=(ColormapInfo *) NULL;
return(image);
}
return((Image *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t W i n d o w I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetWindowInfo() initializes the XWindowInfo structure.
%
% The format of the XGetWindowInfo method is:
%
% void XGetWindowInfo(Display *display,XVisualInfo *visual_info,
% XStandardColormap *map_info,XPixelInfo *pixel,XFontStruct *font_info,
% XResourceInfo *resource_info,XWindowInfo *window)
% resource_info,window)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o map_info: If map_type is specified, this structure is initialized
% with info from the Standard Colormap.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
% o font_info: Specifies a pointer to a XFontStruct structure.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickPrivate void XGetWindowInfo(Display *display,XVisualInfo *visual_info,
XStandardColormap *map_info,XPixelInfo *pixel,XFontStruct *font_info,
XResourceInfo *resource_info,XWindowInfo *window)
{
/*
Initialize window info.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(visual_info != (XVisualInfo *) NULL);
assert(map_info != (XStandardColormap *) NULL);
assert(pixel != (XPixelInfo *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(window != (XWindowInfo *) NULL);
if (window->id != (Window) NULL)
{
if (window->cursor != (Cursor) NULL)
(void) XFreeCursor(display,window->cursor);
if (window->busy_cursor != (Cursor) NULL)
(void) XFreeCursor(display,window->busy_cursor);
if (window->highlight_stipple != (Pixmap) NULL)
(void) XFreePixmap(display,window->highlight_stipple);
if (window->shadow_stipple != (Pixmap) NULL)
(void) XFreePixmap(display,window->shadow_stipple);
if (window->name == (char *) NULL)
window->name=AcquireString("");
if (window->icon_name == (char *) NULL)
window->icon_name=AcquireString("");
}
else
{
/*
Initialize these attributes just once.
*/
window->id=(Window) NULL;
if (window->name == (char *) NULL)
window->name=AcquireString("");
if (window->icon_name == (char *) NULL)
window->icon_name=AcquireString("");
window->x=XDisplayWidth(display,visual_info->screen) >> 1;
window->y=XDisplayWidth(display,visual_info->screen) >> 1;
window->ximage=(XImage *) NULL;
window->matte_image=(XImage *) NULL;
window->pixmap=(Pixmap) NULL;
window->matte_pixmap=(Pixmap) NULL;
window->mapped=MagickFalse;
window->stasis=MagickFalse;
window->shared_memory=MagickTrue;
window->segment_info=(void *) NULL;
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
{
XShmSegmentInfo
*segment_info;
if (window->segment_info == (void *) NULL)
window->segment_info=AcquireQuantumMemory(2,sizeof(*segment_info));
segment_info=(XShmSegmentInfo *) window->segment_info;
segment_info[0].shmid=(-1);
segment_info[0].shmaddr=(char *) NULL;
segment_info[1].shmid=(-1);
segment_info[1].shmaddr=(char *) NULL;
}
#endif
}
/*
Initialize these attributes every time function is called.
*/
window->screen=visual_info->screen;
window->root=XRootWindow(display,visual_info->screen);
window->visual=visual_info->visual;
window->storage_class=(unsigned int) visual_info->klass;
window->depth=(unsigned int) visual_info->depth;
window->visual_info=visual_info;
window->map_info=map_info;
window->pixel_info=pixel;
window->font_info=font_info;
window->cursor=XCreateFontCursor(display,XC_left_ptr);
window->busy_cursor=XCreateFontCursor(display,XC_watch);
window->geometry=(char *) NULL;
window->icon_geometry=(char *) NULL;
if (resource_info->icon_geometry != (char *) NULL)
(void) CloneString(&window->icon_geometry,resource_info->icon_geometry);
window->crop_geometry=(char *) NULL;
window->flags=(size_t) PSize;
window->width=1;
window->height=1;
window->min_width=1;
window->min_height=1;
window->width_inc=1;
window->height_inc=1;
window->border_width=resource_info->border_width;
window->annotate_context=pixel->annotate_context;
window->highlight_context=pixel->highlight_context;
window->widget_context=pixel->widget_context;
window->shadow_stipple=(Pixmap) NULL;
window->highlight_stipple=(Pixmap) NULL;
window->use_pixmap=MagickTrue;
window->immutable=MagickFalse;
window->shape=MagickFalse;
window->data=0;
window->mask=(int) (CWBackingStore | CWBackPixel | CWBackPixmap |
CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWDontPropagate |
CWEventMask | CWOverrideRedirect | CWSaveUnder | CWWinGravity);
window->attributes.background_pixel=pixel->background_color.pixel;
window->attributes.background_pixmap=(Pixmap) NULL;
window->attributes.bit_gravity=ForgetGravity;
window->attributes.backing_store=WhenMapped;
window->attributes.save_under=MagickTrue;
window->attributes.border_pixel=pixel->border_color.pixel;
window->attributes.colormap=map_info->colormap;
window->attributes.cursor=window->cursor;
window->attributes.do_not_propagate_mask=NoEventMask;
window->attributes.event_mask=NoEventMask;
window->attributes.override_redirect=MagickFalse;
window->attributes.win_gravity=NorthWestGravity;
window->orphan=MagickFalse;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X H i g h l i g h t E l l i p s e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XHighlightEllipse() puts a border on the X server around a region defined by
% highlight_info.
%
% The format of the XHighlightEllipse method is:
%
% void XHighlightEllipse(Display *display,Window window,
% GC annotate_context,const RectangleInfo *highlight_info)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window structure.
%
% o annotate_context: Specifies a pointer to a GC structure.
%
% o highlight_info: Specifies a pointer to a RectangleInfo structure. It
% contains the extents of any highlighting rectangle.
%
*/
MagickPrivate void XHighlightEllipse(Display *display,Window window,
GC annotate_context,const RectangleInfo *highlight_info)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
assert(annotate_context != (GC) NULL);
assert(highlight_info != (RectangleInfo *) NULL);
if ((highlight_info->width < 4) || (highlight_info->height < 4))
return;
(void) XDrawArc(display,window,annotate_context,(int) highlight_info->x,
(int) highlight_info->y,(unsigned int) highlight_info->width-1,
(unsigned int) highlight_info->height-1,0,360*64);
(void) XDrawArc(display,window,annotate_context,(int) highlight_info->x+1,
(int) highlight_info->y+1,(unsigned int) highlight_info->width-3,
(unsigned int) highlight_info->height-3,0,360*64);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X H i g h l i g h t L i n e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XHighlightLine() puts a border on the X server around a region defined by
% highlight_info.
%
% The format of the XHighlightLine method is:
%
% void XHighlightLine(Display *display,Window window,GC annotate_context,
% const XSegment *highlight_info)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window structure.
%
% o annotate_context: Specifies a pointer to a GC structure.
%
% o highlight_info: Specifies a pointer to a RectangleInfo structure. It
% contains the extents of any highlighting rectangle.
%
*/
MagickPrivate void XHighlightLine(Display *display,Window window,
GC annotate_context,const XSegment *highlight_info)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
assert(annotate_context != (GC) NULL);
assert(highlight_info != (XSegment *) NULL);
(void) XDrawLine(display,window,annotate_context,highlight_info->x1,
highlight_info->y1,highlight_info->x2,highlight_info->y2);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X H i g h l i g h t R e c t a n g l e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XHighlightRectangle() puts a border on the X server around a region defined
% by highlight_info.
%
% The format of the XHighlightRectangle method is:
%
% void XHighlightRectangle(Display *display,Window window,
% GC annotate_context,const RectangleInfo *highlight_info)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window structure.
%
% o annotate_context: Specifies a pointer to a GC structure.
%
% o highlight_info: Specifies a pointer to a RectangleInfo structure. It
% contains the extents of any highlighting rectangle.
%
*/
MagickPrivate void XHighlightRectangle(Display *display,Window window,
GC annotate_context,const RectangleInfo *highlight_info)
{
assert(display != (Display *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(window != (Window) NULL);
assert(annotate_context != (GC) NULL);
assert(highlight_info != (RectangleInfo *) NULL);
if ((highlight_info->width < 4) || (highlight_info->height < 4))
return;
(void) XDrawRectangle(display,window,annotate_context,(int) highlight_info->x,
(int) highlight_info->y,(unsigned int) highlight_info->width-1,
(unsigned int) highlight_info->height-1);
(void) XDrawRectangle(display,window,annotate_context,(int) highlight_info->x+
1,(int) highlight_info->y+1,(unsigned int) highlight_info->width-3,
(unsigned int) highlight_info->height-3);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X I m p o r t I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XImportImage() reads an image from an X window.
%
% The format of the XImportImage method is:
%
% Image *XImportImage(const ImageInfo *image_info,XImportInfo *ximage_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o ximage_info: Specifies a pointer to an XImportInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *XImportImage(const ImageInfo *image_info,
XImportInfo *ximage_info,ExceptionInfo *exception)
{
Colormap
*colormaps;
Display
*display;
Image
*image;
int
number_colormaps,
number_windows,
x;
RectangleInfo
crop_info;
Status
status;
Window
*children,
client,
prior_target,
root,
target;
XTextProperty
window_name;
/*
Open X server connection.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(ximage_info != (XImportInfo *) NULL);
display=XOpenDisplay(image_info->server_name);
if (display == (Display *) NULL)
{
ThrowXWindowException(XServerError,"UnableToOpenXServer",
XDisplayName(image_info->server_name));
return((Image *) NULL);
}
/*
Set our forgiving exception handler.
*/
(void) XSetErrorHandler(XError);
/*
Select target window.
*/
crop_info.x=0;
crop_info.y=0;
crop_info.width=0;
crop_info.height=0;
root=XRootWindow(display,XDefaultScreen(display));
target=(Window) NULL;
if (*image_info->filename != '\0')
{
if (LocaleCompare(image_info->filename,"root") == 0)
target=root;
else
{
/*
Select window by ID or name.
*/
if (isdigit((int) ((unsigned char) *image_info->filename)) != 0)
target=XWindowByID(display,root,(Window)
strtol(image_info->filename,(char **) NULL,0));
if (target == (Window) NULL)
target=XWindowByName(display,root,image_info->filename);
if (target == (Window) NULL)
ThrowXWindowException(XServerError,"NoWindowWithSpecifiedIDExists",
image_info->filename);
}
}
/*
If target window is not defined, interactively select one.
*/
prior_target=target;
if (target == (Window) NULL)
target=XSelectWindow(display,&crop_info);
if (target == (Window) NULL)
ThrowXWindowException(XServerError,"UnableToReadXWindowImage",
image_info->filename);
client=target; /* obsolete */
if (target != root)
{
unsigned int
d;
status=XGetGeometry(display,target,&root,&x,&x,&d,&d,&d,&d);
if (status != False)
{
for ( ; ; )
{
Window
parent;
/*
Find window manager frame.
*/
status=XQueryTree(display,target,&root,&parent,&children,&d);
if ((status != False) && (children != (Window *) NULL))
(void) XFree((char *) children);
if ((status == False) || (parent == (Window) NULL) ||
(parent == root))
break;
target=parent;
}
/*
Get client window.
*/
client=XClientWindow(display,target);
if (ximage_info->frame == MagickFalse)
target=client;
if ((ximage_info->frame == MagickFalse) &&
(prior_target != MagickFalse))
target=prior_target;
}
}
if (ximage_info->screen)
{
int
y;
Window
child;
XWindowAttributes
window_attributes;
/*
Obtain window image directly from screen.
*/
status=XGetWindowAttributes(display,target,&window_attributes);
if (status == False)
{
ThrowXWindowException(XServerError,"UnableToReadXWindowAttributes",
image_info->filename);
(void) XCloseDisplay(display);
return((Image *) NULL);
}
(void) XTranslateCoordinates(display,target,root,0,0,&x,&y,&child);
crop_info.x=(ssize_t) x;
crop_info.y=(ssize_t) y;
crop_info.width=(size_t) window_attributes.width;
crop_info.height=(size_t) window_attributes.height;
if (ximage_info->borders != 0)
{
/*
Include border in image.
*/
crop_info.x-=window_attributes.border_width;
crop_info.y-=window_attributes.border_width;
crop_info.width+=window_attributes.border_width << 1;
crop_info.height+=window_attributes.border_width << 1;
}
target=root;
}
/*
If WM_COLORMAP_WINDOWS property is set or multiple colormaps, descend.
*/
number_windows=0;
status=XGetWMColormapWindows(display,target,&children,&number_windows);
if ((status == True) && (number_windows > 0))
{
ximage_info->descend=MagickTrue;
(void) XFree ((char *) children);
}
colormaps=XListInstalledColormaps(display,target,&number_colormaps);
if (number_colormaps > 0)
{
if (number_colormaps > 1)
ximage_info->descend=MagickTrue;
(void) XFree((char *) colormaps);
}
/*
Alert the user not to alter the screen.
*/
if (ximage_info->silent == MagickFalse)
(void) XBell(display,0);
/*
Get image by window id.
*/
(void) XGrabServer(display);
image=XGetWindowImage(display,target,ximage_info->borders,
ximage_info->descend ? 1U : 0U,exception);
(void) XUngrabServer(display);
if (image == (Image *) NULL)
ThrowXWindowException(XServerError,"UnableToReadXWindowImage",
image_info->filename)
else
{
(void) CopyMagickString(image->filename,image_info->filename,
MagickPathExtent);
if ((crop_info.width != 0) && (crop_info.height != 0))
{
Image
*clone_image,
*crop_image;
/*
Crop image as defined by the cropping rectangle.
*/
clone_image=CloneImage(image,0,0,MagickTrue,exception);
if (clone_image != (Image *) NULL)
{
crop_image=CropImage(clone_image,&crop_info,exception);
if (crop_image != (Image *) NULL)
{
image=DestroyImage(image);
image=crop_image;
}
}
}
status=XGetWMName(display,target,&window_name);
if (status == True)
{
if (*image_info->filename == '\0')
(void) CopyMagickString(image->filename,(char *) window_name.value,
(size_t) window_name.nitems+1);
(void) XFree((void *) window_name.value);
}
}
if (ximage_info->silent == MagickFalse)
{
/*
Alert the user we're done.
*/
(void) XBell(display,0);
(void) XBell(display,0);
}
(void) XCloseDisplay(display);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X I n i t i a l i z e W i n d o w s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XInitializeWindows() initializes the XWindows structure.
%
% The format of the XInitializeWindows method is:
%
% XWindows *XInitializeWindows(Display *display,
% XResourceInfo *resource_info)
%
% A description of each parameter follows:
%
% o windows: XInitializeWindows returns a pointer to a XWindows structure.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickPrivate XWindows *XInitializeWindows(Display *display,
XResourceInfo *resource_info)
{
Window
root_window;
XWindows
*windows;
/*
Allocate windows structure.
*/
windows=(XWindows *) AcquireMagickMemory(sizeof(*windows));
if (windows == (XWindows *) NULL)
{
ThrowXWindowFatalException(XServerFatalError,"MemoryAllocationFailed",
"...");
return((XWindows *) NULL);
}
(void) ResetMagickMemory(windows,0,sizeof(*windows));
windows->pixel_info=(XPixelInfo *) AcquireMagickMemory(
sizeof(*windows->pixel_info));
windows->icon_pixel=(XPixelInfo *) AcquireMagickMemory(
sizeof(*windows->icon_pixel));
windows->icon_resources=(XResourceInfo *) AcquireMagickMemory(
sizeof(*windows->icon_resources));
if ((windows->pixel_info == (XPixelInfo *) NULL) ||
(windows->icon_pixel == (XPixelInfo *) NULL) ||
(windows->icon_resources == (XResourceInfo *) NULL))
{
ThrowXWindowFatalException(XServerFatalError,"MemoryAllocationFailed",
"...");
return((XWindows *) NULL);
}
/*
Initialize windows structure.
*/
windows->display=display;
windows->wm_protocols=XInternAtom(display,"WM_PROTOCOLS",MagickFalse);
windows->wm_delete_window=XInternAtom(display,"WM_DELETE_WINDOW",MagickFalse);
windows->wm_take_focus=XInternAtom(display,"WM_TAKE_FOCUS",MagickFalse);
windows->im_protocols=XInternAtom(display,"IM_PROTOCOLS",MagickFalse);
windows->im_remote_command=
XInternAtom(display,"IM_REMOTE_COMMAND",MagickFalse);
windows->im_update_widget=XInternAtom(display,"IM_UPDATE_WIDGET",MagickFalse);
windows->im_update_colormap=
XInternAtom(display,"IM_UPDATE_COLORMAP",MagickFalse);
windows->im_former_image=XInternAtom(display,"IM_FORMER_IMAGE",MagickFalse);
windows->im_next_image=XInternAtom(display,"IM_NEXT_IMAGE",MagickFalse);
windows->im_retain_colors=XInternAtom(display,"IM_RETAIN_COLORS",MagickFalse);
windows->im_exit=XInternAtom(display,"IM_EXIT",MagickFalse);
windows->dnd_protocols=XInternAtom(display,"DndProtocol",MagickFalse);
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
(void) XSynchronize(display,IsWindows95());
#endif
if (IsEventLogging())
{
(void) XSynchronize(display,MagickTrue);
(void) LogMagickEvent(X11Event,GetMagickModule(),"Version: %s",
GetMagickVersion((size_t *) NULL));
(void) LogMagickEvent(X11Event,GetMagickModule(),"Protocols:");
(void) LogMagickEvent(X11Event,GetMagickModule(),
" Window Manager: 0x%lx",windows->wm_protocols);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" delete window: 0x%lx",windows->wm_delete_window);
(void) LogMagickEvent(X11Event,GetMagickModule()," take focus: 0x%lx",
windows->wm_take_focus);
(void) LogMagickEvent(X11Event,GetMagickModule()," ImageMagick: 0x%lx",
windows->im_protocols);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" remote command: 0x%lx",windows->im_remote_command);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" update widget: 0x%lx",windows->im_update_widget);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" update colormap: 0x%lx",windows->im_update_colormap);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" former image: 0x%lx",windows->im_former_image);
(void) LogMagickEvent(X11Event,GetMagickModule()," next image: 0x%lx",
windows->im_next_image);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" retain colors: 0x%lx",windows->im_retain_colors);
(void) LogMagickEvent(X11Event,GetMagickModule()," exit: 0x%lx",
windows->im_exit);
(void) LogMagickEvent(X11Event,GetMagickModule()," Drag and Drop: 0x%lx",
windows->dnd_protocols);
}
/*
Allocate standard colormap.
*/
windows->map_info=XAllocStandardColormap();
windows->icon_map=XAllocStandardColormap();
if ((windows->map_info == (XStandardColormap *) NULL) ||
(windows->icon_map == (XStandardColormap *) NULL))
ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
"...");
windows->map_info->colormap=(Colormap) NULL;
windows->icon_map->colormap=(Colormap) NULL;
windows->pixel_info->pixels=(unsigned long *) NULL;
windows->pixel_info->annotate_context=(GC) NULL;
windows->pixel_info->highlight_context=(GC) NULL;
windows->pixel_info->widget_context=(GC) NULL;
windows->font_info=(XFontStruct *) NULL;
windows->icon_pixel->annotate_context=(GC) NULL;
windows->icon_pixel->pixels=(unsigned long *) NULL;
/*
Allocate visual.
*/
*windows->icon_resources=(*resource_info);
windows->icon_resources->visual_type=(char *) "default";
windows->icon_resources->colormap=SharedColormap;
windows->visual_info=
XBestVisualInfo(display,windows->map_info,resource_info);
windows->icon_visual=
XBestVisualInfo(display,windows->icon_map,windows->icon_resources);
if ((windows->visual_info == (XVisualInfo *) NULL) ||
(windows->icon_visual == (XVisualInfo *) NULL))
ThrowXWindowFatalException(XServerFatalError,"UnableToGetVisual",
resource_info->visual_type);
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),"Visual:");
(void) LogMagickEvent(X11Event,GetMagickModule()," visual id: 0x%lx",
windows->visual_info->visualid);
(void) LogMagickEvent(X11Event,GetMagickModule()," class: %s",
XVisualClassName(windows->visual_info->klass));
(void) LogMagickEvent(X11Event,GetMagickModule()," depth: %d planes",
windows->visual_info->depth);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" size of colormap: %d entries",windows->visual_info->colormap_size);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue masks: 0x%lx 0x%lx 0x%lx",
windows->visual_info->red_mask,windows->visual_info->green_mask,
windows->visual_info->blue_mask);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" significant bits in color: %d bits",
windows->visual_info->bits_per_rgb);
}
/*
Allocate class and manager hints.
*/
windows->class_hints=XAllocClassHint();
windows->manager_hints=XAllocWMHints();
if ((windows->class_hints == (XClassHint *) NULL) ||
(windows->manager_hints == (XWMHints *) NULL))
ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
"...");
/*
Determine group leader if we have one.
*/
root_window=XRootWindow(display,windows->visual_info->screen);
windows->group_leader.id=(Window) NULL;
if (resource_info->window_group != (char *) NULL)
{
if (isdigit((int) ((unsigned char) *resource_info->window_group)) != 0)
windows->group_leader.id=XWindowByID(display,root_window,(Window)
strtol((char *) resource_info->window_group,(char **) NULL,0));
if (windows->group_leader.id == (Window) NULL)
windows->group_leader.id=
XWindowByName(display,root_window,resource_info->window_group);
}
return(windows);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e C u r s o r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeCursor() creates a crosshairs X11 cursor.
%
% The format of the XMakeCursor method is:
%
% Cursor XMakeCursor(Display *display,Window window,Colormap colormap,
% char *background_color,char *foreground_color)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies the ID of the window for which the cursor is
% assigned.
%
% o colormap: Specifies the ID of the colormap from which the background
% and foreground color will be retrieved.
%
% o background_color: Specifies the color to use for the cursor background.
%
% o foreground_color: Specifies the color to use for the cursor foreground.
%
*/
MagickPrivate Cursor XMakeCursor(Display *display,Window window,
Colormap colormap,char *background_color,char *foreground_color)
{
#define scope_height 17
#define scope_x_hot 8
#define scope_y_hot 8
#define scope_width 17
static const unsigned char
scope_bits[] =
{
0x80, 0x03, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02,
0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x7f,
0xfc, 0x01, 0x01, 0x00, 0x01, 0x7f, 0xfc, 0x01, 0x80, 0x02, 0x00,
0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02,
0x00, 0x80, 0x02, 0x00, 0x80, 0x03, 0x00
},
scope_mask_bits[] =
{
0xc0, 0x07, 0x00, 0xc0, 0x07, 0x00, 0xc0, 0x06, 0x00, 0xc0, 0x06,
0x00, 0xc0, 0x06, 0x00, 0xc0, 0x06, 0x00, 0xff, 0xfe, 0x01, 0x7f,
0xfc, 0x01, 0x03, 0x80, 0x01, 0x7f, 0xfc, 0x01, 0xff, 0xfe, 0x01,
0xc0, 0x06, 0x00, 0xc0, 0x06, 0x00, 0xc0, 0x06, 0x00, 0xc0, 0x06,
0x00, 0xc0, 0x07, 0x00, 0xc0, 0x07, 0x00
};
Cursor
cursor;
Pixmap
mask,
source;
XColor
background,
foreground;
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
assert(colormap != (Colormap) NULL);
assert(background_color != (char *) NULL);
assert(foreground_color != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",background_color);
source=XCreateBitmapFromData(display,window,(char *) scope_bits,scope_width,
scope_height);
mask=XCreateBitmapFromData(display,window,(char *) scope_mask_bits,
scope_width,scope_height);
if ((source == (Pixmap) NULL) || (mask == (Pixmap) NULL))
{
ThrowXWindowException(XServerError,"UnableToCreatePixmap","...");
return((Cursor) NULL);
}
(void) XParseColor(display,colormap,background_color,&background);
(void) XParseColor(display,colormap,foreground_color,&foreground);
cursor=XCreatePixmapCursor(display,source,mask,&foreground,&background,
scope_x_hot,scope_y_hot);
(void) XFreePixmap(display,source);
(void) XFreePixmap(display,mask);
return(cursor);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeImage() creates an X11 image. If the image size differs from the X11
% image size, the image is first resized.
%
% The format of the XMakeImage method is:
%
% MagickBooleanType XMakeImage(Display *display,
% const XResourceInfo *resource_info,XWindowInfo *window,Image *image,
% unsigned int width,unsigned int height,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 window: Specifies a pointer to a XWindowInfo structure.
%
% o image: the image.
%
% o width: Specifies the width in pixels of the rectangular area to
% display.
%
% o height: Specifies the height in pixels of the rectangular area to
% display.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XMakeImage(Display *display,
const XResourceInfo *resource_info,XWindowInfo *window,Image *image,
unsigned int width,unsigned int height,ExceptionInfo *exception)
{
#define CheckOverflowException(length,width,height) \
(((height) != 0) && ((length)/((size_t) height) != ((size_t) width)))
int
depth,
format;
size_t
length;
XImage
*matte_image,
*ximage;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(window != (XWindowInfo *) NULL);
assert(width != 0);
assert(height != 0);
if ((window->width == 0) || (window->height == 0))
return(MagickFalse);
/*
Apply user transforms to the image.
*/
(void) XCheckDefineCursor(display,window->id,window->busy_cursor);
(void) XFlush(display);
depth=(int) window->depth;
if (window->destroy)
window->image=DestroyImage(window->image);
window->image=image;
window->destroy=MagickFalse;
if (window->image != (Image *) NULL)
{
if (window->crop_geometry != (char *) NULL)
{
Image
*crop_image;
RectangleInfo
crop_info;
/*
Crop image.
*/
window->image->page.x=0;
window->image->page.y=0;
(void) ParsePageGeometry(window->image,window->crop_geometry,
&crop_info,exception);
crop_image=CropImage(window->image,&crop_info,exception);
if (crop_image != (Image *) NULL)
{
if (window->image != image)
window->image=DestroyImage(window->image);
window->image=crop_image;
window->destroy=MagickTrue;
}
}
if ((width != (unsigned int) window->image->columns) ||
(height != (unsigned int) window->image->rows))
{
Image
*resize_image;
/*
Resize image.
*/
resize_image=NewImageList();
if ((window->pixel_info->colors == 0) &&
(window->image->rows > (unsigned long) XDisplayHeight(display,window->screen)) &&
(window->image->columns > (unsigned long) XDisplayWidth(display,window->screen)))
resize_image=ResizeImage(window->image,width,height,
image->filter,exception);
else
{
if (window->image->storage_class == PseudoClass)
resize_image=SampleImage(window->image,width,height,
exception);
else
resize_image=ThumbnailImage(window->image,width,height,
exception);
}
if (resize_image != (Image *) NULL)
{
if (window->image != image)
window->image=DestroyImage(window->image);
window->image=resize_image;
window->destroy=MagickTrue;
}
}
width=(unsigned int) window->image->columns;
assert((size_t) width == window->image->columns);
height=(unsigned int) window->image->rows;
assert((size_t) height == window->image->rows);
}
/*
Create X image.
*/
ximage=(XImage *) NULL;
format=(depth == 1) ? XYBitmap : ZPixmap;
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->shared_memory != MagickFalse)
{
XShmSegmentInfo
*segment_info;
segment_info=(XShmSegmentInfo *) window->segment_info;
segment_info[1].shmid=(-1);
segment_info[1].shmaddr=(char *) NULL;
ximage=XShmCreateImage(display,window->visual,(unsigned int) depth,format,
(char *) NULL,&segment_info[1],width,height);
if (ximage == (XImage *) NULL)
window->shared_memory=MagickFalse;
else
{
length=(size_t) ximage->bytes_per_line*ximage->height;
if (CheckOverflowException(length,ximage->bytes_per_line,ximage->height))
window->shared_memory=MagickFalse;
}
if (window->shared_memory != MagickFalse)
segment_info[1].shmid=shmget(IPC_PRIVATE,length,IPC_CREAT | 0777);
if (window->shared_memory != MagickFalse)
segment_info[1].shmaddr=(char *) shmat(segment_info[1].shmid,0,0);
if (segment_info[1].shmid < 0)
window->shared_memory=MagickFalse;
if (window->shared_memory != MagickFalse)
(void) shmctl(segment_info[1].shmid,IPC_RMID,0);
else
{
if (ximage != (XImage *) NULL)
XDestroyImage(ximage);
ximage=(XImage *) NULL;
if (segment_info[1].shmaddr)
{
(void) shmdt(segment_info[1].shmaddr);
segment_info[1].shmaddr=(char *) NULL;
}
if (segment_info[1].shmid >= 0)
{
(void) shmctl(segment_info[1].shmid,IPC_RMID,0);
segment_info[1].shmid=(-1);
}
}
}
#endif
/*
Allocate X image pixel data.
*/
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->shared_memory)
{
Status
status;
XShmSegmentInfo
*segment_info;
(void) XSync(display,MagickFalse);
xerror_alert=MagickFalse;
segment_info=(XShmSegmentInfo *) window->segment_info;
ximage->data=segment_info[1].shmaddr;
segment_info[1].readOnly=MagickFalse;
status=XShmAttach(display,&segment_info[1]);
if (status != False)
(void) XSync(display,MagickFalse);
if ((status == False) || (xerror_alert != MagickFalse))
{
window->shared_memory=MagickFalse;
if (status != False)
XShmDetach(display,&segment_info[1]);
ximage->data=NULL;
XDestroyImage(ximage);
ximage=(XImage *) NULL;
if (segment_info[1].shmid >= 0)
{
if (segment_info[1].shmaddr != NULL)
(void) shmdt(segment_info[1].shmaddr);
(void) shmctl(segment_info[1].shmid,IPC_RMID,0);
segment_info[1].shmid=(-1);
segment_info[1].shmaddr=(char *) NULL;
}
}
}
#endif
if (window->shared_memory == MagickFalse)
ximage=XCreateImage(display,window->visual,(unsigned int) depth,format,0,
(char *) NULL,width,height,XBitmapPad(display),0);
if (ximage == (XImage *) NULL)
{
/*
Unable to create X image.
*/
(void) XCheckDefineCursor(display,window->id,window->cursor);
return(MagickFalse);
}
length=(size_t) ximage->bytes_per_line*ximage->height;
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),"XImage:");
(void) LogMagickEvent(X11Event,GetMagickModule()," width, height: %dx%d",
ximage->width,ximage->height);
(void) LogMagickEvent(X11Event,GetMagickModule()," format: %d",
ximage->format);
(void) LogMagickEvent(X11Event,GetMagickModule()," byte order: %d",
ximage->byte_order);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" bitmap unit, bit order, pad: %d %d %d",ximage->bitmap_unit,
ximage->bitmap_bit_order,ximage->bitmap_pad);
(void) LogMagickEvent(X11Event,GetMagickModule()," depth: %d",
ximage->depth);
(void) LogMagickEvent(X11Event,GetMagickModule()," bytes per line: %d",
ximage->bytes_per_line);
(void) LogMagickEvent(X11Event,GetMagickModule()," bits per pixel: %d",
ximage->bits_per_pixel);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue masks: 0x%lx 0x%lx 0x%lx",ximage->red_mask,
ximage->green_mask,ximage->blue_mask);
}
if (window->shared_memory == MagickFalse)
{
if (ximage->format != XYBitmap)
ximage->data=(char *) malloc((size_t) ximage->bytes_per_line*
ximage->height);
else
ximage->data=(char *) malloc((size_t) ximage->bytes_per_line*
ximage->depth*ximage->height);
}
if (ximage->data == (char *) NULL)
{
/*
Unable to allocate pixel data.
*/
XDestroyImage(ximage);
ximage=(XImage *) NULL;
(void) XCheckDefineCursor(display,window->id,window->cursor);
return(MagickFalse);
}
if (window->ximage != (XImage *) NULL)
{
/*
Destroy previous X image.
*/
length=(size_t) window->ximage->bytes_per_line*window->ximage->height;
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->segment_info != (XShmSegmentInfo *) NULL)
{
XShmSegmentInfo
*segment_info;
segment_info=(XShmSegmentInfo *) window->segment_info;
if (segment_info[0].shmid >= 0)
{
(void) XSync(display,MagickFalse);
(void) XShmDetach(display,&segment_info[0]);
(void) XSync(display,MagickFalse);
if (segment_info[0].shmaddr != (char *) NULL)
(void) shmdt(segment_info[0].shmaddr);
(void) shmctl(segment_info[0].shmid,IPC_RMID,0);
segment_info[0].shmid=(-1);
segment_info[0].shmaddr=(char *) NULL;
window->ximage->data=(char *) NULL;
}
}
#endif
if (window->ximage->data != (char *) NULL)
free(window->ximage->data);
window->ximage->data=(char *) NULL;
XDestroyImage(window->ximage);
window->ximage=(XImage *) NULL;
}
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->segment_info != (XShmSegmentInfo *) NULL)
{
XShmSegmentInfo
*segment_info;
segment_info=(XShmSegmentInfo *) window->segment_info;
segment_info[0]=segment_info[1];
}
#endif
window->ximage=ximage;
matte_image=(XImage *) NULL;
if ((window->shape != MagickFalse) && (window->image != (Image *) NULL))
if ((window->image->alpha_trait != UndefinedPixelTrait) &&
((int) width <= XDisplayWidth(display,window->screen)) &&
((int) height <= XDisplayHeight(display,window->screen)))
{
/*
Create matte image.
*/
matte_image=XCreateImage(display,window->visual,1,XYBitmap,0,
(char *) NULL,width,height,XBitmapPad(display),0);
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),"Matte Image:");
(void) LogMagickEvent(X11Event,GetMagickModule(),
" width, height: %dx%d",matte_image->width,matte_image->height);
}
if (matte_image != (XImage *) NULL)
{
/*
Allocate matte image pixel data.
*/
matte_image->data=(char *) malloc((size_t)
matte_image->bytes_per_line*matte_image->depth*
matte_image->height);
if (matte_image->data == (char *) NULL)
{
XDestroyImage(matte_image);
matte_image=(XImage *) NULL;
}
}
}
if (window->matte_image != (XImage *) NULL)
{
/*
Free matte image.
*/
if (window->matte_image->data != (char *) NULL)
free(window->matte_image->data);
window->matte_image->data=(char *) NULL;
XDestroyImage(window->matte_image);
window->matte_image=(XImage *) NULL;
}
window->matte_image=matte_image;
if (window->matte_pixmap != (Pixmap) NULL)
{
(void) XFreePixmap(display,window->matte_pixmap);
window->matte_pixmap=(Pixmap) NULL;
#if defined(MAGICKCORE_HAVE_SHAPE)
if (window->shape != MagickFalse)
XShapeCombineMask(display,window->id,ShapeBounding,0,0,None,ShapeSet);
#endif
}
window->stasis=MagickFalse;
/*
Convert pixels to X image data.
*/
if (window->image != (Image *) NULL)
{
if ((ximage->byte_order == LSBFirst) || ((ximage->format == XYBitmap) &&
(ximage->bitmap_bit_order == LSBFirst)))
XMakeImageLSBFirst(resource_info,window,window->image,ximage,
matte_image,exception);
else
XMakeImageMSBFirst(resource_info,window,window->image,ximage,
matte_image,exception);
}
if (window->matte_image != (XImage *) NULL)
{
/*
Create matte pixmap.
*/
window->matte_pixmap=XCreatePixmap(display,window->id,width,height,1);
if (window->matte_pixmap != (Pixmap) NULL)
{
GC
graphics_context;
XGCValues
context_values;
/*
Copy matte image to matte pixmap.
*/
context_values.background=0;
context_values.foreground=1;
graphics_context=XCreateGC(display,window->matte_pixmap,
(size_t) (GCBackground | GCForeground),&context_values);
(void) XPutImage(display,window->matte_pixmap,graphics_context,
window->matte_image,0,0,0,0,width,height);
(void) XFreeGC(display,graphics_context);
#if defined(MAGICKCORE_HAVE_SHAPE)
if (window->shape != MagickFalse)
XShapeCombineMask(display,window->id,ShapeBounding,0,0,
window->matte_pixmap,ShapeSet);
#endif
}
}
(void) XMakePixmap(display,resource_info,window);
/*
Restore cursor.
*/
(void) XCheckDefineCursor(display,window->id,window->cursor);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X M a k e I m a g e L S B F i r s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeImageLSBFirst() initializes the pixel data of an X11 Image. The X image
% pixels are copied in least-significant bit and byte first order. The
% server's scanline pad is respected. Rather than using one or two general
% cases, many special cases are found here to help speed up the image
% conversion.
%
% The format of the XMakeImageLSBFirst method is:
%
% void XMakeImageLSBFirst(Display *display,XWindows *windows,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o window: Specifies a pointer to a XWindowInfo structure.
%
% o image: the image.
%
% o ximage: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
% o matte_image: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
% o exception: return any errors or warnings in this structure.
%
*/
static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image,
ExceptionInfo *exception)
{
CacheView
*canvas_view;
Image
*canvas;
int
y;
register const Quantum
*p;
register int
x;
register unsigned char
*q;
unsigned char
bit,
byte;
unsigned int
scanline_pad;
unsigned long
pixel,
*pixels;
XStandardColormap
*map_info;
assert(resource_info != (XResourceInfo *) NULL);
assert(window != (XWindowInfo *) NULL);
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable == MagickFalse) &&
(image->storage_class == DirectClass) && (image->alpha_trait != UndefinedPixelTrait))
{
char
size[MagickPathExtent];
Image
*pattern;
ImageInfo
*image_info;
image_info=AcquireImageInfo();
(void) CopyMagickString(image_info->filename,
resource_info->image_info->texture != (char *) NULL ?
resource_info->image_info->texture : "pattern:checkerboard",
MagickPathExtent);
(void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",(double)
image->columns,(double) image->rows);
image_info->size=ConstantString(size);
pattern=ReadImage(image_info,exception);
image_info=DestroyImageInfo(image_info);
if (pattern != (Image *) NULL)
{
canvas=CloneImage(image,0,0,MagickTrue,exception);
if (canvas != (Image *) NULL)
(void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickTrue,
0,0,exception);
pattern=DestroyImage(pattern);
}
}
scanline_pad=(unsigned int) (ximage->bytes_per_line-((ximage->width*
ximage->bits_per_pixel) >> 3));
map_info=window->map_info;
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
polarity;
unsigned char
background,
foreground;
/*
Convert canvas to big-endian bitmap.
*/
background=(unsigned char)
(XPixelIntensity(&window->pixel_info->foreground_color) <
XPixelIntensity(&window->pixel_info->background_color) ? 0x80 : 0x00);
foreground=(unsigned char)
(XPixelIntensity(&window->pixel_info->background_color) <
XPixelIntensity(&window->pixel_info->foreground_color) ? 0x80 : 0x00);
polarity=(unsigned short) ((GetPixelInfoIntensity(image,
&canvas->colormap[0])) < (QuantumRange/2.0) ? 1 : 0);
if (canvas->colors == 2)
polarity=GetPixelInfoIntensity(image,&canvas->colormap[0]) <
GetPixelInfoIntensity(image,&canvas->colormap[1]);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
byte=0;
for (x=0; x < (int) canvas->columns; x++)
{
byte>>=1;
if (GetPixelIndex(canvas,p) == (Quantum) polarity)
byte|=foreground;
else
byte|=background;
bit++;
if (bit == 8)
{
*q++=byte;
bit=0;
byte=0;
}
p+=GetPixelChannels(canvas);
}
if (bit != 0)
*q=byte >> (8-bit);
q+=scanline_pad;
}
}
else
if (window->pixel_info->colors != 0)
switch (ximage->bits_per_pixel)
{
case 2:
{
register unsigned int
nibble;
/*
Convert to 2 bit color-mapped X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)] & 0x0f;
switch (nibble)
{
case 0:
{
*q=(unsigned char) pixel;
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 2);
nibble++;
break;
}
case 2:
{
*q|=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 3:
{
*q|=(unsigned char) (pixel << 6);
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 4:
{
register unsigned int
nibble;
/*
Convert to 4 bit color-mapped X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)] & 0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) pixel;
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 4);
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 6:
case 8:
{
/*
Convert to 8 bit color-mapped X canvas.
*/
if (resource_info->color_recovery &&
resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
}
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)];
*q++=(unsigned char) pixel;
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
default:
{
register int
k;
register unsigned int
bytes_per_pixel;
/*
Convert to multi-byte color-mapped X canvas.
*/
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)];
for (k=0; k < (int) bytes_per_pixel; k++)
{
*q++=(unsigned char) (pixel & 0xff);
pixel>>=8;
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
}
else
switch (ximage->bits_per_pixel)
{
case 2:
{
register unsigned int
nibble;
/*
Convert to contiguous 2 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
nibble=0;
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=XGammaPixel(canvas,map_info,p);
pixel&=0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) pixel;
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 2);
nibble++;
break;
}
case 2:
{
*q|=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 3:
{
*q|=(unsigned char) (pixel << 6);
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 4:
{
register unsigned int
nibble;
/*
Convert to contiguous 4 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=XGammaPixel(canvas,map_info,p);
pixel&=0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) pixel;
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 4);
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 6:
case 8:
{
/*
Convert to contiguous 8 bit continuous-tone X canvas.
*/
if (resource_info->color_recovery &&
resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
}
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=XGammaPixel(canvas,map_info,p);
*q++=(unsigned char) pixel;
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
default:
{
if ((ximage->bits_per_pixel == 32) && (map_info->red_max == 255) &&
(map_info->green_max == 255) && (map_info->blue_max == 255) &&
(map_info->red_mult == 65536L) && (map_info->green_mult == 256) &&
(map_info->blue_mult == 1))
{
/*
Convert to 32 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
(blue_gamma != 1.0))
{
/*
Gamma correct canvas.
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
*q++=ScaleQuantumToChar(XGreenGamma(
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
*q++=0;
p+=GetPixelChannels(canvas);
}
continue;
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
*q++=0;
p+=GetPixelChannels(canvas);
}
}
}
else
if ((ximage->bits_per_pixel == 32) && (map_info->red_max == 255) &&
(map_info->green_max == 255) && (map_info->blue_max == 255) &&
(map_info->red_mult == 1) && (map_info->green_mult == 256) &&
(map_info->blue_mult == 65536L))
{
/*
Convert to 32 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
(blue_gamma != 1.0))
{
/*
Gamma correct canvas.
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
*q++=ScaleQuantumToChar(XGreenGamma(
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
*q++=0;
p+=GetPixelChannels(canvas);
}
continue;
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
*q++=0;
p+=GetPixelChannels(canvas);
}
}
}
else
{
register int
k;
register unsigned int
bytes_per_pixel;
/*
Convert to multi-byte continuous-tone X canvas.
*/
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=XGammaPixel(canvas,map_info,p);
for (k=0; k < (int) bytes_per_pixel; k++)
{
*q++=(unsigned char) (pixel & 0xff);
pixel>>=8;
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
}
break;
}
}
if (matte_image != (XImage *) NULL)
{
/*
Initialize matte canvas.
*/
scanline_pad=(unsigned int) (matte_image->bytes_per_line-
((matte_image->width*matte_image->bits_per_pixel) >> 3));
q=(unsigned char *) matte_image->data;
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
byte=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
byte>>=1;
if (GetPixelAlpha(canvas,p) > (QuantumRange/2))
byte|=0x80;
bit++;
if (bit == 8)
{
*q++=byte;
bit=0;
byte=0;
}
p+=GetPixelChannels(canvas);
}
if (bit != 0)
*q=byte >> (8-bit);
q+=scanline_pad;
}
}
canvas_view=DestroyCacheView(canvas_view);
if (canvas != image)
canvas=DestroyImage(canvas);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X M a k e I m a g e M S B F i r s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeImageMSBFirst() initializes the pixel data of an X11 Image. The X
% image pixels are copied in most-significant bit and byte first order. The
% server's scanline pad is also respected. Rather than using one or two
% general cases, many special cases are found here to help speed up the image
% conversion.
%
% The format of the XMakeImageMSBFirst method is:
%
% XMakeImageMSBFirst(resource_info,window,image,ximage,matte_image,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o window: Specifies a pointer to a XWindowInfo structure.
%
% o image: the image.
%
% o ximage: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
% o matte_image: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
% o exception: return any errors or warnings in this structure.
%
*/
static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image,
ExceptionInfo *exception)
{
CacheView
*canvas_view;
Image
*canvas;
int
y;
register int
x;
register const Quantum
*p;
register unsigned char
*q;
unsigned char
bit,
byte;
unsigned int
scanline_pad;
unsigned long
pixel,
*pixels;
XStandardColormap
*map_info;
assert(resource_info != (XResourceInfo *) NULL);
assert(window != (XWindowInfo *) NULL);
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable != MagickFalse) &&
(image->storage_class == DirectClass) &&
(image->alpha_trait != UndefinedPixelTrait))
{
char
size[MagickPathExtent];
Image
*pattern;
ImageInfo
*image_info;
image_info=AcquireImageInfo();
(void) CopyMagickString(image_info->filename,
resource_info->image_info->texture != (char *) NULL ?
resource_info->image_info->texture : "pattern:checkerboard",
MagickPathExtent);
(void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",(double)
image->columns,(double) image->rows);
image_info->size=ConstantString(size);
pattern=ReadImage(image_info,exception);
image_info=DestroyImageInfo(image_info);
if (pattern != (Image *) NULL)
{
canvas=CloneImage(image,0,0,MagickTrue,exception);
if (canvas != (Image *) NULL)
(void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickFalse,
0,0,exception);
pattern=DestroyImage(pattern);
}
}
scanline_pad=(unsigned int) (ximage->bytes_per_line-((ximage->width*
ximage->bits_per_pixel) >> 3));
map_info=window->map_info;
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
polarity;
unsigned char
background,
foreground;
/*
Convert canvas to big-endian bitmap.
*/
background=(unsigned char)
(XPixelIntensity(&window->pixel_info->foreground_color) <
XPixelIntensity(&window->pixel_info->background_color) ? 0x01 : 0x00);
foreground=(unsigned char)
(XPixelIntensity(&window->pixel_info->background_color) <
XPixelIntensity(&window->pixel_info->foreground_color) ? 0x01 : 0x00);
polarity=(unsigned short) ((GetPixelInfoIntensity(image,
&canvas->colormap[0])) < (QuantumRange/2.0) ? 1 : 0);
if (canvas->colors == 2)
polarity=GetPixelInfoIntensity(image,&canvas->colormap[0]) <
GetPixelInfoIntensity(image,&canvas->colormap[1]);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
byte=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
byte<<=1;
if (GetPixelIndex(canvas,p) == (Quantum) polarity)
byte|=foreground;
else
byte|=background;
bit++;
if (bit == 8)
{
*q++=byte;
bit=0;
byte=0;
}
p+=GetPixelChannels(canvas);
}
if (bit != 0)
*q=byte << (8-bit);
q+=scanline_pad;
}
}
else
if (window->pixel_info->colors != 0)
switch (ximage->bits_per_pixel)
{
case 2:
{
register unsigned int
nibble;
/*
Convert to 2 bit color-mapped X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t)
GetPixelIndex(canvas,p)] & 0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) (pixel << 6);
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 2:
{
*q|=(unsigned char) (pixel << 2);
nibble++;
break;
}
case 3:
{
*q|=(unsigned char) pixel;
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 4:
{
register unsigned int
nibble;
/*
Convert to 4 bit color-mapped X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t)
GetPixelIndex(canvas,p)] & 0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) pixel;
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 6:
case 8:
{
/*
Convert to 8 bit color-mapped X canvas.
*/
if (resource_info->color_recovery &&
resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
}
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)];
*q++=(unsigned char) pixel;
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
default:
{
register int
k;
register unsigned int
bytes_per_pixel;
unsigned char
channel[sizeof(size_t)];
/*
Convert to 8 bit color-mapped X canvas.
*/
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
{
pixel=pixels[(ssize_t)
GetPixelIndex(canvas,p)];
for (k=(int) bytes_per_pixel-1; k >= 0; k--)
{
channel[k]=(unsigned char) pixel;
pixel>>=8;
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
}
else
switch (ximage->bits_per_pixel)
{
case 2:
{
register unsigned int
nibble;
/*
Convert to 4 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
pixel=XGammaPixel(canvas,map_info,p);
pixel&=0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) (pixel << 6);
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 2:
{
*q|=(unsigned char) (pixel << 2);
nibble++;
break;
}
case 3:
{
*q|=(unsigned char) pixel;
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 4:
{
register unsigned int
nibble;
/*
Convert to 4 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
nibble=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
pixel=XGammaPixel(canvas,map_info,p);
pixel&=0xf;
switch (nibble)
{
case 0:
{
*q=(unsigned char) (pixel << 4);
nibble++;
break;
}
case 1:
{
*q|=(unsigned char) pixel;
q++;
nibble=0;
break;
}
}
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
case 6:
case 8:
{
/*
Convert to 8 bit continuous-tone X canvas.
*/
if (resource_info->color_recovery &&
resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
}
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
pixel=XGammaPixel(canvas,map_info,p);
*q++=(unsigned char) pixel;
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
break;
}
default:
{
if ((ximage->bits_per_pixel == 32) && (map_info->red_max == 255) &&
(map_info->green_max == 255) && (map_info->blue_max == 255) &&
(map_info->red_mult == 65536L) && (map_info->green_mult == 256) &&
(map_info->blue_mult == 1))
{
/*
Convert to 32 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
(blue_gamma != 1.0))
{
/*
Gamma correct canvas.
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
*q++=ScaleQuantumToChar(XGreenGamma(
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
p+=GetPixelChannels(canvas);
}
continue;
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
*q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
p+=GetPixelChannels(canvas);
}
}
}
else
if ((ximage->bits_per_pixel == 32) && (map_info->red_max == 255) &&
(map_info->green_max == 255) && (map_info->blue_max == 255) &&
(map_info->red_mult == 1) && (map_info->green_mult == 256) &&
(map_info->blue_mult == 65536L))
{
/*
Convert to 32 bit continuous-tone X canvas.
*/
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
(blue_gamma != 1.0))
{
/*
Gamma correct canvas.
*/
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
*q++=ScaleQuantumToChar(XBlueGamma(
GetPixelBlue(canvas,p)));
*q++=ScaleQuantumToChar(XGreenGamma(
GetPixelGreen(canvas,p)));
*q++=ScaleQuantumToChar(XRedGamma(
GetPixelRed(canvas,p)));
p+=GetPixelChannels(canvas);
}
continue;
}
for (x=(int) canvas->columns-1; x >= 0; x--)
{
*q++=0;
*q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
*q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
p+=GetPixelChannels(canvas);
}
}
}
else
{
register int
k;
register unsigned int
bytes_per_pixel;
unsigned char
channel[sizeof(size_t)];
/*
Convert to multi-byte continuous-tone X canvas.
*/
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
canvas->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
pixel=XGammaPixel(canvas,map_info,p);
for (k=(int) bytes_per_pixel-1; k >= 0; k--)
{
channel[k]=(unsigned char) pixel;
pixel>>=8;
}
for (k=0; k < (int) bytes_per_pixel; k++)
*q++=channel[k];
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
}
}
break;
}
}
if (matte_image != (XImage *) NULL)
{
/*
Initialize matte canvas.
*/
scanline_pad=(unsigned int) (matte_image->bytes_per_line-
((matte_image->width*matte_image->bits_per_pixel) >> 3));
q=(unsigned char *) matte_image->data;
for (y=0; y < (int) canvas->rows; y++)
{
p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
byte=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
byte<<=1;
if (GetPixelAlpha(canvas,p) > (QuantumRange/2))
byte|=0x01;
bit++;
if (bit == 8)
{
*q++=byte;
bit=0;
byte=0;
}
p+=GetPixelChannels(canvas);
}
if (bit != 0)
*q=byte << (8-bit);
q+=scanline_pad;
}
}
canvas_view=DestroyCacheView(canvas_view);
if (canvas != image)
canvas=DestroyImage(canvas);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e M a g n i f y I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeMagnifyImage() magnifies a region of an X image and displays it.
%
% The format of the XMakeMagnifyImage method is:
%
% void XMakeMagnifyImage(Display *display,XWindows *windows,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o windows: Specifies a pointer to a XWindows structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate void XMakeMagnifyImage(Display *display,XWindows *windows,
ExceptionInfo *exception)
{
char
tuple[MagickPathExtent];
int
y;
PixelInfo
pixel;
register int
x;
register ssize_t
i;
register unsigned char
*p,
*q;
ssize_t
n;
static unsigned int
previous_magnify = 0;
static XWindowInfo
magnify_window;
unsigned int
height,
j,
k,
l,
magnify,
scanline_pad,
width;
XImage
*ximage;
/*
Check boundary conditions.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(windows != (XWindows *) NULL);
magnify=1;
for (n=1; n < (ssize_t) windows->magnify.data; n++)
magnify<<=1;
while ((magnify*windows->image.ximage->width) < windows->magnify.width)
magnify<<=1;
while ((magnify*windows->image.ximage->height) < windows->magnify.height)
magnify<<=1;
while (magnify > windows->magnify.width)
magnify>>=1;
while (magnify > windows->magnify.height)
magnify>>=1;
if (magnify == 0)
magnify=1;
if (magnify != previous_magnify)
{
Status
status;
XTextProperty
window_name;
/*
New magnify factor: update magnify window name.
*/
i=0;
while ((1 << i) <= (int) magnify)
i++;
(void) FormatLocaleString(windows->magnify.name,MagickPathExtent,
"Magnify %.20gX",(double) i);
status=XStringListToTextProperty(&windows->magnify.name,1,&window_name);
if (status != False)
{
XSetWMName(display,windows->magnify.id,&window_name);
XSetWMIconName(display,windows->magnify.id,&window_name);
(void) XFree((void *) window_name.value);
}
}
previous_magnify=magnify;
ximage=windows->image.ximage;
width=(unsigned int) windows->magnify.ximage->width;
height=(unsigned int) windows->magnify.ximage->height;
if ((windows->magnify.x < 0) ||
(windows->magnify.x >= windows->image.ximage->width))
windows->magnify.x=windows->image.ximage->width >> 1;
x=windows->magnify.x-((width/magnify) >> 1);
if (x < 0)
x=0;
else
if (x > (int) (ximage->width-(width/magnify)))
x=ximage->width-width/magnify;
if ((windows->magnify.y < 0) ||
(windows->magnify.y >= windows->image.ximage->height))
windows->magnify.y=windows->image.ximage->height >> 1;
y=windows->magnify.y-((height/magnify) >> 1);
if (y < 0)
y=0;
else
if (y > (int) (ximage->height-(height/magnify)))
y=ximage->height-height/magnify;
q=(unsigned char *) windows->magnify.ximage->data;
scanline_pad=(unsigned int) (windows->magnify.ximage->bytes_per_line-
((width*windows->magnify.ximage->bits_per_pixel) >> 3));
if (ximage->bits_per_pixel < 8)
{
register unsigned char
background,
byte,
foreground,
p_bit,
q_bit;
register unsigned int
plane;
XPixelInfo
*pixel_info;
pixel_info=windows->magnify.pixel_info;
switch (ximage->bitmap_bit_order)
{
case LSBFirst:
{
/*
Magnify little-endian bitmap.
*/
background=0x00;
foreground=0x80;
if (ximage->format == XYBitmap)
{
background=(unsigned char)
(XPixelIntensity(&pixel_info->foreground_color) <
XPixelIntensity(&pixel_info->background_color) ? 0x80 : 0x00);
foreground=(unsigned char)
(XPixelIntensity(&pixel_info->background_color) <
XPixelIntensity(&pixel_info->foreground_color) ? 0x80 : 0x00);
if (windows->magnify.depth > 1)
Swap(background,foreground);
}
for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
*/
for (j=0; j < magnify; j++)
{
p=(unsigned char *) ximage->data+y*ximage->bytes_per_line+
((x*ximage->bits_per_pixel) >> 3);
p_bit=(unsigned char) (x*ximage->bits_per_pixel) & 0x07;
q_bit=0;
byte=0;
for (k=0; k < width; k+=magnify)
{
/*
Propogate pixel magnify columns.
*/
for (l=0; l < magnify; l++)
{
/*
Propogate each bit plane.
*/
for (plane=0; (int) plane < ximage->bits_per_pixel; plane++)
{
byte>>=1;
if (*p & (0x01 << (p_bit+plane)))
byte|=foreground;
else
byte|=background;
q_bit++;
if (q_bit == 8)
{
*q++=byte;
q_bit=0;
byte=0;
}
}
}
p_bit+=ximage->bits_per_pixel;
if (p_bit == 8)
{
p++;
p_bit=0;
}
if (q_bit != 0)
*q=byte >> (8-q_bit);
q+=scanline_pad;
}
}
y++;
}
break;
}
case MSBFirst:
default:
{
/*
Magnify big-endian bitmap.
*/
background=0x00;
foreground=0x01;
if (ximage->format == XYBitmap)
{
background=(unsigned char)
(XPixelIntensity(&pixel_info->foreground_color) <
XPixelIntensity(&pixel_info->background_color) ? 0x01 : 0x00);
foreground=(unsigned char)
(XPixelIntensity(&pixel_info->background_color) <
XPixelIntensity(&pixel_info->foreground_color) ? 0x01 : 0x00);
if (windows->magnify.depth > 1)
Swap(background,foreground);
}
for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
*/
for (j=0; j < magnify; j++)
{
p=(unsigned char *) ximage->data+y*ximage->bytes_per_line+
((x*ximage->bits_per_pixel) >> 3);
p_bit=(unsigned char) (x*ximage->bits_per_pixel) & 0x07;
q_bit=0;
byte=0;
for (k=0; k < width; k+=magnify)
{
/*
Propogate pixel magnify columns.
*/
for (l=0; l < magnify; l++)
{
/*
Propogate each bit plane.
*/
for (plane=0; (int) plane < ximage->bits_per_pixel; plane++)
{
byte<<=1;
if (*p & (0x80 >> (p_bit+plane)))
byte|=foreground;
else
byte|=background;
q_bit++;
if (q_bit == 8)
{
*q++=byte;
q_bit=0;
byte=0;
}
}
}
p_bit+=ximage->bits_per_pixel;
if (p_bit == 8)
{
p++;
p_bit=0;
}
if (q_bit != 0)
*q=byte << (8-q_bit);
q+=scanline_pad;
}
}
y++;
}
break;
}
}
}
else
switch (ximage->bits_per_pixel)
{
case 6:
case 8:
{
/*
Magnify 8 bit X image.
*/
for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
*/
for (j=0; j < magnify; j++)
{
p=(unsigned char *) ximage->data+y*ximage->bytes_per_line+
((x*ximage->bits_per_pixel) >> 3);
for (k=0; k < width; k+=magnify)
{
/*
Propogate pixel magnify columns.
*/
for (l=0; l < magnify; l++)
*q++=(*p);
p++;
}
q+=scanline_pad;
}
y++;
}
break;
}
default:
{
register unsigned int
bytes_per_pixel,
m;
/*
Magnify multi-byte X image.
*/
bytes_per_pixel=(unsigned int) ximage->bits_per_pixel >> 3;
for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
*/
for (j=0; j < magnify; j++)
{
p=(unsigned char *) ximage->data+y*ximage->bytes_per_line+
((x*ximage->bits_per_pixel) >> 3);
for (k=0; k < width; k+=magnify)
{
/*
Propogate pixel magnify columns.
*/
for (l=0; l < magnify; l++)
for (m=0; m < bytes_per_pixel; m++)
*q++=(*(p+m));
p+=bytes_per_pixel;
}
q+=scanline_pad;
}
y++;
}
break;
}
}
/*
Copy X image to magnify pixmap.
*/
x=windows->magnify.x-((width/magnify) >> 1);
if (x < 0)
x=(int) ((width >> 1)-windows->magnify.x*magnify);
else
if (x > (int) (ximage->width-(width/magnify)))
x=(int) ((ximage->width-windows->magnify.x)*magnify-(width >> 1));
else
x=0;
y=windows->magnify.y-((height/magnify) >> 1);
if (y < 0)
y=(int) ((height >> 1)-windows->magnify.y*magnify);
else
if (y > (int) (ximage->height-(height/magnify)))
y=(int) ((ximage->height-windows->magnify.y)*magnify-(height >> 1));
else
y=0;
if ((x != 0) || (y != 0))
(void) XFillRectangle(display,windows->magnify.pixmap,
windows->magnify.annotate_context,0,0,width,height);
(void) XPutImage(display,windows->magnify.pixmap,
windows->magnify.annotate_context,windows->magnify.ximage,0,0,x,y,width-x,
height-y);
if ((magnify > 1) && ((magnify <= (width >> 1)) &&
(magnify <= (height >> 1))))
{
RectangleInfo
highlight_info;
/*
Highlight center pixel.
*/
highlight_info.x=(ssize_t) windows->magnify.width >> 1;
highlight_info.y=(ssize_t) windows->magnify.height >> 1;
highlight_info.width=magnify;
highlight_info.height=magnify;
(void) XDrawRectangle(display,windows->magnify.pixmap,
windows->magnify.highlight_context,(int) highlight_info.x,
(int) highlight_info.y,(unsigned int) highlight_info.width-1,
(unsigned int) highlight_info.height-1);
if (magnify > 2)
(void) XDrawRectangle(display,windows->magnify.pixmap,
windows->magnify.annotate_context,(int) highlight_info.x+1,
(int) highlight_info.y+1,(unsigned int) highlight_info.width-3,
(unsigned int) highlight_info.height-3);
}
/*
Show center pixel color.
*/
(void) GetOneVirtualPixelInfo(windows->image.image,TileVirtualPixelMethod,
(ssize_t) windows->magnify.x,(ssize_t) windows->magnify.y,&pixel,exception);
(void) FormatLocaleString(tuple,MagickPathExtent,"%d,%d: ",
windows->magnify.x,windows->magnify.y);
(void) ConcatenateMagickString(tuple,"(",MagickPathExtent);
ConcatenateColorComponent(&pixel,RedPixelChannel,X11Compliance,tuple);
(void) ConcatenateMagickString(tuple,",",MagickPathExtent);
ConcatenateColorComponent(&pixel,GreenPixelChannel,X11Compliance,tuple);
(void) ConcatenateMagickString(tuple,",",MagickPathExtent);
ConcatenateColorComponent(&pixel,BluePixelChannel,X11Compliance,tuple);
if (pixel.colorspace == CMYKColorspace)
{
(void) ConcatenateMagickString(tuple,",",MagickPathExtent);
ConcatenateColorComponent(&pixel,BlackPixelChannel,X11Compliance,tuple);
}
if (pixel.alpha_trait != UndefinedPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MagickPathExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,X11Compliance,tuple);
}
(void) ConcatenateMagickString(tuple,")",MagickPathExtent);
height=(unsigned int) windows->magnify.font_info->ascent+
windows->magnify.font_info->descent;
x=windows->magnify.font_info->max_bounds.width >> 1;
y=windows->magnify.font_info->ascent+(height >> 2);
(void) XDrawImageString(display,windows->magnify.pixmap,
windows->magnify.annotate_context,x,y,tuple,(int) strlen(tuple));
GetColorTuple(&pixel,MagickTrue,tuple);
y+=height;
(void) XDrawImageString(display,windows->magnify.pixmap,
windows->magnify.annotate_context,x,y,tuple,(int) strlen(tuple));
(void) QueryColorname(windows->image.image,&pixel,SVGCompliance,tuple,
exception);
y+=height;
(void) XDrawImageString(display,windows->magnify.pixmap,
windows->magnify.annotate_context,x,y,tuple,(int) strlen(tuple));
/*
Refresh magnify window.
*/
magnify_window=windows->magnify;
magnify_window.x=0;
magnify_window.y=0;
XRefreshWindow(display,&magnify_window,(XEvent *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e P i x m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakePixmap() creates an X11 pixmap.
%
% The format of the XMakePixmap method is:
%
% void XMakeStandardColormap(Display *display,XVisualInfo *visual_info,
% XResourceInfo *resource_info,Image *image,XStandardColormap *map_info,
% XPixelInfo *pixel)
%
% A description of each parameter follows:
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a XWindowInfo structure.
%
*/
static MagickBooleanType XMakePixmap(Display *display,
const XResourceInfo *resource_info,XWindowInfo *window)
{
unsigned int
height,
width;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(window != (XWindowInfo *) NULL);
if (window->pixmap != (Pixmap) NULL)
{
/*
Destroy previous X pixmap.
*/
(void) XFreePixmap(display,window->pixmap);
window->pixmap=(Pixmap) NULL;
}
if (window->use_pixmap == MagickFalse)
return(MagickFalse);
if (window->ximage == (XImage *) NULL)
return(MagickFalse);
/*
Display busy cursor.
*/
(void) XCheckDefineCursor(display,window->id,window->busy_cursor);
(void) XFlush(display);
/*
Create pixmap.
*/
width=(unsigned int) window->ximage->width;
height=(unsigned int) window->ximage->height;
window->pixmap=XCreatePixmap(display,window->id,width,height,window->depth);
if (window->pixmap == (Pixmap) NULL)
{
/*
Unable to allocate pixmap.
*/
(void) XCheckDefineCursor(display,window->id,window->cursor);
return(MagickFalse);
}
/*
Copy X image to pixmap.
*/
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->shared_memory)
(void) XShmPutImage(display,window->pixmap,window->annotate_context,
window->ximage,0,0,0,0,width,height,MagickTrue);
#endif
if (window->shared_memory == MagickFalse)
(void) XPutImage(display,window->pixmap,window->annotate_context,
window->ximage,0,0,0,0,width,height);
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),"Pixmap:");
(void) LogMagickEvent(X11Event,GetMagickModule()," width, height: %ux%u",
width,height);
}
/*
Restore cursor.
*/
(void) XCheckDefineCursor(display,window->id,window->cursor);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e S t a n d a r d C o l o r m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeStandardColormap() creates an X11 Standard Colormap.
%
% The format of the XMakeStandardColormap method is:
%
% void XMakeStandardColormap(Display *display,XVisualInfo *visual_info,
% XResourceInfo *resource_info,Image *image,XStandardColormap *map_info,
% XPixelInfo *pixel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o visual_info: Specifies a pointer to a X11 XVisualInfo structure;
% returned from XGetVisualInfo.
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
% o image: the image.
%
% o map_info: If a Standard Colormap type is specified, this structure is
% initialized with info from the Standard Colormap.
%
% o pixel: Specifies a pointer to a XPixelInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
static inline double DiversityPixelIntensity(
const DiversityPacket *pixel)
{
double
intensity;
intensity=0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
return(intensity);
}
static int IntensityCompare(const void *x,const void *y)
{
DiversityPacket
*color_1,
*color_2;
int
diversity;
color_1=(DiversityPacket *) x;
color_2=(DiversityPacket *) y;
diversity=(int) (DiversityPixelIntensity(color_2)-
DiversityPixelIntensity(color_1));
return(diversity);
}
static int PopularityCompare(const void *x,const void *y)
{
DiversityPacket
*color_1,
*color_2;
color_1=(DiversityPacket *) x;
color_2=(DiversityPacket *) y;
return((int) color_2->count-(int) color_1->count);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
static inline Quantum ScaleXToQuantum(const size_t x,
const size_t scale)
{
return((Quantum) (((double) QuantumRange*x)/scale+0.5));
}
MagickPrivate void XMakeStandardColormap(Display *display,
XVisualInfo *visual_info,XResourceInfo *resource_info,Image *image,
XStandardColormap *map_info,XPixelInfo *pixel,ExceptionInfo *exception)
{
Colormap
colormap;
register ssize_t
i;
Status
status;
size_t
number_colors,
retain_colors;
unsigned short
gray_value;
XColor
color,
*colors,
*p;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(visual_info != (XVisualInfo *) NULL);
assert(map_info != (XStandardColormap *) NULL);
assert(resource_info != (XResourceInfo *) NULL);
assert(pixel != (XPixelInfo *) NULL);
if (resource_info->map_type != (char *) NULL)
{
/*
Standard Colormap is already defined (i.e. xstdcmap).
*/
XGetPixelInfo(display,visual_info,map_info,resource_info,image,
pixel);
number_colors=(unsigned int) (map_info->base_pixel+
(map_info->red_max+1)*(map_info->green_max+1)*(map_info->blue_max+1));
if ((map_info->red_max*map_info->green_max*map_info->blue_max) != 0)
if ((image->alpha_trait == UndefinedPixelTrait) &&
(resource_info->color_recovery == MagickFalse) &&
(resource_info->quantize_info->dither_method != NoDitherMethod) &&
(number_colors < MaxColormapSize))
{
Image
*affinity_image;
register Quantum
*magick_restrict q;
/*
Improve image appearance with error diffusion.
*/
affinity_image=AcquireImage((ImageInfo *) NULL,exception);
if (affinity_image == (Image *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToDitherImage",image->filename);
affinity_image->columns=number_colors;
affinity_image->rows=1;
/*
Initialize colormap image.
*/
q=QueueAuthenticPixels(affinity_image,0,0,affinity_image->columns,
1,exception);
if (q != (Quantum *) NULL)
{
for (i=0; i < (ssize_t) number_colors; i++)
{
SetPixelRed(affinity_image,0,q);
if (map_info->red_max != 0)
SetPixelRed(affinity_image,ScaleXToQuantum((size_t)
(i/map_info->red_mult),map_info->red_max),q);
SetPixelGreen(affinity_image,0,q);
if (map_info->green_max != 0)
SetPixelGreen(affinity_image,ScaleXToQuantum((size_t)
((i/map_info->green_mult) % (map_info->green_max+1)),
map_info->green_max),q);
SetPixelBlue(affinity_image,0,q);
if (map_info->blue_max != 0)
SetPixelBlue(affinity_image,ScaleXToQuantum((size_t)
(i % map_info->green_mult),map_info->blue_max),q);
SetPixelAlpha(affinity_image,
TransparentAlpha,q);
q+=GetPixelChannels(affinity_image);
}
(void) SyncAuthenticPixels(affinity_image,exception);
(void) RemapImage(resource_info->quantize_info,image,
affinity_image,exception);
}
XGetPixelInfo(display,visual_info,map_info,resource_info,image,
pixel);
(void) SetImageStorageClass(image,DirectClass,exception);
affinity_image=DestroyImage(affinity_image);
}
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),
"Standard Colormap:");
(void) LogMagickEvent(X11Event,GetMagickModule(),
" colormap id: 0x%lx",map_info->colormap);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue max: %lu %lu %lu",map_info->red_max,
map_info->green_max,map_info->blue_max);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue mult: %lu %lu %lu",map_info->red_mult,
map_info->green_mult,map_info->blue_mult);
}
return;
}
if ((visual_info->klass != DirectColor) &&
(visual_info->klass != TrueColor))
if ((image->storage_class == DirectClass) ||
((int) image->colors > visual_info->colormap_size))
{
QuantizeInfo
quantize_info;
/*
Image has more colors than the visual supports.
*/
quantize_info=(*resource_info->quantize_info);
quantize_info.number_colors=(size_t) visual_info->colormap_size;
(void) QuantizeImage(&quantize_info,image,exception);
}
/*
Free previous and create new colormap.
*/
(void) XFreeStandardColormap(display,visual_info,map_info,pixel);
colormap=XDefaultColormap(display,visual_info->screen);
if (visual_info->visual != XDefaultVisual(display,visual_info->screen))
colormap=XCreateColormap(display,XRootWindow(display,visual_info->screen),
visual_info->visual,visual_info->klass == DirectColor ?
AllocAll : AllocNone);
if (colormap == (Colormap) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,"UnableToCreateColormap",
image->filename);
/*
Initialize the map and pixel info structures.
*/
XGetMapInfo(visual_info,colormap,map_info);
XGetPixelInfo(display,visual_info,map_info,resource_info,image,pixel);
/*
Allocating colors in server colormap is based on visual class.
*/
switch (visual_info->klass)
{
case StaticGray:
case StaticColor:
{
/*
Define Standard Colormap for StaticGray or StaticColor visual.
*/
number_colors=image->colors;
colors=(XColor *) AcquireQuantumMemory((size_t)
visual_info->colormap_size,sizeof(*colors));
if (colors == (XColor *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
for (i=0; i < (ssize_t) image->colors; i++)
{
color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
color.blue=ScaleQuantumToShort(XBlueGamma(image->colormap[i].blue));
if (visual_info->klass != StaticColor)
{
gray_value=(unsigned short) XPixelIntensity(&color);
color.red=gray_value;
color.green=gray_value;
color.blue=gray_value;
}
status=XAllocColor(display,colormap,&color);
if (status == False)
{
colormap=XCopyColormapAndFree(display,colormap);
(void) XAllocColor(display,colormap,&color);
}
pixel->pixels[i]=color.pixel;
*p++=color;
}
break;
}
case GrayScale:
case PseudoColor:
{
unsigned int
colormap_type;
/*
Define Standard Colormap for GrayScale or PseudoColor visual.
*/
number_colors=image->colors;
colors=(XColor *) AcquireQuantumMemory((size_t)
visual_info->colormap_size,sizeof(*colors));
if (colors == (XColor *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
/*
Preallocate our GUI colors.
*/
(void) XAllocColor(display,colormap,&pixel->foreground_color);
(void) XAllocColor(display,colormap,&pixel->background_color);
(void) XAllocColor(display,colormap,&pixel->border_color);
(void) XAllocColor(display,colormap,&pixel->matte_color);
(void) XAllocColor(display,colormap,&pixel->highlight_color);
(void) XAllocColor(display,colormap,&pixel->shadow_color);
(void) XAllocColor(display,colormap,&pixel->depth_color);
(void) XAllocColor(display,colormap,&pixel->trough_color);
for (i=0; i < MaxNumberPens; i++)
(void) XAllocColor(display,colormap,&pixel->pen_colors[i]);
/*
Determine if image colors will "fit" into X server colormap.
*/
colormap_type=resource_info->colormap;
status=XAllocColorCells(display,colormap,MagickFalse,(unsigned long *)
NULL,0,pixel->pixels,(unsigned int) image->colors);
if (status != False)
colormap_type=PrivateColormap;
if (colormap_type == SharedColormap)
{
CacheView
*image_view;
DiversityPacket
*diversity;
int
y;
register int
x;
unsigned short
index;
XColor
*server_colors;
/*
Define Standard colormap for shared GrayScale or PseudoColor visual.
*/
diversity=(DiversityPacket *) AcquireQuantumMemory(image->colors,
sizeof(*diversity));
if (diversity == (DiversityPacket *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
for (i=0; i < (ssize_t) image->colors; i++)
{
diversity[i].red=ClampToQuantum(image->colormap[i].red);
diversity[i].green=ClampToQuantum(image->colormap[i].green);
diversity[i].blue=ClampToQuantum(image->colormap[i].blue);
diversity[i].index=(unsigned short) i;
diversity[i].count=0;
}
image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (int) image->rows; y++)
{
register int
x;
register const Quantum
*magick_restrict p;
p=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,
image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=(int) image->columns-1; x >= 0; x--)
{
diversity[(ssize_t) GetPixelIndex(image,p)].count++;
p+=GetPixelChannels(image);
}
}
image_view=DestroyCacheView(image_view);
/*
Sort colors by decreasing intensity.
*/
qsort((void *) diversity,image->colors,sizeof(*diversity),
IntensityCompare);
for (i=0; i < (ssize_t) image->colors; )
{
diversity[i].count<<=4; /* increase this colors popularity */
i+=MagickMax((int) (image->colors >> 4),2);
}
diversity[image->colors-1].count<<=4;
qsort((void *) diversity,image->colors,sizeof(*diversity),
PopularityCompare);
/*
Allocate colors.
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
for (i=0; i < (ssize_t) image->colors; i++)
{
index=diversity[i].index;
color.red=
ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
color.green=
ScaleQuantumToShort(XGreenGamma(image->colormap[index].green));
color.blue=
ScaleQuantumToShort(XBlueGamma(image->colormap[index].blue));
if (visual_info->klass != PseudoColor)
{
gray_value=(unsigned short) XPixelIntensity(&color);
color.red=gray_value;
color.green=gray_value;
color.blue=gray_value;
}
status=XAllocColor(display,colormap,&color);
if (status == False)
break;
pixel->pixels[index]=color.pixel;
*p++=color;
}
/*
Read X server colormap.
*/
server_colors=(XColor *) AcquireQuantumMemory((size_t)
visual_info->colormap_size,sizeof(*server_colors));
if (server_colors == (XColor *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
for (x=visual_info->colormap_size-1; x >= 0; x--)
server_colors[x].pixel=(size_t) x;
(void) XQueryColors(display,colormap,server_colors,
(int) MagickMin((unsigned int) visual_info->colormap_size,256));
/*
Select remaining colors from X server colormap.
*/
for (; i < (ssize_t) image->colors; i++)
{
index=diversity[i].index;
color.red=ScaleQuantumToShort(
XRedGamma(image->colormap[index].red));
color.green=ScaleQuantumToShort(
XGreenGamma(image->colormap[index].green));
color.blue=ScaleQuantumToShort(
XBlueGamma(image->colormap[index].blue));
if (visual_info->klass != PseudoColor)
{
gray_value=(unsigned short) XPixelIntensity(&color);
color.red=gray_value;
color.green=gray_value;
color.blue=gray_value;
}
XBestPixel(display,colormap,server_colors,(unsigned int)
visual_info->colormap_size,&color);
pixel->pixels[index]=color.pixel;
*p++=color;
}
if ((int) image->colors < visual_info->colormap_size)
{
/*
Fill up colors array-- more choices for pen colors.
*/
retain_colors=MagickMin((unsigned int)
(visual_info->colormap_size-image->colors),256);
for (i=0; i < (ssize_t) retain_colors; i++)
*p++=server_colors[i];
number_colors+=retain_colors;
}
server_colors=(XColor *) RelinquishMagickMemory(server_colors);
diversity=(DiversityPacket *) RelinquishMagickMemory(diversity);
break;
}
/*
Define Standard colormap for private GrayScale or PseudoColor visual.
*/
if (status == False)
{
/*
Not enough colormap entries in the colormap-- Create a new colormap.
*/
colormap=XCreateColormap(display,
XRootWindow(display,visual_info->screen),visual_info->visual,
AllocNone);
if (colormap == (Colormap) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
map_info->colormap=colormap;
if ((int) image->colors < visual_info->colormap_size)
{
/*
Retain colors from the default colormap to help lessens the
effects of colormap flashing.
*/
retain_colors=MagickMin((unsigned int)
(visual_info->colormap_size-image->colors),256);
p=colors+image->colors;
for (i=0; i < (ssize_t) retain_colors; i++)
{
p->pixel=(unsigned long) i;
p++;
}
(void) XQueryColors(display,
XDefaultColormap(display,visual_info->screen),
colors+image->colors,(int) retain_colors);
/*
Transfer colors from default to private colormap.
*/
(void) XAllocColorCells(display,colormap,MagickFalse,
(unsigned long *) NULL,0,pixel->pixels,(unsigned int)
retain_colors);
p=colors+image->colors;
for (i=0; i < (ssize_t) retain_colors; i++)
{
p->pixel=pixel->pixels[i];
p++;
}
(void) XStoreColors(display,colormap,colors+image->colors,
(int) retain_colors);
number_colors+=retain_colors;
}
(void) XAllocColorCells(display,colormap,MagickFalse,
(unsigned long *) NULL,0,pixel->pixels,(unsigned int)
image->colors);
}
/*
Store the image colormap.
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
for (i=0; i < (ssize_t) image->colors; i++)
{
color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
color.blue=ScaleQuantumToShort(XBlueGamma(image->colormap[i].blue));
if (visual_info->klass != PseudoColor)
{
gray_value=(unsigned short) XPixelIntensity(&color);
color.red=gray_value;
color.green=gray_value;
color.blue=gray_value;
}
color.pixel=pixel->pixels[i];
*p++=color;
}
(void) XStoreColors(display,colormap,colors,(int) image->colors);
break;
}
case TrueColor:
case DirectColor:
default:
{
MagickBooleanType
linear_colormap;
/*
Define Standard Colormap for TrueColor or DirectColor visual.
*/
number_colors=(unsigned int) ((map_info->red_max*map_info->red_mult)+
(map_info->green_max*map_info->green_mult)+
(map_info->blue_max*map_info->blue_mult)+1);
linear_colormap=(number_colors > 4096) ||
(((int) (map_info->red_max+1) == visual_info->colormap_size) &&
((int) (map_info->green_max+1) == visual_info->colormap_size) &&
((int) (map_info->blue_max+1) == visual_info->colormap_size)) ?
MagickTrue : MagickFalse;
if (linear_colormap != MagickFalse)
number_colors=(size_t) visual_info->colormap_size;
/*
Allocate color array.
*/
colors=(XColor *) AcquireQuantumMemory(number_colors,sizeof(*colors));
if (colors == (XColor *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
/*
Initialize linear color ramp.
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
if (linear_colormap != MagickFalse)
for (i=0; i < (ssize_t) number_colors; i++)
{
color.blue=(unsigned short) 0;
if (map_info->blue_max != 0)
color.blue=(unsigned short) ((size_t)
((65535L*(i % map_info->green_mult))/map_info->blue_max));
color.green=color.blue;
color.red=color.blue;
color.pixel=XStandardPixel(map_info,&color);
*p++=color;
}
else
for (i=0; i < (ssize_t) number_colors; i++)
{
color.red=(unsigned short) 0;
if (map_info->red_max != 0)
color.red=(unsigned short) ((size_t)
((65535L*(i/map_info->red_mult))/map_info->red_max));
color.green=(unsigned int) 0;
if (map_info->green_max != 0)
color.green=(unsigned short) ((size_t)
((65535L*((i/map_info->green_mult) % (map_info->green_max+1)))/
map_info->green_max));
color.blue=(unsigned short) 0;
if (map_info->blue_max != 0)
color.blue=(unsigned short) ((size_t)
((65535L*(i % map_info->green_mult))/map_info->blue_max));
color.pixel=XStandardPixel(map_info,&color);
*p++=color;
}
if ((visual_info->klass == DirectColor) &&
(colormap != XDefaultColormap(display,visual_info->screen)))
(void) XStoreColors(display,colormap,colors,(int) number_colors);
else
for (i=0; i < (ssize_t) number_colors; i++)
(void) XAllocColor(display,colormap,&colors[i]);
break;
}
}
if ((visual_info->klass != DirectColor) &&
(visual_info->klass != TrueColor))
{
/*
Set foreground, background, border, etc. pixels.
*/
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->foreground_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->background_color);
if (pixel->background_color.pixel == pixel->foreground_color.pixel)
{
/*
Foreground and background colors must differ.
*/
pixel->background_color.red=(~pixel->foreground_color.red);
pixel->background_color.green=
(~pixel->foreground_color.green);
pixel->background_color.blue=
(~pixel->foreground_color.blue);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->background_color);
}
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->border_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->matte_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->highlight_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->shadow_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->depth_color);
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->trough_color);
for (i=0; i < MaxNumberPens; i++)
{
XBestPixel(display,colormap,colors,(unsigned int) number_colors,
&pixel->pen_colors[i]);
pixel->pixels[image->colors+i]=pixel->pen_colors[i].pixel;
}
pixel->colors=(ssize_t) (image->colors+MaxNumberPens);
}
colors=(XColor *) RelinquishMagickMemory(colors);
if (IsEventLogging())
{
(void) LogMagickEvent(X11Event,GetMagickModule(),"Standard Colormap:");
(void) LogMagickEvent(X11Event,GetMagickModule()," colormap id: 0x%lx",
map_info->colormap);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue max: %lu %lu %lu",map_info->red_max,
map_info->green_max,map_info->blue_max);
(void) LogMagickEvent(X11Event,GetMagickModule(),
" red, green, blue mult: %lu %lu %lu",map_info->red_mult,
map_info->green_mult,map_info->blue_mult);
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a k e W i n d o w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMakeWindow() creates an X11 window.
%
% The format of the XMakeWindow method is:
%
% void XMakeWindow(Display *display,Window parent,char **argv,int argc,
% XClassHint *class_hint,XWMHints *manager_hints,
% XWindowInfo *window_info)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o parent: Specifies the parent window_info.
%
% o argv: Specifies the application's argument list.
%
% o argc: Specifies the number of arguments.
%
% o class_hint: Specifies a pointer to a X11 XClassHint structure.
%
% o manager_hints: Specifies a pointer to a X11 XWMHints structure.
%
% o window_info: Specifies a pointer to a X11 XWindowInfo structure.
%
*/
MagickPrivate void XMakeWindow(Display *display,Window parent,char **argv,
int argc,XClassHint *class_hint,XWMHints *manager_hints,
XWindowInfo *window_info)
{
#define MinWindowSize 64
Atom
atom_list[2];
int
gravity;
static XTextProperty
icon_name,
window_name;
Status
status;
XSizeHints
*size_hints;
/*
Set window info hints.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window_info != (XWindowInfo *) NULL);
size_hints=XAllocSizeHints();
if (size_hints == (XSizeHints *) NULL)
ThrowXWindowFatalException(XServerFatalError,"UnableToMakeXWindow",argv[0]);
size_hints->flags=(int) window_info->flags;
size_hints->x=window_info->x;
size_hints->y=window_info->y;
size_hints->width=(int) window_info->width;
size_hints->height=(int) window_info->height;
if (window_info->immutable != MagickFalse)
{
/*
Window size cannot be changed.
*/
size_hints->min_width=size_hints->width;
size_hints->min_height=size_hints->height;
size_hints->max_width=size_hints->width;
size_hints->max_height=size_hints->height;
size_hints->flags|=PMinSize;
size_hints->flags|=PMaxSize;
}
else
{
/*
Window size can be changed.
*/
size_hints->min_width=(int) window_info->min_width;
size_hints->min_height=(int) window_info->min_height;
size_hints->flags|=PResizeInc;
size_hints->width_inc=(int) window_info->width_inc;
size_hints->height_inc=(int) window_info->height_inc;
#if !defined(PRE_R4_ICCCM)
size_hints->flags|=PBaseSize;
size_hints->base_width=size_hints->width_inc;
size_hints->base_height=size_hints->height_inc;
#endif
}
gravity=NorthWestGravity;
if (window_info->geometry != (char *) NULL)
{
char
default_geometry[MagickPathExtent],
geometry[MagickPathExtent];
int
flags;
register char
*p;
/*
User specified geometry.
*/
(void) FormatLocaleString(default_geometry,MagickPathExtent,"%dx%d",
size_hints->width,size_hints->height);
(void) CopyMagickString(geometry,window_info->geometry,MagickPathExtent);
p=geometry;
while (strlen(p) != 0)
{
if ((isspace((int) ((unsigned char) *p)) == 0) && (*p != '%'))
p++;
else
(void) CopyMagickString(p,p+1,MagickPathExtent-(p-geometry));
}
flags=XWMGeometry(display,window_info->screen,geometry,default_geometry,
window_info->border_width,size_hints,&size_hints->x,&size_hints->y,
&size_hints->width,&size_hints->height,&gravity);
if ((flags & WidthValue) && (flags & HeightValue))
size_hints->flags|=USSize;
if ((flags & XValue) && (flags & YValue))
{
size_hints->flags|=USPosition;
window_info->x=size_hints->x;
window_info->y=size_hints->y;
}
}
#if !defined(PRE_R4_ICCCM)
size_hints->win_gravity=gravity;
size_hints->flags|=PWinGravity;
#endif
if (window_info->id == (Window) NULL)
window_info->id=XCreateWindow(display,parent,window_info->x,window_info->y,
(unsigned int) size_hints->width,(unsigned int) size_hints->height,
window_info->border_width,(int) window_info->depth,InputOutput,
window_info->visual,(unsigned long) window_info->mask,
&window_info->attributes);
else
{
MagickStatusType
mask;
XEvent
sans_event;
XWindowChanges
window_changes;
/*
Window already exists; change relevant attributes.
*/
(void) XChangeWindowAttributes(display,window_info->id,(unsigned long)
window_info->mask,&window_info->attributes);
mask=ConfigureNotify;
while (XCheckTypedWindowEvent(display,window_info->id,(int) mask,&sans_event)) ;
window_changes.x=window_info->x;
window_changes.y=window_info->y;
window_changes.width=(int) window_info->width;
window_changes.height=(int) window_info->height;
mask=(MagickStatusType) (CWWidth | CWHeight);
if (window_info->flags & USPosition)
mask|=CWX | CWY;
(void) XReconfigureWMWindow(display,window_info->id,window_info->screen,
mask,&window_changes);
}
if (window_info->id == (Window) NULL)
ThrowXWindowFatalException(XServerFatalError,"UnableToCreateWindow",
window_info->name);
status=XStringListToTextProperty(&window_info->name,1,&window_name);
if (status == False)
ThrowXWindowFatalException(XServerFatalError,"UnableToCreateTextProperty",
window_info->name);
status=XStringListToTextProperty(&window_info->icon_name,1,&icon_name);
if (status == False)
ThrowXWindowFatalException(XServerFatalError,"UnableToCreateTextProperty",
window_info->icon_name);
if (window_info->icon_geometry != (char *) NULL)
{
int
flags,
height,
width;
/*
User specified icon geometry.
*/
size_hints->flags|=USPosition;
flags=XWMGeometry(display,window_info->screen,window_info->icon_geometry,
(char *) NULL,0,size_hints,&manager_hints->icon_x,
&manager_hints->icon_y,&width,&height,&gravity);
if ((flags & XValue) && (flags & YValue))
manager_hints->flags|=IconPositionHint;
}
XSetWMProperties(display,window_info->id,&window_name,&icon_name,argv,argc,
size_hints,manager_hints,class_hint);
if (window_name.value != (void *) NULL)
{
(void) XFree((void *) window_name.value);
window_name.value=(unsigned char *) NULL;
window_name.nitems=0;
}
if (icon_name.value != (void *) NULL)
{
(void) XFree((void *) icon_name.value);
icon_name.value=(unsigned char *) NULL;
icon_name.nitems=0;
}
atom_list[0]=XInternAtom(display,"WM_DELETE_WINDOW",MagickFalse);
atom_list[1]=XInternAtom(display,"WM_TAKE_FOCUS",MagickFalse);
(void) XSetWMProtocols(display,window_info->id,atom_list,2);
(void) XFree((void *) size_hints);
if (window_info->shape != MagickFalse)
{
#if defined(MAGICKCORE_HAVE_SHAPE)
int
error_base,
event_base;
/*
Can we apply a non-rectangular shaping mask?
*/
error_base=0;
event_base=0;
if (XShapeQueryExtension(display,&error_base,&event_base) == 0)
window_info->shape=MagickFalse;
#else
window_info->shape=MagickFalse;
#endif
}
if (window_info->shared_memory)
{
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
/*
Can we use shared memory with this window?
*/
if (XShmQueryExtension(display) == 0)
window_info->shared_memory=MagickFalse;
#else
window_info->shared_memory=MagickFalse;
#endif
}
window_info->image=NewImageList();
window_info->destroy=MagickFalse;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X M a g i c k P r o g r e s s M o n i t o r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XMagickProgressMonitor() displays the progress a task is making in
% completing a task.
%
% The format of the XMagickProgressMonitor method is:
%
% void XMagickProgressMonitor(const char *task,
% const MagickOffsetType quantum,const MagickSizeType span,
% void *client_data)
%
% A description of each parameter follows:
%
% o task: Identifies the task in progress.
%
% o quantum: Specifies the quantum position within the span which represents
% how much progress has been made in completing a task.
%
% o span: Specifies the span relative to completing a task.
%
% o client_data: Pointer to any client data.
%
*/
static const char *GetLocaleMonitorMessage(const char *text)
{
char
message[MagickPathExtent],
tag[MagickPathExtent];
const char
*locale_message;
register char
*p;
(void) CopyMagickString(tag,text,MagickPathExtent);
p=strrchr(tag,'/');
if (p != (char *) NULL)
*p='\0';
(void) FormatLocaleString(message,MagickPathExtent,"Monitor/%s",tag);
locale_message=GetLocaleMessage(message);
if (locale_message == message)
return(text);
return(locale_message);
}
MagickPrivate MagickBooleanType XMagickProgressMonitor(const char *tag,
const MagickOffsetType quantum,const MagickSizeType span,
void *magick_unused(client_data))
{
XWindows
*windows;
windows=XSetWindows((XWindows *) ~0);
if (windows == (XWindows *) NULL)
return(MagickTrue);
if (windows->info.mapped != MagickFalse)
XProgressMonitorWidget(windows->display,windows,
GetLocaleMonitorMessage(tag),quantum,span);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X Q u e r y C o l o r D a t a b a s e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XQueryColorCompliance() looks up a RGB values for a color given in the target
% string.
%
% The format of the XQueryColorDatabase method is:
%
% MagickBooleanType XQueryColorCompliance(const char *target,XColor *color)
%
% A description of each parameter follows:
%
% o target: Specifies the color to lookup in the X color database.
%
% o color: A pointer to an PixelInfo structure. The RGB value of the target
% color is returned as this value.
%
*/
MagickPrivate MagickBooleanType XQueryColorCompliance(const char *target,
XColor *color)
{
Colormap
colormap;
static Display
*display = (Display *) NULL;
Status
status;
XColor
xcolor;
/*
Initialize color return value.
*/
assert(color != (XColor *) NULL);
color->red=0;
color->green=0;
color->blue=0;
color->flags=(char) (DoRed | DoGreen | DoBlue);
if ((target == (char *) NULL) || (*target == '\0'))
target="#ffffffffffff";
/*
Let the X server define the color for us.
*/
if (display == (Display *) NULL)
display=XOpenDisplay((char *) NULL);
if (display == (Display *) NULL)
{
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",target);
return(MagickFalse);
}
colormap=XDefaultColormap(display,XDefaultScreen(display));
status=XParseColor(display,colormap,(char *) target,&xcolor);
if (status == False)
ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",target)
else
{
color->red=xcolor.red;
color->green=xcolor.green;
color->blue=xcolor.blue;
color->flags=xcolor.flags;
}
return(status != False ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X Q u e r y P o s i t i o n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XQueryPosition() gets the pointer coordinates relative to a window.
%
% The format of the XQueryPosition method is:
%
% void XQueryPosition(Display *display,const Window window,int *x,int *y)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a Window.
%
% o x: Return the x coordinate of the pointer relative to the origin of the
% window.
%
% o y: Return the y coordinate of the pointer relative to the origin of the
% window.
%
*/
MagickPrivate void XQueryPosition(Display *display,const Window window,int *x,
int *y)
{
int
x_root,
y_root;
unsigned int
mask;
Window
root_window;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
assert(x != (int *) NULL);
assert(y != (int *) NULL);
(void) XQueryPointer(display,window,&root_window,&root_window,&x_root,&y_root,
x,y,&mask);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X R e f r e s h W i n d o w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XRefreshWindow() refreshes an image in a X window.
%
% The format of the XRefreshWindow method is:
%
% void XRefreshWindow(Display *display,const XWindowInfo *window,
% const XEvent *event)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a XWindowInfo structure.
%
% o event: Specifies a pointer to a XEvent structure. If it is NULL,
% the entire image is refreshed.
%
*/
MagickPrivate void XRefreshWindow(Display *display,const XWindowInfo *window,
const XEvent *event)
{
int
x,
y;
unsigned int
height,
width;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (XWindowInfo *) NULL);
if (window->ximage == (XImage *) NULL)
return;
if (event != (XEvent *) NULL)
{
/*
Determine geometry from expose event.
*/
x=event->xexpose.x;
y=event->xexpose.y;
width=(unsigned int) event->xexpose.width;
height=(unsigned int) event->xexpose.height;
}
else
{
XEvent
sans_event;
/*
Refresh entire window; discard outstanding expose events.
*/
x=0;
y=0;
width=window->width;
height=window->height;
while (XCheckTypedWindowEvent(display,window->id,Expose,&sans_event)) ;
if (window->matte_pixmap != (Pixmap) NULL)
{
#if defined(MAGICKCORE_HAVE_SHAPE)
if (window->shape != MagickFalse)
XShapeCombineMask(display,window->id,ShapeBounding,0,0,
window->matte_pixmap,ShapeSet);
#endif
}
}
/*
Check boundary conditions.
*/
if ((window->ximage->width-(x+window->x)) < (int) width)
width=(unsigned int) (window->ximage->width-(x+window->x));
if ((window->ximage->height-(y+window->y)) < (int) height)
height=(unsigned int) (window->ximage->height-(y+window->y));
/*
Refresh image.
*/
if (window->matte_pixmap != (Pixmap) NULL)
(void) XSetClipMask(display,window->annotate_context,window->matte_pixmap);
if (window->pixmap != (Pixmap) NULL)
{
if (window->depth > 1)
(void) XCopyArea(display,window->pixmap,window->id,
window->annotate_context,x+window->x,y+window->y,width,height,x,y);
else
(void) XCopyPlane(display,window->pixmap,window->id,
window->highlight_context,x+window->x,y+window->y,width,height,x,y,
1L);
}
else
{
#if defined(MAGICKCORE_HAVE_SHARED_MEMORY)
if (window->shared_memory)
(void) XShmPutImage(display,window->id,window->annotate_context,
window->ximage,x+window->x,y+window->y,x,y,width,height,MagickTrue);
#endif
if (window->shared_memory == MagickFalse)
(void) XPutImage(display,window->id,window->annotate_context,
window->ximage,x+window->x,y+window->y,x,y,width,height);
}
if (window->matte_pixmap != (Pixmap) NULL)
(void) XSetClipMask(display,window->annotate_context,None);
(void) XFlush(display);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X R e m o t e C o m m a n d %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XRemoteCommand() forces a remote display(1) to display the specified
% image filename.
%
% The format of the XRemoteCommand method is:
%
% MagickBooleanType XRemoteCommand(Display *display,const char *window,
% const char *filename)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies the name or id of an X window.
%
% o filename: the name of the image filename to display.
%
*/
MagickExport MagickBooleanType XRemoteCommand(Display *display,
const char *window,const char *filename)
{
Atom
remote_atom;
Window
remote_window,
root_window;
assert(filename != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
if (display == (Display *) NULL)
display=XOpenDisplay((char *) NULL);
if (display == (Display *) NULL)
{
ThrowXWindowException(XServerError,"UnableToOpenXServer",filename);
return(MagickFalse);
}
remote_atom=XInternAtom(display,"IM_PROTOCOLS",MagickFalse);
remote_window=(Window) NULL;
root_window=XRootWindow(display,XDefaultScreen(display));
if (window != (char *) NULL)
{
/*
Search window hierarchy and identify any clients by name or ID.
*/
if (isdigit((int) ((unsigned char) *window)) != 0)
remote_window=XWindowByID(display,root_window,(Window)
strtol((char *) window,(char **) NULL,0));
if (remote_window == (Window) NULL)
remote_window=XWindowByName(display,root_window,window);
}
if (remote_window == (Window) NULL)
remote_window=XWindowByProperty(display,root_window,remote_atom);
if (remote_window == (Window) NULL)
{
ThrowXWindowException(XServerError,"UnableToConnectToRemoteDisplay",
filename);
return(MagickFalse);
}
/*
Send remote command.
*/
remote_atom=XInternAtom(display,"IM_REMOTE_COMMAND",MagickFalse);
(void) XChangeProperty(display,remote_window,remote_atom,XA_STRING,8,
PropModeReplace,(unsigned char *) filename,(int) strlen(filename));
(void) XSync(display,MagickFalse);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X R e n d e r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XRenderImage() renders text on the image with an X11 font. It also returns
% the bounding box of the text relative to the image.
%
% The format of the XRenderImage method is:
%
% MagickBooleanType XRenderImage(Image *image,DrawInfo *draw_info,
% const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o draw_info: the draw info.
%
% o offset: (x,y) location of text relative to image.
%
% o metrics: bounding box of text.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XRenderImage(Image *image,
const DrawInfo *draw_info,const PointInfo *offset,TypeMetric *metrics,
ExceptionInfo *exception)
{
const char
*client_name;
DrawInfo
cache_info;
Display
*display;
ImageInfo
*image_info;
MagickBooleanType
status;
size_t
height,
width;
XAnnotateInfo
annotate_info;
XFontStruct
*font_info;
XPixelInfo
pixel;
XResourceInfo
resource_info;
XrmDatabase
resource_database;
XStandardColormap
*map_info;
XVisualInfo
*visual_info;
/*
Open X server connection.
*/
display=XOpenDisplay(draw_info->server_name);
if (display == (Display *) NULL)
{
ThrowXWindowException(XServerError,"UnableToOpenXServer",
draw_info->server_name);
return(MagickFalse);
}
/*
Get user defaults from X resource database.
*/
(void) XSetErrorHandler(XError);
image_info=AcquireImageInfo();
client_name=GetClientName();
resource_database=XGetResourceDatabase(display,client_name);
XGetResourceInfo(image_info,resource_database,client_name,&resource_info);
resource_info.close_server=MagickFalse;
resource_info.colormap=PrivateColormap;
resource_info.font=AcquireString(draw_info->font);
resource_info.background_color=AcquireString("#ffffffffffff");
resource_info.foreground_color=AcquireString("#000000000000");
map_info=XAllocStandardColormap();
visual_info=(XVisualInfo *) NULL;
font_info=(XFontStruct *) NULL;
pixel.pixels=(unsigned long *) NULL;
if (map_info == (XStandardColormap *) NULL)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
return(MagickFalse);
}
/*
Initialize visual info.
*/
visual_info=XBestVisualInfo(display,map_info,&resource_info);
if (visual_info == (XVisualInfo *) NULL)
{
XFreeResources(display,visual_info,map_info,&pixel,font_info,
&resource_info,(XWindowInfo *) NULL);
ThrowXWindowException(XServerError,"UnableToGetVisual",image->filename);
return(MagickFalse);
}
map_info->colormap=(Colormap) NULL;
/*
Initialize Standard Colormap info.
*/
XGetMapInfo(visual_info,XDefaultColormap(display,visual_info->screen),
map_info);
XGetPixelInfo(display,visual_info,map_info,&resource_info,(Image *) NULL,
&pixel);
pixel.annotate_context=XDefaultGC(display,visual_info->screen);
/*
Initialize font info.
*/
font_info=XBestFont(display,&resource_info,MagickFalse);
if (font_info == (XFontStruct *) NULL)
{
XFreeResources(display,visual_info,map_info,&pixel,font_info,
&resource_info,(XWindowInfo *) NULL);
ThrowXWindowException(XServerError,"UnableToLoadFont",draw_info->font);
return(MagickFalse);
}
cache_info=(*draw_info);
/*
Initialize annotate info.
*/
XGetAnnotateInfo(&annotate_info);
annotate_info.stencil=ForegroundStencil;
if (cache_info.font != draw_info->font)
{
/*
Type name has changed.
*/
(void) XFreeFont(display,font_info);
(void) CloneString(&resource_info.font,draw_info->font);
font_info=XBestFont(display,&resource_info,MagickFalse);
if (font_info == (XFontStruct *) NULL)
{
ThrowXWindowException(XServerError,"UnableToLoadFont",
draw_info->font);
return(MagickFalse);
}
}
if (image->debug != MagickFalse)
(void) LogMagickEvent(AnnotateEvent,GetMagickModule(),
"Font %s; pointsize %g",draw_info->font != (char *) NULL ?
draw_info->font : "none",draw_info->pointsize);
cache_info=(*draw_info);
annotate_info.font_info=font_info;
annotate_info.text=(char *) draw_info->text;
annotate_info.width=(unsigned int) XTextWidth(font_info,draw_info->text,(int)
strlen(draw_info->text));
annotate_info.height=(unsigned int) font_info->ascent+font_info->descent;
metrics->pixels_per_em.x=(double) font_info->max_bounds.width;
metrics->pixels_per_em.y=(double) font_info->ascent+font_info->descent;
metrics->ascent=(double) font_info->ascent+4;
metrics->descent=(double) (-font_info->descent);
metrics->width=annotate_info.width/ExpandAffine(&draw_info->affine);
metrics->height=font_info->ascent+font_info->descent;
metrics->max_advance=(double) font_info->max_bounds.width;
metrics->bounds.x1=0.0;
metrics->bounds.y1=metrics->descent;
metrics->bounds.x2=metrics->ascent+metrics->descent;
metrics->bounds.y2=metrics->ascent+metrics->descent;
metrics->underline_position=(-2.0);
metrics->underline_thickness=1.0;
if (draw_info->render == MagickFalse)
return(MagickTrue);
if (draw_info->fill.alpha == TransparentAlpha)
return(MagickTrue);
/*
Render fill color.
*/
width=annotate_info.width;
height=annotate_info.height;
if ((fabs(draw_info->affine.rx) >= MagickEpsilon) ||
(fabs(draw_info->affine.ry) >= MagickEpsilon))
{
if ((fabs(draw_info->affine.sx-draw_info->affine.sy) < MagickEpsilon) &&
(fabs(draw_info->affine.rx+draw_info->affine.ry) < MagickEpsilon))
annotate_info.degrees=(double) (180.0/MagickPI)*
atan2(draw_info->affine.rx,draw_info->affine.sx);
}
(void) FormatLocaleString(annotate_info.geometry,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) width,(double) height,
ceil(offset->x-0.5),ceil(offset->y-metrics->ascent-metrics->descent+
draw_info->interline_spacing-0.5));
pixel.pen_color.red=ScaleQuantumToShort(draw_info->fill.red);
pixel.pen_color.green=ScaleQuantumToShort(draw_info->fill.green);
pixel.pen_color.blue=ScaleQuantumToShort(draw_info->fill.blue);
status=XAnnotateImage(display,&pixel,&annotate_info,image,exception);
if (status == 0)
{
ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
return(MagickFalse);
}
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X R e t a i n W i n d o w C o l o r s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XRetainWindowColors() sets X11 color resources on a window. This preserves
% the colors associated with an image displayed on the window.
%
% The format of the XRetainWindowColors method is:
%
% void XRetainWindowColors(Display *display,const Window window)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o window: Specifies a pointer to a XWindowInfo structure.
%
*/
MagickExport void XRetainWindowColors(Display *display,const Window window)
{
Atom
property;
Pixmap
pixmap;
/*
Put property on the window.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
property=XInternAtom(display,"_XSETROOT_ID",MagickFalse);
if (property == (Atom) NULL)
{
ThrowXWindowException(XServerError,"UnableToCreateProperty",
"_XSETROOT_ID");
return;
}
pixmap=XCreatePixmap(display,window,1,1,1);
if (pixmap == (Pixmap) NULL)
{
ThrowXWindowException(XServerError,"UnableToCreateBitmap","");
return;
}
(void) XChangeProperty(display,window,property,XA_PIXMAP,32,PropModeReplace,
(unsigned char *) &pixmap,1);
(void) XSetCloseDownMode(display,RetainPermanent);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X S e l e c t W i n d o w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XSelectWindow() allows a user to select a window using the mouse. If the
% mouse moves, a cropping rectangle is drawn and the extents of the rectangle
% is returned in the crop_info structure.
%
% The format of the XSelectWindow function is:
%
% target_window=XSelectWindow(display,crop_info)
%
% A description of each parameter follows:
%
% o window: XSelectWindow returns the window id.
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o crop_info: Specifies a pointer to a RectangleInfo structure. It
% contains the extents of any cropping rectangle.
%
*/
static Window XSelectWindow(Display *display,RectangleInfo *crop_info)
{
#define MinimumCropArea (unsigned int) 9
Cursor
target_cursor;
GC
annotate_context;
int
presses,
x_offset,
y_offset;
Status
status;
Window
root_window,
target_window;
XEvent
event;
XGCValues
context_values;
/*
Initialize graphic context.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(crop_info != (RectangleInfo *) NULL);
root_window=XRootWindow(display,XDefaultScreen(display));
context_values.background=XBlackPixel(display,XDefaultScreen(display));
context_values.foreground=XWhitePixel(display,XDefaultScreen(display));
context_values.function=GXinvert;
context_values.plane_mask=
context_values.background ^ context_values.foreground;
context_values.subwindow_mode=IncludeInferiors;
annotate_context=XCreateGC(display,root_window,(size_t) (GCBackground |
GCForeground | GCFunction | GCSubwindowMode),&context_values);
if (annotate_context == (GC) NULL)
return(MagickFalse);
/*
Grab the pointer using target cursor.
*/
target_cursor=XMakeCursor(display,root_window,XDefaultColormap(display,
XDefaultScreen(display)),(char * ) "white",(char * ) "black");
status=XGrabPointer(display,root_window,MagickFalse,(unsigned int)
(ButtonPressMask | ButtonReleaseMask | ButtonMotionMask),GrabModeSync,
GrabModeAsync,root_window,target_cursor,CurrentTime);
if (status != GrabSuccess)
{
ThrowXWindowException(XServerError,"UnableToGrabMouse","");
return((Window) NULL);
}
/*
Select a window.
*/
crop_info->width=0;
crop_info->height=0;
presses=0;
target_window=(Window) NULL;
x_offset=0;
y_offset=0;
do
{
if ((crop_info->width*crop_info->height) >= MinimumCropArea)
(void) XDrawRectangle(display,root_window,annotate_context,
(int) crop_info->x,(int) crop_info->y,(unsigned int) crop_info->width-1,
(unsigned int) crop_info->height-1);
/*
Allow another event.
*/
(void) XAllowEvents(display,SyncPointer,CurrentTime);
(void) XWindowEvent(display,root_window,ButtonPressMask |
ButtonReleaseMask | ButtonMotionMask,&event);
if ((crop_info->width*crop_info->height) >= MinimumCropArea)
(void) XDrawRectangle(display,root_window,annotate_context,
(int) crop_info->x,(int) crop_info->y,(unsigned int) crop_info->width-1,
(unsigned int) crop_info->height-1);
switch (event.type)
{
case ButtonPress:
{
target_window=XGetSubwindow(display,event.xbutton.subwindow,
event.xbutton.x,event.xbutton.y);
if (target_window == (Window) NULL)
target_window=root_window;
x_offset=event.xbutton.x_root;
y_offset=event.xbutton.y_root;
crop_info->x=(ssize_t) x_offset;
crop_info->y=(ssize_t) y_offset;
crop_info->width=0;
crop_info->height=0;
presses++;
break;
}
case ButtonRelease:
{
presses--;
break;
}
case MotionNotify:
{
/*
Discard pending button motion events.
*/
while (XCheckMaskEvent(display,ButtonMotionMask,&event)) ;
crop_info->x=(ssize_t) event.xmotion.x;
crop_info->y=(ssize_t) event.xmotion.y;
/*
Check boundary conditions.
*/
if ((int) crop_info->x < x_offset)
crop_info->width=(size_t) (x_offset-crop_info->x);
else
{
crop_info->width=(size_t) (crop_info->x-x_offset);
crop_info->x=(ssize_t) x_offset;
}
if ((int) crop_info->y < y_offset)
crop_info->height=(size_t) (y_offset-crop_info->y);
else
{
crop_info->height=(size_t) (crop_info->y-y_offset);
crop_info->y=(ssize_t) y_offset;
}
}
default:
break;
}
} while ((target_window == (Window) NULL) || (presses > 0));
(void) XUngrabPointer(display,CurrentTime);
(void) XFreeCursor(display,target_cursor);
(void) XFreeGC(display,annotate_context);
if ((crop_info->width*crop_info->height) < MinimumCropArea)
{
crop_info->width=0;
crop_info->height=0;
}
if ((crop_info->width != 0) && (crop_info->height != 0))
target_window=root_window;
return(target_window);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X S e t C u r s o r S t a t e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XSetCursorState() sets the cursor state to busy, otherwise the cursor are
% reset to their default.
%
% The format of the XXSetCursorState method is:
%
% XSetCursorState(display,windows,const MagickStatusType state)
%
% A description of each parameter follows:
%
% o display: Specifies a connection to an X server; returned from
% XOpenDisplay.
%
% o windows: Specifies a pointer to a XWindows structure.
%
% o state: An unsigned integer greater than 0 sets the cursor state
% to busy, otherwise the cursor are reset to their default.
%
*/
MagickPrivate void XSetCursorState(Display *display,XWindows *windows,
const MagickStatusType state)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(windows != (XWindows *) NULL);
if (state)
{
(void) XCheckDefineCursor(display,windows->image.id,
windows->image.busy_cursor);
(void) XCheckDefineCursor(display,windows->pan.id,
windows->pan.busy_cursor);
(void) XCheckDefineCursor(display,windows->magnify.id,
windows->magnify.busy_cursor);
(void) XCheckDefineCursor(display,windows->command.id,
windows->command.busy_cursor);
}
else
{
(void) XCheckDefineCursor(display,windows->image.id,
windows->image.cursor);
(void) XCheckDefineCursor(display,windows->pan.id,windows->pan.cursor);
(void) XCheckDefineCursor(display,windows->magnify.id,
windows->magnify.cursor);
(void) XCheckDefineCursor(display,windows->command.id,
windows->command.cursor);
(void) XCheckDefineCursor(display,windows->command.id,
windows->widget.cursor);
(void) XWithdrawWindow(display,windows->info.id,windows->info.screen);
}
windows->info.mapped=MagickFalse;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X S e t W i n d o w s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XSetWindows() sets the X windows structure if the windows info is specified.
% Otherwise the current windows structure is returned.
%
% The format of the XSetWindows method is:
%
% XWindows *XSetWindows(XWindows *windows_info)
%
% A description of each parameter follows:
%
% o windows_info: Initialize the Windows structure with this information.
%
*/
MagickPrivate XWindows *XSetWindows(XWindows *windows_info)
{
static XWindows
*windows = (XWindows *) NULL;
if (windows_info != (XWindows *) ~0)
{
windows=(XWindows *) RelinquishMagickMemory(windows);
windows=windows_info;
}
return(windows);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X U s e r P r e f e r e n c e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XUserPreferences() saves the preferences in a configuration file in the
% users' home directory.
%
% The format of the XUserPreferences method is:
%
% void XUserPreferences(XResourceInfo *resource_info)
%
% A description of each parameter follows:
%
% o resource_info: Specifies a pointer to a X11 XResourceInfo structure.
%
*/
MagickPrivate void XUserPreferences(XResourceInfo *resource_info)
{
#if defined(X11_PREFERENCES_PATH)
char
cache[MagickPathExtent],
filename[MagickPathExtent],
specifier[MagickPathExtent];
const char
*client_name,
*value;
XrmDatabase
preferences_database;
/*
Save user preferences to the client configuration file.
*/
assert(resource_info != (XResourceInfo *) NULL);
client_name=GetClientName();
preferences_database=XrmGetStringDatabase("");
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.backdrop",client_name);
value=resource_info->backdrop ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.colormap",client_name);
value=resource_info->colormap == SharedColormap ? "Shared" : "Private";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.confirmExit",
client_name);
value=resource_info->confirm_exit ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.confirmEdit",
client_name);
value=resource_info->confirm_edit ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.displayWarnings",
client_name);
value=resource_info->display_warnings ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.dither",client_name);
value=resource_info->quantize_info->dither_method != NoDitherMethod ?
"True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.gammaCorrect",
client_name);
value=resource_info->gamma_correct ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.undoCache",client_name);
(void) FormatLocaleString(cache,MagickPathExtent,"%.20g",(double)
resource_info->undo_cache);
XrmPutStringResource(&preferences_database,specifier,cache);
(void) FormatLocaleString(specifier,MagickPathExtent,"%s.usePixmap",client_name);
value=resource_info->use_pixmap ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(filename,MagickPathExtent,"%s%src",
X11_PREFERENCES_PATH,client_name);
ExpandFilename(filename);
XrmPutFileDatabase(preferences_database,filename);
#endif
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X V i s u a l C l a s s N a m e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XVisualClassName() returns the visual class name as a character string.
%
% The format of the XVisualClassName method is:
%
% char *XVisualClassName(const int visual_class)
%
% A description of each parameter follows:
%
% o visual_type: XVisualClassName returns the visual class as a character
% string.
%
% o class: Specifies the visual class.
%
*/
static const char *XVisualClassName(const int visual_class)
{
switch (visual_class)
{
case StaticGray: return("StaticGray");
case GrayScale: return("GrayScale");
case StaticColor: return("StaticColor");
case PseudoColor: return("PseudoColor");
case TrueColor: return("TrueColor");
case DirectColor: return("DirectColor");
}
return("unknown visual class");
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X W a r n i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XWarning() displays a warning reason in a Notice widget.
%
% The format of the XWarning method is:
%
% void XWarning(const unsigned int warning,const char *reason,
% const char *description)
%
% A description of each parameter follows:
%
% o warning: Specifies the numeric warning category.
%
% o reason: Specifies the reason to display before terminating the
% program.
%
% o description: Specifies any description to the reason.
%
*/
MagickPrivate void XWarning(const ExceptionType magick_unused(warning),
const char *reason,const char *description)
{
char
text[MagickPathExtent];
XWindows
*windows;
if (reason == (char *) NULL)
return;
(void) CopyMagickString(text,reason,MagickPathExtent);
(void) ConcatenateMagickString(text,":",MagickPathExtent);
windows=XSetWindows((XWindows *) ~0);
XNoticeWidget(windows->display,windows,text,(char *) description);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X W i n d o w B y I D %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XWindowByID() locates a child window with a given ID. If not window with
% the given name is found, 0 is returned. Only the window specified and its
% subwindows are searched.
%
% The format of the XWindowByID function is:
%
% child=XWindowByID(display,window,id)
%
% A description of each parameter follows:
%
% o child: XWindowByID returns the window with the specified
% id. If no windows are found, XWindowByID returns 0.
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o id: Specifies the id of the window to locate.
%
*/
MagickPrivate Window XWindowByID(Display *display,const Window root_window,
const size_t id)
{
RectangleInfo
rectangle_info;
register int
i;
Status
status;
unsigned int
number_children;
Window
child,
*children,
window;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(root_window != (Window) NULL);
if (id == 0)
return(XSelectWindow(display,&rectangle_info));
if (root_window == id)
return(root_window);
status=XQueryTree(display,root_window,&child,&child,&children,
&number_children);
if (status == False)
return((Window) NULL);
window=(Window) NULL;
for (i=0; i < (int) number_children; i++)
{
/*
Search each child and their children.
*/
window=XWindowByID(display,children[i],id);
if (window != (Window) NULL)
break;
}
if (children != (Window *) NULL)
(void) XFree((void *) children);
return(window);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X W i n d o w B y N a m e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XWindowByName() locates a window with a given name on a display. If no
% window with the given name is found, 0 is returned. If more than one window
% has the given name, the first one is returned. Only root and its children
% are searched.
%
% The format of the XWindowByName function is:
%
% window=XWindowByName(display,root_window,name)
%
% A description of each parameter follows:
%
% o window: XWindowByName returns the window id.
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o root_window: Specifies the id of the root window.
%
% o name: Specifies the name of the window to locate.
%
*/
MagickPrivate Window XWindowByName(Display *display,const Window root_window,
const char *name)
{
register int
i;
Status
status;
unsigned int
number_children;
Window
*children,
child,
window;
XTextProperty
window_name;
assert(display != (Display *) NULL);
assert(root_window != (Window) NULL);
assert(name != (char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
if (XGetWMName(display,root_window,&window_name) != 0)
if (LocaleCompare((char *) window_name.value,name) == 0)
return(root_window);
status=XQueryTree(display,root_window,&child,&child,&children,
&number_children);
if (status == False)
return((Window) NULL);
window=(Window) NULL;
for (i=0; i < (int) number_children; i++)
{
/*
Search each child and their children.
*/
window=XWindowByName(display,children[i],name);
if (window != (Window) NULL)
break;
}
if (children != (Window *) NULL)
(void) XFree((void *) children);
return(window);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X W i n d o w B y P r o p e r y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XWindowByProperty() locates a child window with a given property. If not
% window with the given name is found, 0 is returned. If more than one window
% has the given property, the first one is returned. Only the window
% specified and its subwindows are searched.
%
% The format of the XWindowByProperty function is:
%
% child=XWindowByProperty(display,window,property)
%
% A description of each parameter follows:
%
% o child: XWindowByProperty returns the window id with the specified
% property. If no windows are found, XWindowByProperty returns 0.
%
% o display: Specifies a pointer to the Display structure; returned from
% XOpenDisplay.
%
% o property: Specifies the property of the window to locate.
%
*/
MagickPrivate Window XWindowByProperty(Display *display,const Window window,
const Atom property)
{
Atom
type;
int
format;
Status
status;
unsigned char
*data;
unsigned int
i,
number_children;
unsigned long
after,
number_items;
Window
child,
*children,
parent,
root;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(display != (Display *) NULL);
assert(window != (Window) NULL);
assert(property != (Atom) NULL);
status=XQueryTree(display,window,&root,&parent,&children,&number_children);
if (status == False)
return((Window) NULL);
type=(Atom) NULL;
child=(Window) NULL;
for (i=0; (i < number_children) && (child == (Window) NULL); i++)
{
status=XGetWindowProperty(display,children[i],property,0L,0L,MagickFalse,
(Atom) AnyPropertyType,&type,&format,&number_items,&after,&data);
if (data != NULL)
(void) XFree((void *) data);
if ((status == Success) && (type != (Atom) NULL))
child=children[i];
}
for (i=0; (i < number_children) && (child == (Window) NULL); i++)
child=XWindowByProperty(display,children[i],property);
if (children != (Window *) NULL)
(void) XFree((void *) children);
return(child);
}
#else
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X I m p o r t I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XImportImage() reads an image from an X window.
%
% The format of the XImportImage method is:
%
% Image *XImportImage(const ImageInfo *image_info,XImportInfo *ximage_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info..
%
% o ximage_info: Specifies a pointer to an XImportInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *XImportImage(const ImageInfo *image_info,
XImportInfo *ximage_info,ExceptionInfo *exception)
{
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(ximage_info != (XImportInfo *) NULL);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
return((Image *) NULL);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X R e n d e r X 1 1 %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XRenderImage() renders text on the image with an X11 font. It also returns
% the bounding box of the text relative to the image.
%
% The format of the XRenderImage method is:
%
% MagickBooleanType XRenderImage(Image *image,DrawInfo *draw_info,
% const PointInfo *offset,TypeMetric *metrics,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o draw_info: the draw info.
%
% o offset: (x,y) location of text relative to image.
%
% o metrics: bounding box of text.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickPrivate MagickBooleanType XRenderImage(Image *image,
const DrawInfo *draw_info,const PointInfo *offset,TypeMetric *metrics,
ExceptionInfo *exception)
{
(void) draw_info;
(void) offset;
(void) metrics;
(void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","'%s' (X11)",
image->filename);
return(MagickFalse);
}
#endif
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ X C o m p o n e n t G e n e s i s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XComponentGenesis() instantiates the X component.
%
% The format of the XComponentGenesis method is:
%
% MagickBooleanType XComponentGenesis(void)
%
*/
MagickPrivate MagickBooleanType XComponentGenesis(void)
{
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% X G e t I m p o r t I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% XGetImportInfo() initializes the XImportInfo structure.
%
% The format of the XGetImportInfo method is:
%
% void XGetImportInfo(XImportInfo *ximage_info)
%
% A description of each parameter follows:
%
% o ximage_info: Specifies a pointer to an ImageInfo structure.
%
*/
MagickExport void XGetImportInfo(XImportInfo *ximage_info)
{
assert(ximage_info != (XImportInfo *) NULL);
ximage_info->frame=MagickFalse;
ximage_info->borders=MagickFalse;
ximage_info->screen=MagickFalse;
ximage_info->descend=MagickTrue;
ximage_info->silent=MagickFalse;
}