summaryrefslogtreecommitdiff
path: root/dmagick/c/deprecate.d
blob: 5060a9645343ad9aabdd48ee37e160f9da24e296 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
module dmagick.c.deprecate;

import core.vararg;
import core.stdc.stdio;
import core.sys.posix.sys.types;

import dmagick.c.cacheView;
import dmagick.c.colorspace;
import dmagick.c.constitute;
import dmagick.c.draw;
import dmagick.c.exception;
import dmagick.c.geometry;
import dmagick.c.image;
import dmagick.c.magickType;
import dmagick.c.pixel;
import dmagick.c.quantize;
import dmagick.c.quantum;
import dmagick.c.registry;
import dmagick.c.resample;
import dmagick.c.semaphore;

deprecated extern(C)
{
	enum MagickLayerMethod
	{
		UndefinedMagickLayerMethod
	}

	alias MagickOffsetType ExtendedSignedIntegralType;
	alias MagickSizeType   ExtendedUnsignedIntegralType;
	alias MagickRealType   ExtendedRationalType;

	struct ViewInfo {}

	alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, ExceptionInfo*) MonitorHandler;

	struct ImageAttribute
	{
		char*
			key,
			value;

		MagickBooleanType
			compression;

		ImageAttribute*
			previous,
			next;
	}

	CacheView* CloseCacheView(CacheView*);
	CacheView* OpenCacheView(const Image*);

	char* AllocateString(const char*);
	char* InterpretImageAttributes(const ImageInfo*, Image*, const char*);
	char* PostscriptGeometry(const char*);
	char* TranslateText(const ImageInfo *,Image *,const char *);

	const(ImageAttribute)* GetImageAttribute(const Image*, const char*);
	const(ImageAttribute)* GetImageClippingPathAttribute(Image*);
	const(ImageAttribute)* GetNextImageAttribute(const Image*);

	const(IndexPacket)* AcquireCacheViewIndexes(const CacheView*);
	const(IndexPacket)* AcquireIndexes(const Image*);

	const(PixelPacket)* AcquirePixels(const Image*);
	const(PixelPacket)* AcquireCacheViewPixels(const CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);
	const(PixelPacket)* AcquireImagePixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*);

	Image* AllocateImage(const ImageInfo*);
	Image* AverageImages(const Image*, ExceptionInfo*);
	Image* ExtractSubimageFromImage(Image*, const Image*, ExceptionInfo*);
	Image* GetImageFromMagickRegistry(const char*, ssize_t* id, ExceptionInfo*);
	Image* GetImageList(const Image*, const ssize_t, ExceptionInfo*);
	Image* GetNextImage(const Image*);
	Image* GetPreviousImage(const Image*);
	Image* FlattenImages(Image*, ExceptionInfo*);
	Image* MaximumImages(const Image*, ExceptionInfo*);
	Image* MinimumImages(const Image*, ExceptionInfo*);
	Image* MosaicImages(Image*, ExceptionInfo*);
	Image* PopImageList(Image**);
	Image* RecolorImage(const Image*, const size_t, const double*, ExceptionInfo*);
	Image* ShiftImageList(Image**);
	Image* SpliceImageList(Image*, const ssize_t, const size_t, const Image*, ExceptionInfo*);
	Image* ZoomImage(const Image*, const size_t, const size_t, ExceptionInfo*);

	IndexPacket* GetCacheViewIndexes(CacheView*);
	IndexPacket* GetIndexes(const Image*);
	IndexPacket  ValidateColormapIndex(Image*, const size_t);

	int GetImageGeometry(Image*, const char*, const uint, RectangleInfo*);
	int ParseImageGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);

	ssize_t GetImageListIndex(const Image*);
	ssize_t SetMagickRegistry(const RegistryType, const void*, const size_t, ExceptionInfo*);

	MagickBooleanType AcquireOneCacheViewPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
	MagickBooleanType AcquireOneCacheViewVirtualPixel(const CacheView*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*);
	MagickBooleanType AffinityImage(const QuantizeInfo*, Image*, const Image*);
	MagickBooleanType AffinityImages(const QuantizeInfo*, Image*, const Image*);
	MagickBooleanType AllocateImageColormap(Image*, const size_t);
	MagickBooleanType ClipPathImage(Image*, const char*, const MagickBooleanType);
	MagickBooleanType CloneImageAttributes(Image*, const Image*);
	MagickBooleanType ColorFloodfillImage(Image*, const DrawInfo*, const PixelPacket, const ssize_t, const ssize_t, const PaintMethod);
	MagickBooleanType DeleteImageAttribute(Image*, const char*);
	MagickBooleanType DeleteMagickRegistry(const ssize_t);
	MagickBooleanType DescribeImage(Image*, FILE*, const MagickBooleanType);
	MagickBooleanType FormatImageAttribute(Image*, const char*, const char*, ...);
	MagickBooleanType FormatImageAttributeList(Image*, const char*, const char*, va_list);
	MagickBooleanType FuzzyColorCompare(const Image*, const PixelPacket*, const PixelPacket*);
	MagickBooleanType FuzzyOpacityCompare(const Image*, const PixelPacket*, const PixelPacket*);
	MagickBooleanType LevelImageColors(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType);
	MagickBooleanType MagickMonitor(const char*, const MagickOffsetType, const MagickSizeType, void*);
	MagickBooleanType MapImage(Image*, const Image*, const MagickBooleanType);
	MagickBooleanType MapImages(Image*, const Image*, const MagickBooleanType);
	MagickBooleanType MatteFloodfillImage(Image*, const PixelPacket, const Quantum, const ssize_t, const ssize_t, const PaintMethod);
	MagickBooleanType OpaqueImage(Image*, const PixelPacket, const PixelPacket);
	MagickBooleanType PaintFloodfillImage(Image*, const ChannelType, const MagickPixelPacket*, const ssize_t, const ssize_t, const DrawInfo*, const PaintMethod);
	MagickBooleanType PaintOpaqueImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*);
	MagickBooleanType PaintOpaqueImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*);
	MagickBooleanType PaintTransparentImage(Image*, const MagickPixelPacket*, const Quantum);
	MagickBooleanType SetExceptionInfo(ExceptionInfo*, ExceptionType);
	MagickBooleanType SetImageAttribute(Image*, const char*, const char*);
	MagickBooleanType SyncCacheViewPixels(CacheView*);
	MagickBooleanType SyncImagePixels(Image*);
	MagickBooleanType TransparentImage(Image*, const PixelPacket, const Quantum);

	MagickPixelPacket AcquireOneMagickPixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*);

	MonitorHandler GetMonitorHandler();
	MonitorHandler SetMonitorHandler(MonitorHandler);

	MagickOffsetType SizeBlob(Image* image);

	MagickPixelPacket InterpolatePixelColor(const Image*, CacheView*, const InterpolatePixelMethod, const double, const double, ExceptionInfo*);

	MagickStatusType ParseSizeGeometry(const Image*, const char*, RectangleInfo*);

	PixelPacket  AcquireOnePixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*);
	PixelPacket  AcquireOneVirtualPixel(const Image*, const VirtualPixelMethod, const ssize_t, const ssize_t, ExceptionInfo*);
	PixelPacket* GetCacheView(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
	PixelPacket* GetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
	PixelPacket* GetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t);
	PixelPacket  GetOnePixel(Image*, const ssize_t, const ssize_t);
	PixelPacket* GetPixels(const Image*);
	PixelPacket* SetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t);
	PixelPacket* SetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t);

	size_t GetImageListSize(const Image*);
	size_t PopImagePixels(Image*, const QuantumType, ubyte*);
	size_t PushImagePixels(Image*, const QuantumType, const byte*);

	uint ChannelImage(Image*, const ChannelType);
	uint ChannelThresholdImage(Image*, const char*);
	uint DispatchImage(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, void*, ExceptionInfo*);
	uint FuzzyColorMatch(const PixelPacket*, const PixelPacket*, const double);
	uint GetNumberScenes(const Image*);
	uint GetMagickGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*);
	uint IsSubimage(const char*, const uint);
	uint PushImageList(Image**, const Image*, ExceptionInfo*);
	uint QuantizationError(Image*);
	uint RandomChannelThresholdImage(Image*, const char*, const char*, ExceptionInfo*);
	uint SetImageList(Image**, const Image*, const ssize_t, ExceptionInfo*);
	uint TransformColorspace(Image*, const ColorspaceType);
	uint ThresholdImage(Image*, const double);
	uint ThresholdImageChannel(Image*, const char*);
	uint UnshiftImageList(Image**, const Image*, ExceptionInfo*);

	void* AcquireMemory(const size_t);
	void  AllocateNextImage(const ImageInfo*, Image*);
	void* CloneMemory(void*, const void*, const size_t);
	void  DestroyImageAttributes(Image*);
	void  DestroyImages(Image*);
	void  DestroyMagick();
	void  DestroyMagickRegistry();
	void* GetConfigureBlob(const char*, char*, size_t*, ExceptionInfo*);
	void* GetMagickRegistry(const ssize_t, RegistryType*, size_t*, ExceptionInfo*);
	void  IdentityAffine(AffineMatrix*);
	void  LiberateMemory(void**);
	void  LiberateSemaphoreInfo(SemaphoreInfo**);
	void  FormatString(char*, const char*, ...);
	void  FormatStringList(char*, const char*, va_list);
	void  HSLTransform(const double, const double, const double, Quantum*, Quantum*, Quantum*);
	void  InitializeMagick(const char*);
	void  MagickIncarnate(const char*);
	void  ReacquireMemory(void**, const size_t);
	void  ResetImageAttributeIterator(const Image*);
	void  SetCacheThreshold(const size_t);
	void  SetImage(Image*, const Quantum);
	void  Strip(char*);
	void  TemporaryFilename(char*);
	void  TransformHSL(const Quantum, const Quantum, const Quantum, double*, double*, double*);
}