% MagickCore X11 Utility Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 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 %
#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/quantum-private.h"
#include "MagickCore/resource_.h"
#include "MagickCore/resize.h"
-#include "MagickCore/shear.h"
#include "MagickCore/statistic.h"
#include "MagickCore/string_.h"
#include "MagickCore/string-private.h"
#include "MagickCore/transform.h"
+#include "MagickCore/token.h"
#include "MagickCore/utility.h"
#include "MagickCore/utility-private.h"
#include "MagickCore/widget.h"
static const char
*XVisualClassName(const int);
-static MagickRealType
+static double
blue_gamma = 1.0,
green_gamma = 1.0,
red_gamma = 1.0;
x,
y;
- MagickBooleanType
- matte;
+ PixelTrait
+ alpha_trait;
Pixmap
annotate_pixmap;
- Quantum
- virtual_pixel[CompositePixelChannel];
-
unsigned int
depth,
height,
x=0;
y=0;
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
- (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
- exception);
- annotate_image->background_color.red=virtual_pixel[RedPixelChannel];
- annotate_image->background_color.green=virtual_pixel[GreenPixelChannel];
- annotate_image->background_color.blue=virtual_pixel[BluePixelChannel];
- annotate_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
+ (void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,(ssize_t) x,
+ (ssize_t) y,&annotate_image->background_color,exception);
if (annotate_info->stencil == ForegroundStencil)
- annotate_image->matte=MagickTrue;
- annotate_view=AcquireCacheView(annotate_image);
+ annotate_image->alpha_trait=BlendPixelTrait;
+ annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
for (y=0; y < (int) annotate_image->rows; y++)
{
register int
int
rotations;
- MagickRealType
+ double
normalized_degrees;
/*
Composite text onto the image.
*/
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
- matte=image->matte;
- (void) CompositeImage(image,annotate_image->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp,annotate_image,(ssize_t) x,(ssize_t) y,
- exception);
- image->matte=matte;
+ alpha_trait=image->alpha_trait;
+ (void) CompositeImage(image,annotate_image,
+ annotate_image->alpha_trait == BlendPixelTrait ? OverCompositeOp :
+ CopyCompositeOp,MagickTrue,(ssize_t) x,(ssize_t) y,exception);
+ image->alpha_trait=alpha_trait;
annotate_image=DestroyImage(annotate_image);
return(MagickTrue);
}
fontlist=(char **) AcquireQuantumMemory((size_t) fonts+1UL,sizeof(*fontlist));
if (fontlist == (char **) NULL)
{
- ThrowXWindowFatalException(ResourceLimitError,"MemoryAllocationFailed",
- font);
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",font);
return((char **) NULL);
}
p=font;
sizeof(*fontlist[i]));
if (fontlist[i] == (char *) NULL)
{
- ThrowXWindowFatalException(ResourceLimitError,"MemoryAllocationFailed",
- font);
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",font);
return((char **) NULL);
}
(void) CopyMagickString(fontlist[i],p,(size_t) (q-p+1));
fontlist=(char **) RelinquishMagickMemory(fontlist);
}
if (font_info == (XFontStruct *) NULL)
- ThrowXWindowFatalException(XServerError,"UnableToLoadFont",font_name);
+ ThrowXWindowException(XServerError,"UnableToLoadFont",font_name);
}
/*
Load fonts from list of fonts until one is found.
i,
number_sizes;
- MagickRealType
+ double
scale_factor;
unsigned int
icon_size=XAllocIconSize();
if (icon_size == (XIconSize *) NULL)
{
- ThrowXWindowFatalException(ResourceLimitError,
- "MemoryAllocationFailed",image->filename);
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
return;
}
icon_size->min_width=1;
/*
Look for an icon size that maintains the aspect ratio of image.
*/
- scale_factor=(MagickRealType) icon_size->max_width/width;
- if (scale_factor > ((MagickRealType) icon_size->max_height/height))
- scale_factor=(MagickRealType) icon_size->max_height/height;
+ 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)
{
PixelInfo
pixel;
- MagickRealType
+ double
min_distance;
- register MagickRealType
+ register double
distance;
register int
colors=(XColor *) AcquireQuantumMemory(number_colors,sizeof(*colors));
if (colors == (XColor *) NULL)
{
- ThrowXWindowFatalException(ResourceLimitError,
- "MemoryAllocationFailed","...");
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
+ "...");
return;
}
for (i=0; i < (int) number_colors; i++)
number_colors=256;
(void) XQueryColors(display,colormap,colors,(int) number_colors);
}
- min_distance=3.0*((MagickRealType) QuantumRange+1.0)*((MagickRealType)
+ 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-(MagickRealType) color->red;
+ pixel.red=colors[i].red-(double) color->red;
distance=pixel.red*pixel.red;
if (distance > min_distance)
continue;
- pixel.green=colors[i].green-(MagickRealType) color->green;
+ pixel.green=colors[i].green-(double) color->green;
distance+=pixel.green*pixel.green;
if (distance > min_distance)
continue;
- pixel.blue=colors[i].blue-(MagickRealType) color->blue;
+ pixel.blue=colors[i].blue-(double) color->blue;
distance+=pixel.blue*pixel.blue;
if (distance > min_distance)
continue;
strtol(visual_type,(char **) NULL,0);
}
else
- ThrowXWindowFatalException(XServerError,
+ ThrowXWindowException(XServerError,
"UnrecognizedVisualSpecifier",visual_type);
}
/*
/*
Failed to get visual; try using the default visual.
*/
- ThrowXWindowFatalException(XServerWarning,"UnableToGetVisual",
- visual_type);
+ 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);
- ThrowXWindowFatalException(XServerWarning,"UsingDefaultVisual",
+ ThrowXWindowException(XServerWarning,"UsingDefaultVisual",
XVisualClassName(visual_list->klass));
}
resource_info->color_recovery=MagickFalse;
*/
root_window=XRootWindow(display,XDefaultScreen(display));
status=False;
+ number_maps=0;
if (LocaleCompare(map_type,"list") != 0)
{
/*
}
if (status == False)
{
- ThrowXWindowFatalException(XServerError,"UnableToGetStandardColormap",
+ ThrowXWindowException(XServerError,"UnableToGetStandardColormap",
map_type);
return((XVisualInfo *) NULL);
}
}
if (map_info->visualid != visual_template.visualid)
{
- ThrowXWindowFatalException(XServerError,
+ ThrowXWindowException(XServerError,
"UnableToMatchVisualToStandardColormap",map_type);
return((XVisualInfo *) NULL);
}
#endif
if (map_info->colormap == (Colormap) NULL)
{
- ThrowXWindowFatalException(XServerError,
- "StandardColormapIsNotInitialized",map_type);
+ ThrowXWindowException(XServerError,"StandardColormapIsNotInitialized",
+ map_type);
return((XVisualInfo *) NULL);
}
(void) XFree((void *) map_list);
property=XInternAtom(display,"_XSETROOT_ID",MagickFalse);
if (property == (Atom) NULL)
{
- ThrowXWindowFatalException(XServerError,"UnableToCreateProperty",
+ ThrowXWindowException(XServerError,"UnableToCreateProperty",
"_XSETROOT_ID");
return;
}
*/
(void) IdentifyImage(image,file,MagickTrue,exception);
(void) fclose(file);
- text=FileToString(filename,~0,exception);
+ text=FileToString(filename,~0UL,exception);
(void) RelinquishUniqueFileResource(filename);
if (text == (char *) NULL)
{
(green_map[i][j] == (unsigned char *) NULL) ||
(blue_map[i][j] == (unsigned char *) NULL))
{
- ThrowXWindowFatalException(ResourceLimitError,
- "MemoryAllocationFailed",image->filename);
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
return;
}
}
i=0;
j=0;
q=ximage->data;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (int) image->rows; y++)
{
p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) y,image->columns,1,
break;
for (x=0; x < (int) image->columns; x++)
{
- color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
- ScaleQuantumToChar(GetPixelRed(image,p))] << 8));
- color.green=ClampToQuantum((MagickRealType) (green_map[i][j][(int)
- ScaleQuantumToChar(GetPixelGreen(image,p))] << 8));
- color.blue=ClampToQuantum((MagickRealType) (blue_map[i][j][(int)
- ScaleQuantumToChar(GetPixelBlue(image,p))] << 8));
+ 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));
x,
y;
- MagickBooleanType
- matte;
-
- Quantum
- virtual_pixel[CompositePixelChannel];
+ PixelTrait
+ alpha_trait;
Pixmap
draw_pixmap;
x=0;
y=0;
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
- (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
- exception);
- draw_image->background_color.red=virtual_pixel[RedPixelChannel];
- draw_image->background_color.green=virtual_pixel[GreenPixelChannel];
- draw_image->background_color.blue=virtual_pixel[BluePixelChannel];
- draw_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
+ (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->matte=MagickTrue;
- draw_view=AcquireCacheView(draw_image);
+ draw_image->alpha_trait=BlendPixelTrait;
+ draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
/*
Set this pixel to the background color.
*/
- SetPixelPixelInfo(draw_image,&draw_image->background_color,q);
+ SetPixelInfoPixel(draw_image,&draw_image->background_color,q);
SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
OpaqueStencil ? TransparentAlpha : OpaqueAlpha),q);
}
int
rotations;
- MagickRealType
+ double
normalized_degrees;
/*
/*
Composite text onto the image.
*/
- draw_view=AcquireCacheView(draw_image);
+ draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
draw_view=DestroyCacheView(draw_view);
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
if (draw_info->stencil == TransparentStencil)
- (void) CompositeImage(image,CopyOpacityCompositeOp,draw_image,(ssize_t) x,
- (ssize_t) y,exception);
+ (void) CompositeImage(image,draw_image,CopyAlphaCompositeOp,MagickTrue,
+ (ssize_t) x,(ssize_t) y,exception);
else
{
- matte=image->matte;
- (void) CompositeImage(image,OverCompositeOp,draw_image,(ssize_t) x,
- (ssize_t) y,exception);
- image->matte=matte;
+ 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);
Colormap
colormap;
+ extern const char
+ BorderColor[],
+ ForegroundColor[];
+
register ssize_t
i;
status=XParseColor(display,colormap,resource_info->foreground_color,
&pixel->foreground_color);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",
+ ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->foreground_color);
pixel->foreground_color.pixel=
XStandardPixel(map_info,&pixel->foreground_color);
status=XParseColor(display,colormap,resource_info->background_color,
&pixel->background_color);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",
+ ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",
resource_info->background_color);
pixel->background_color.pixel=
XStandardPixel(map_info,&pixel->background_color);
status=XParseColor(display,colormap,resource_info->border_color,
&pixel->border_color);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",
+ 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);
status=XParseColor(display,colormap,resource_info->matte_color,
&pixel->matte_color);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",
+ 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 shadow color.
*/
- pixel->shadow_color.red=(unsigned short) (((MagickRealType)
+ pixel->shadow_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(ShadowModulate))/65535L);
- pixel->shadow_color.green=(unsigned short) (((MagickRealType)
+ pixel->shadow_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(ShadowModulate))/65535L);
- pixel->shadow_color.blue=(unsigned short) (((MagickRealType)
+ 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) (((MagickRealType)
+ pixel->depth_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(DepthModulate))/65535L);
- pixel->depth_color.green=(unsigned short) (((MagickRealType)
+ pixel->depth_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(DepthModulate))/65535L);
- pixel->depth_color.blue=(unsigned short) (((MagickRealType)
+ 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) (((MagickRealType)
+ pixel->trough_color.red=(unsigned short) (((double)
pixel->matte_color.red*ScaleQuantumToShort(TroughModulate))/65535L);
- pixel->trough_color.green=(unsigned short) (((MagickRealType)
+ pixel->trough_color.green=(unsigned short) (((double)
pixel->matte_color.green*ScaleQuantumToShort(TroughModulate))/65535L);
- pixel->trough_color.blue=(unsigned short) (((MagickRealType)
+ 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);
status=XParseColor(display,colormap,resource_info->pen_colors[i],
&pixel->pen_colors[i]);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",
+ 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);
*directory,
*resource_value;
+ extern const char
+ BorderColor[],
+ ForegroundColor[];
+
/*
Initialize resource info fields.
*/
resource_info->client_name=AcquireString(client_name);
resource_value=XGetResourceClass(database,client_name,"backdrop",
(char *) "False");
- resource_info->backdrop=IsMagickTrue(resource_value);
+ 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,
if (LocaleCompare("shared",resource_value) == 0)
resource_info->colormap=SharedColormap;
if (resource_info->colormap == UndefinedColormap)
- ThrowXWindowFatalException(OptionError,"UnrecognizedColormapType",
+ ThrowXWindowException(OptionError,"UnrecognizedColormapType",
resource_value);
resource_value=XGetResourceClass(database,client_name,
"colorRecovery",(char *) "False");
- resource_info->color_recovery=IsMagickTrue(resource_value);
+ resource_info->color_recovery=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"confirmExit",
(char *) "False");
- resource_info->confirm_exit=IsMagickTrue(resource_value);
+ resource_info->confirm_exit=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"confirmEdit",
(char *) "False");
- resource_info->confirm_edit=IsMagickTrue(resource_value);
+ 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=IsMagickTrue(resource_value);
+ 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->foreground_color=XGetResourceInstance(database,client_name,
"foreground",ForegroundColor);
resource_value=XGetResourceClass(database,client_name,"gammaCorrect",
- (char *) "True");
- resource_info->gamma_correct=IsMagickTrue(resource_value);
+ (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",
"iconGeometry",(char *) NULL);
resource_value=XGetResourceClass(database,client_name,"iconic",
(char *) "False");
- resource_info->iconic=IsMagickTrue(resource_value);
+ 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=IsMagickTrue(resource_value);
+ 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->title=XGetResourceClass(database,client_name,"title",
(char *) NULL);
resource_value=XGetResourceClass(database,client_name,"undoCache",
- (char *) "16");
+ (char *) "256");
resource_info->undo_cache=(unsigned int) StringToUnsignedLong(resource_value);
resource_value=XGetResourceClass(database,client_name,"update",
(char *) "False");
- resource_info->update=IsMagickTrue(resource_value);
+ resource_info->update=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"usePixmap",
(char *) "True");
- resource_info->use_pixmap=IsMagickTrue(resource_value);
+ resource_info->use_pixmap=IsStringTrue(resource_value);
resource_value=XGetResourceClass(database,client_name,"sharedMemory",
(char *) "True");
- resource_info->use_shared_memory=IsMagickTrue(resource_value);
+ 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,
Match color against the color database.
*/
(void) XQueryColor(display,window_attributes.colormap,&color);
- pixel.red=ScaleShortToQuantum(color.red);
- pixel.green=ScaleShortToQuantum(color.green);
- pixel.blue=ScaleShortToQuantum(color.blue);
+ 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);
}
if (window_info == (WindowInfo *) NULL)
{
- ThrowXWindowFatalException(ResourceLimitError,
- "MemoryAllocationFailed","...");
+ ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed","...");
return((Image *) NULL);
}
id=number_windows++;
(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.x1 >= window_info[i].bounds.x2) ||
- (window_info[id].bounds.y1 <= window_info[i].bounds.y1) ||
- (window_info[id].bounds.y1 >= window_info[i].bounds.y2))
+ 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.
/*
Does target window intersect top level window?
*/
- import=
- ((window_info[id].bounds.x2 >= window_info[0].bounds.x1) &&
+ 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)) ?
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.x1 >= window_info[j].bounds.x2) ||
- (window_info[id].bounds.y1 <= window_info[j].bounds.y1) ||
- (window_info[id].bounds.y1 >= window_info[j].bounds.y2))
- import=MagickFalse;
+ 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;
}
- else
- if ((window_info[id].visual != window_info[j].visual) ||
- (window_info[id].colormap != window_info[j].colormap))
- {
- if ((window_info[id].bounds.x2 > window_info[j].bounds.x1) &&
- (window_info[id].bounds.x1 < window_info[j].bounds.x2) &&
- (window_info[id].bounds.y2 > window_info[j].bounds.y1) &&
- (window_info[id].bounds.y1 < window_info[j].bounds.y2))
- import=MagickTrue;
- }
if (import == MagickFalse)
continue;
/*
composite_image->storage_class=PseudoClass;
composite_image->columns=(size_t) ximage->width;
composite_image->rows=(size_t) ximage->height;
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireAuthenticCacheView(composite_image,exception);
switch (composite_image->storage_class)
{
case DirectClass:
{
pixel=XGetPixel(ximage,x,y);
color=(pixel >> red_shift) & red_mask;
- color=(65535UL*color)/red_mask;
- SetPixelRed(composite_image,
- ScaleShortToQuantum((unsigned short) color),q);
+ if (red_mask != 0)
+ color=(65535UL*color)/red_mask;
+ SetPixelRed(composite_image,ScaleShortToQuantum(
+ (unsigned short) color),q);
color=(pixel >> green_shift) & green_mask;
- color=(65535UL*color)/green_mask;
- SetPixelGreen(composite_image,
- ScaleShortToQuantum((unsigned short) color),q);
+ if (green_mask != 0)
+ color=(65535UL*color)/green_mask;
+ SetPixelGreen(composite_image,ScaleShortToQuantum(
+ (unsigned short) color),q);
color=(pixel >> blue_shift) & blue_mask;
- color=(65535UL*color)/blue_mask;
- SetPixelBlue(composite_image,
- ScaleShortToQuantum((unsigned short) color),q);
+ 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);
}
for (i=0; i < (int) composite_image->colors; i++)
{
- composite_image->colormap[colors[i].pixel].red=
+ composite_image->colormap[colors[i].pixel].red=(double)
ScaleShortToQuantum(colors[i].red);
- composite_image->colormap[colors[i].pixel].green=
+ composite_image->colormap[colors[i].pixel].green=(double)
ScaleShortToQuantum(colors[i].green);
- composite_image->colormap[colors[i].pixel].blue=
+ composite_image->colormap[colors[i].pixel].blue=(double)
ScaleShortToQuantum(colors[i].blue);
}
/*
{
index=(Quantum) XGetPixel(ximage,x,y);
SetPixelIndex(composite_image,index,q);
- SetPixelPixelInfo(composite_image,
+ SetPixelInfoPixel(composite_image,
composite_image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(composite_image);
}
y_offset-=(int) crop_info.y;
if (y_offset < 0)
y_offset=0;
- (void) CompositeImage(image,CopyCompositeOp,composite_image,(ssize_t)
- x_offset,(ssize_t) y_offset,exception);
+ (void) CompositeImage(image,composite_image,CopyCompositeOp,MagickTrue,
+ (ssize_t) x_offset,(ssize_t) y_offset,exception);
+ composite_image=DestroyImage(composite_image);
}
/*
Relinquish resources.
display=XOpenDisplay(image_info->server_name);
if (display == (Display *) NULL)
{
- ThrowXWindowFatalException(XServerError,"UnableToOpenXServer",
+ ThrowXWindowException(XServerError,"UnableToOpenXServer",
XDisplayName(image_info->server_name));
return((Image *) NULL);
}
/*
Select window by ID or name.
*/
- if (isdigit((unsigned char) *image_info->filename) != 0)
+ 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)
- ThrowXWindowFatalException(XServerError,
- "NoWindowWithSpecifiedIDExists",image_info->filename);
+ ThrowXWindowException(XServerError,"NoWindowWithSpecifiedIDExists",
+ image_info->filename);
}
}
/*
if (target == (Window) NULL)
target=XSelectWindow(display,&crop_info);
if (target == (Window) NULL)
- ThrowXWindowFatalException(XServerError,"UnableToReadXWindowImage",
+ ThrowXWindowException(XServerError,"UnableToReadXWindowImage",
image_info->filename);
client=target; /* obsolete */
if (target != root)
if ((ximage_info->frame == MagickFalse) &&
(prior_target != MagickFalse))
target=prior_target;
- XDelay(display,SuspendTime << 4);
}
}
if (ximage_info->screen)
status=XGetWindowAttributes(display,target,&window_attributes);
if (status == False)
{
- ThrowXWindowFatalException(XServerError,
- "UnableToReadXWindowAttributes",image_info->filename);
+ ThrowXWindowException(XServerError,"UnableToReadXWindowAttributes",
+ image_info->filename);
(void) XCloseDisplay(display);
return((Image *) NULL);
}
ximage_info->descend ? 1U : 0U,exception);
(void) XUngrabServer(display);
if (image == (Image *) NULL)
- ThrowXWindowFatalException(XServerError,"UnableToReadXWindowImage",
+ ThrowXWindowException(XServerError,"UnableToReadXWindowImage",
image_info->filename)
else
{
windows->icon_map=XAllocStandardColormap();
if ((windows->map_info == (XStandardColormap *) NULL) ||
(windows->icon_map == (XStandardColormap *) NULL))
- ThrowXWindowFatalException(ResourceLimitFatalError,
- "MemoryAllocationFailed","...");
+ ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
+ "...");
windows->map_info->colormap=(Colormap) NULL;
windows->icon_map->colormap=(Colormap) NULL;
windows->pixel_info->pixels=(unsigned long *) NULL;
windows->manager_hints=XAllocWMHints();
if ((windows->class_hints == (XClassHint *) NULL) ||
(windows->manager_hints == (XWMHints *) NULL))
- ThrowXWindowFatalException(ResourceLimitFatalError,
- "MemoryAllocationFailed","...");
+ ThrowXWindowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
+ "...");
/*
Determine group leader if we have one.
*/
windows->group_leader.id=(Window) NULL;
if (resource_info->window_group != (char *) NULL)
{
- if (isdigit((unsigned char) *resource_info->window_group) != 0)
+ 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)
scope_width,scope_height);
if ((source == (Pixmap) NULL) || (mask == (Pixmap) NULL))
{
- ThrowXWindowFatalException(XServerError,"UnableToCreatePixmap","...");
+ ThrowXWindowException(XServerError,"UnableToCreatePixmap","...");
return((Cursor) NULL);
}
(void) XParseColor(display,colormap,background_color,&background);
Resize image.
*/
resize_image=NewImageList();
- if (window->pixel_info->colors != 0)
- resize_image=SampleImage(window->image,width,height,exception);
+ 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
- resize_image=ThumbnailImage(window->image,width,height,exception);
+ {
+ 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)
if (window->shared_memory == MagickFalse)
{
if (ximage->format != XYBitmap)
- ximage->data=(char *) AcquireQuantumMemory((size_t)
- ximage->bytes_per_line,(size_t) ximage->height);
+ ximage->data=(char *) malloc((size_t) ximage->bytes_per_line*
+ ximage->height);
else
- ximage->data=(char *) AcquireQuantumMemory((size_t)
- ximage->bytes_per_line*ximage->depth,(size_t) ximage->height);
+ ximage->data=(char *) malloc((size_t) ximage->bytes_per_line*
+ ximage->depth*ximage->height);
}
if (ximage->data == (char *) NULL)
{
window->ximage=ximage;
matte_image=(XImage *) NULL;
if ((window->shape != MagickFalse) && (window->image != (Image *) NULL))
- if ((window->image->matte != MagickFalse) &&
+ if ((window->image->alpha_trait == BlendPixelTrait) &&
((int) width <= XDisplayWidth(display,window->screen)) &&
((int) height <= XDisplayHeight(display,window->screen)))
{
/*
Allocate matte image pixel data.
*/
- matte_image->data=(char *) AcquireQuantumMemory((size_t)
- matte_image->bytes_per_line*matte_image->depth,
- (size_t) matte_image->height);
+ 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);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable == MagickFalse) &&
- (image->storage_class == DirectClass) && (image->matte != MagickFalse))
+ (image->storage_class == DirectClass) && (image->alpha_trait == BlendPixelTrait))
{
char
size[MaxTextExtent];
{
canvas=CloneImage(image,0,0,MagickTrue,exception);
if (canvas != (Image *) NULL)
- (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
- exception);
+ (void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickTrue,
+ 0,0,exception);
pattern=DestroyImage(pattern);
}
}
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
- canvas_view=AcquireCacheView(canvas);
+ canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
(XPixelIntensity(&window->pixel_info->background_color) <
XPixelIntensity(&window->pixel_info->foreground_color) ? 0x80 : 0x00);
polarity=(unsigned short) ((GetPixelInfoIntensity(
- &canvas->colormap[0])) < ((Quantum) QuantumRange/2) ? 1 : 0);
+ &canvas->colormap[0])) < (QuantumRange/2) ? 1 : 0);
if (canvas->colors == 2)
polarity=GetPixelInfoIntensity(&canvas->colormap[0]) <
GetPixelInfoIntensity(&canvas->colormap[1]);
Convert to 8 bit color-mapped X canvas.
*/
if (resource_info->color_recovery &&
- resource_info->quantize_info->dither)
+ resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
register unsigned int
bytes_per_pixel;
- unsigned char
- channel[sizeof(size_t)];
-
/*
Convert to multi-byte color-mapped X canvas.
*/
pixel=pixels[(ssize_t) GetPixelIndex(canvas,p)];
for (k=0; k < (int) bytes_per_pixel; k++)
{
- channel[k]=(unsigned char) pixel;
+ *q++=(unsigned char) (pixel & 0xff);
pixel>>=8;
}
- for (k=0; k < (int) bytes_per_pixel; k++)
- *q++=channel[k];
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
Convert to contiguous 8 bit continuous-tone X canvas.
*/
if (resource_info->color_recovery &&
- resource_info->quantize_info->dither)
+ resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
}
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++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
*q++=0;
p+=GetPixelChannels(canvas);
}
}
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++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
*q++=0;
p+=GetPixelChannels(canvas);
}
register unsigned int
bytes_per_pixel;
- unsigned char
- channel[sizeof(size_t)];
-
/*
Convert to multi-byte continuous-tone X canvas.
*/
pixel=XGammaPixel(canvas,map_info,p);
for (k=0; k < (int) bytes_per_pixel; k++)
{
- channel[k]=(unsigned char) pixel;
+ *q++=(unsigned char) (pixel & 0xff);
pixel>>=8;
}
- for (k=0; k < (int) bytes_per_pixel; k++)
- *q++=channel[k];
p+=GetPixelChannels(canvas);
}
q+=scanline_pad;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
canvas=image;
if ((window->immutable != MagickFalse) &&
- (image->storage_class == DirectClass) && (image->matte != MagickFalse))
+ (image->storage_class == DirectClass) && (image->alpha_trait == BlendPixelTrait))
{
char
size[MaxTextExtent];
{
canvas=CloneImage(image,0,0,MagickTrue,exception);
if (canvas != (Image *) NULL)
- (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
- exception);
+ (void) CompositeImage(canvas,pattern,DstOverCompositeOp,MagickFalse,
+ 0,0,exception);
pattern=DestroyImage(pattern);
}
}
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
- canvas_view=AcquireCacheView(canvas);
+ canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
(XPixelIntensity(&window->pixel_info->background_color) <
XPixelIntensity(&window->pixel_info->foreground_color) ? 0x01 : 0x00);
polarity=(unsigned short) ((GetPixelInfoIntensity(
- &canvas->colormap[0])) < ((Quantum) QuantumRange/2) ? 1 : 0);
+ &canvas->colormap[0])) < (QuantumRange/2) ? 1 : 0);
if (canvas->colors == 2)
polarity=GetPixelInfoIntensity(&canvas->colormap[0]) <
GetPixelInfoIntensity(&canvas->colormap[1]);
Convert to 8 bit color-mapped X canvas.
*/
if (resource_info->color_recovery &&
- resource_info->quantize_info->dither)
+ resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
Convert to 8 bit continuous-tone X canvas.
*/
if (resource_info->color_recovery &&
- resource_info->quantize_info->dither)
+ resource_info->quantize_info->dither_method != NoDitherMethod)
{
XDitherImage(canvas,ximage,exception);
break;
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));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
p+=GetPixelChannels(canvas);
}
}
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));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelBlue(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelGreen(canvas,p));
+ *q++=ScaleQuantumToChar((Quantum) GetPixelRed(canvas,p));
p+=GetPixelChannels(canvas);
}
}
/*
Show center pixel color.
*/
- (void) GetOneVirtualMagickPixel(windows->image.image,TileVirtualPixelMethod,
+ (void) GetOneVirtualPixelInfo(windows->image.image,TileVirtualPixelMethod,
(ssize_t) windows->magnify.x,(ssize_t) windows->magnify.y,&pixel,exception);
(void) FormatLocaleString(tuple,MaxTextExtent,"%d,%d: ",
windows->magnify.x,windows->magnify.y);
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,BlackPixelChannel,X11Compliance,tuple);
}
- if (pixel.matte != MagickFalse)
+ if (pixel.alpha_trait == BlendPixelTrait)
{
(void) ConcatenateMagickString(tuple,",",MaxTextExtent);
ConcatenateColorComponent(&pixel,AlphaPixelChannel,X11Compliance,tuple);
extern "C" {
#endif
-static inline MagickRealType DiversityPixelIntensity(
+static inline double DiversityPixelIntensity(
const DiversityPacket *pixel)
{
- MagickRealType
+ double
intensity;
- intensity=0.299*pixel->red+0.587*pixel->green+0.114*pixel->blue;
+ intensity=0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
return(intensity);
}
static inline Quantum ScaleXToQuantum(const size_t x,
const size_t scale)
{
- return((Quantum) (((MagickRealType) QuantumRange*x)/scale+0.5));
+ return((Quantum) (((double) QuantumRange*x)/scale+0.5));
}
MagickPrivate void XMakeStandardColormap(Display *display,
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->matte == MagickFalse) &&
+ if ((image->alpha_trait != BlendPixelTrait) &&
(resource_info->color_recovery == MagickFalse) &&
- resource_info->quantize_info->dither &&
+ (resource_info->quantize_info->dither_method != NoDitherMethod) &&
(number_colors < MaxColormapSize))
{
Image
{
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);
+ 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);
+ 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);
+ 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);
"UnableToCreateColormap",image->filename);
for (i=0; i < (ssize_t) image->colors; i++)
{
- diversity[i].red=image->colormap[i].red;
- diversity[i].green=image->colormap[i].green;
- diversity[i].blue=image->colormap[i].blue;
+ 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=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (int) image->rows; y++)
{
register int
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));
+ 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);
display=XOpenDisplay((char *) NULL);
if (display == (Display *) NULL)
{
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",target);
+ ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",target);
return(MagickFalse);
}
colormap=XDefaultColormap(display,XDefaultScreen(display));
status=XParseColor(display,colormap,(char *) target,&xcolor);
if (status == False)
- ThrowXWindowFatalException(XServerError,"ColorIsNotKnownToServer",target)
+ ThrowXWindowException(XServerError,"ColorIsNotKnownToServer",target)
else
{
color->red=xcolor.red;
% window.
%
*/
-MagickPrivate void XQueryPosition(Display *display,const Window window,int *x,int *y)
+MagickPrivate void XQueryPosition(Display *display,const Window window,int *x,
+ int *y)
{
int
x_root,
/*
Search window hierarchy and identify any clients by name or ID.
*/
- if (isdigit((unsigned char) *window) != 0)
+ 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)
% %
% %
% %
+% 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();
+ 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)
+ {
+ ThrowXWindowException(XServerError,"UnableToGetVisual",image->filename);
+ return(MagickFalse);
+ }
+ map_info->colormap=(Colormap) NULL;
+ pixel.pixels=(unsigned long *) 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)
+ {
+ ThrowXWindowException(XServerError,"UnableToLoadFont",draw_info->font);
+ return(MagickFalse);
+ }
+ if ((map_info == (XStandardColormap *) NULL) ||
+ (visual_info == (XVisualInfo *) NULL) ||
+ (font_info == (XFontStruct *) NULL))
+ {
+ XFreeResources(display,visual_info,map_info,&pixel,font_info,
+ &resource_info,(XWindowInfo *) NULL);
+ ThrowXWindowException(XServerError,"UnableToLoadFont",image->filename);
+ 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,MaxTextExtent,
+ "%.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);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% X R e t a i n W i n d o w C o l o r s %
% %
% %
property=XInternAtom(display,"_XSETROOT_ID",MagickFalse);
if (property == (Atom) NULL)
{
- ThrowXWindowFatalException(XServerError,"UnableToCreateProperty",
+ ThrowXWindowException(XServerError,"UnableToCreateProperty",
"_XSETROOT_ID");
return;
}
pixmap=XCreatePixmap(display,window,1,1,1);
if (pixmap == (Pixmap) NULL)
{
- ThrowXWindowFatalException(XServerError,"UnableToCreateBitmap","");
+ ThrowXWindowException(XServerError,"UnableToCreateBitmap","");
return;
}
(void) XChangeProperty(display,window,property,XA_PIXMAP,32,PropModeReplace,
GrabModeAsync,root_window,target_cursor,CurrentTime);
if (status != GrabSuccess)
{
- ThrowXWindowFatalException(XServerError,"UnableToGrabMouse","");
+ ThrowXWindowException(XServerError,"UnableToGrabMouse","");
return((Window) NULL);
}
/*
value=resource_info->display_warnings ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MaxTextExtent,"%s.dither",client_name);
- value=resource_info->quantize_info->dither ? "True" : "False";
+ value=resource_info->quantize_info->dither_method != NoDitherMethod ?
+ "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatLocaleString(specifier,MaxTextExtent,"%s.gammaCorrect",
client_name);
%
% The format of the XImportImage method is:
%
-% Image *XImportImage(const ImageInfo *image_info,XImportInfo *ximage_info)
+% Image *XImportImage(const ImageInfo *image_info,XImportInfo *ximage_info,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o ximage_info: Specifies a pointer to an XImportInfo structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickPrivate Image *XImportImage(const ImageInfo *image_info,
- XImportInfo *ximage_info)
+MagickExport Image *XImportImage(const ImageInfo *image_info,
+ XImportInfo *ximage_info,ExceptionInfo *exception)
{
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(ximage_info != (XImportInfo *) NULL);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
return((Image *) NULL);
}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% 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
\f
/*
projects / imagemagick / blobdiff