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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
#include "config.h"
#include <string.h>
#include <stdlib.h>
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
/****h* libAfterImage/tutorials/ASTile
* NAME
* ASTile
* SYNOPSIS
* Simple program based on libAfterImage to tile and tint image.
* DESCRIPTION
* All we want to do here is to get image filename, tint color and
* desired geometry from the command line. We then load this image, and
* proceed on to tiling it based on parameters. Tiling geometry
* specifies rectangular shape on limitless plane on which original
* image is tiled. While we are at tiling the image we also tint it to
* specified color, or to some random value derived from the current
* time in seconds elapsed since 1971.
* We then display the result in simple window.
* After that we would want to wait, until user closes our window.
*
* In this tutorial we will only explain new steps, not described in
* previous tutorial. New steps described in this tutorial are :
* ASTile.1. Parsing ARGB32 tinting color.
* ASTile.2. Parsing geometry spec.
* ASTile.3. Tiling and tinting ASImage.
* SEE ALSO
* ASView - explanation of basic steps needed to use libAfterImage and
* some other simple things.
* SOURCE
*/
#include "../afterbase.h"
#include "../afterimage.h"
#include "common.h"
void usage()
{
printf( "Usage: astile [-h]|[[-g geometry][-t tint_color] image]\n");
printf( "Where: image - source image filename.\n");
printf( " geometry - width and height of the resulting image,\n");
printf( " and x, y of the origin of the tiling on "
"source image.\n");
printf( " tint_color - color to tint image with.( defaults to "
"current time :)\n");
}
int main(int argc, char* argv[])
{
Window w ;
Display *dpy = NULL;
ASVisual *asv ;
int screen = 0, depth = 0;
char *image_file = "rose512.jpg" ;
ARGB32 tint_color = time(NULL);
int tile_x, tile_y, geom_flags = 0;
unsigned int tile_width, tile_height ;
ASImage *im ;
/* see ASView.1 : */
set_application_name( argv[0] );
#ifndef X_DISPLAY_MISSING
/* parse_argb_color can only be used after display is open,
otherwise we are limited to colors defined as ARGB values : */
dpy = XOpenDisplay(NULL);
_XA_WM_DELETE_WINDOW = XInternAtom( dpy, "WM_DELETE_WINDOW", False);
screen = DefaultScreen(dpy);
depth = DefaultDepth( dpy, screen );
#endif
if( argc > 1 )
{
int i ;
if( strncmp( argv[1], "-h", 2 ) == 0 )
{
usage();
return 0;
}
for( i = 1 ; i < argc ; i++ )
{
if( argv[i][0] == '-' && i < argc-1 )
{
switch(argv[i][1])
{
case 't' : /* see ASTile.1 : */
if( parse_argb_color( argv[i+1], &tint_color ) ==
argv[i+1] )
show_warning( "unable to parse tint color - "
"default used: #%8.8lX",
(unsigned long)tint_color );
break ;
case 'g' : /* see ASTile.2 : */
geom_flags = XParseGeometry( argv[i+1],
&tile_x, &tile_y,
&tile_width,
&tile_height );
break ;
}
++i ;
}else
image_file = argv[i] ;
}
}else
{
show_warning( "no image file or tint color specified - "
"defaults used: \"%s\" #%8.8lX",
image_file, (unsigned long)tint_color );
usage();
}
/* see ASView.2 : */
im = file2ASImage( image_file, 0xFFFFFFFF, SCREEN_GAMMA, 0, getenv("IMAGE_PATH"), NULL );
/* Making sure tiling geometry is sane : */
if( !get_flags(geom_flags, XValue ) )
tile_x = im->width/2 ;
if( !get_flags(geom_flags, YValue ) )
tile_y = im->height/2 ;
if( !get_flags(geom_flags, WidthValue ) )
tile_width = im->width*2 ;
if( !get_flags(geom_flags, HeightValue ) )
tile_height = im->height*2;
printf( "%s: tiling image \"%s\" to "
"%dx%d%+d%+d tinting with #%8.8lX\n",
get_application_name(), image_file, tile_width, tile_height,
tile_x, tile_y, (unsigned long)tint_color );
if( im != NULL )
{
/* see ASView.3 : */
asv = create_asvisual( dpy, screen, depth, NULL );
w = None ;
#ifndef X_DISPLAY_MISSING
/* see ASView.4 : */
w = create_top_level_window( asv, DefaultRootWindow(dpy), 32, 32,
tile_width, tile_height, 1, 0, NULL,
"ASTile", image_file );
if( w != None )
{
Pixmap p ;
ASImage *tinted_im ;
XMapRaised (dpy, w);
/* see ASTile.3 : */
tinted_im = tile_asimage( asv, im, tile_x, tile_y,
tile_width, tile_height,
tint_color, ASA_XImage, 0,
ASIMAGE_QUALITY_TOP );
destroy_asimage( &im );
/* see ASView.5 : */
p = asimage2pixmap( asv, DefaultRootWindow(dpy), tinted_im,
NULL, True );
destroy_asimage( &tinted_im );
/* see common.c: set_window_background_and_free() : */
p = set_window_background_and_free( w, p );
}
/* see common.c: wait_closedown() : */
wait_closedown(w);
dpy = NULL;
#else
{
ASImage *tinted_im ;
/* see ASTile.3 : */
tinted_im = tile_asimage( asv, im, tile_x, tile_y,
tile_width, tile_height,
tint_color, ASA_ASImage, 0,
ASIMAGE_QUALITY_TOP );
destroy_asimage( &im );
/* writing result into the file */
ASImage2file( tinted_im, NULL, "astile.jpg", ASIT_Jpeg, NULL );
destroy_asimage( &tinted_im );
}
#endif
}
return 0 ;
}
/**************/
/****f* libAfterImage/tutorials/ASTile.1 [3.1]
* SYNOPSIS
* Step 1. Color parsing.
* DESCRIPTION
* libAfterImage utilizes function provided by libAfterBase for color
* parsing. In case libAfterBase is unavailable - libAfterImage
* includes its own copy of that function. This function differs from
* standard XParseColor in a way that it allows for parsing of alpha
* channel in addition to red, green and blue. It autodetects if value
* include alpha channel or not, using the following logic:
* If number of hex digits in color spec is divisible by 4 and is not
* equal to 12 then first digits are treated as alpha channel.
* In case named color is specified or now apha channel is specified
* alpha value of 0xFF will be used, marking this color as solid.
* EXAMPLE
* if( parse_argb_color( argv[i+1], &tint_color ) == argv[i+1] )
* show_warning( "unable to parse tint color - default used: #%8.8X",
* tint_color );
* NOTES
* On success parse_argb_color returns pointer to the character
* immidiately following color specification in original string.
* Therefore test for returned value to be equal to original string will
* can be used to detect error.
* SEE ALSO
* libAfterBase, parse_argb_color(), ARGB32
*******/
/****f* libAfterImage/tutorials/ASTile.2 [3.2]
* SYNOPSIS
* Step 2. Parsing the geometry.
* DESCRIPTION
* Geometry can be specified in WIDTHxHEIGHT+X+Y format. Accordingly we
* use standard X function to parse it: XParseGeometry. Returned flags
* tell us what values has been specified. We only have to fill the rest
* with some sensible defaults. Default x is width/2, y is height/2, and
* default size is same as image's width.
* EXAMPLE
* geom_flags = XParseGeometry ( argv[i+1], &tile_x, &tile_y,
* &tile_width, &tile_height );
* SEE ALSO
* ASScale.1
********/
/****f* libAfterImage/tutorials/ASTile.3 [3.3]
* SYNOPSIS
* Step 3. Actuall tiling of the image.
* DESCRIPTION
* Actuall tiling is quite simple - just call tile_asimage and it will
* generate new ASImage containing tiled and tinted image. For the sake
* of example we set quality to TOP, but normally GOOD quality is quite
* sufficient, and is a default. Again, compression is set to 0 since we
* do not intend to store image for long time. Even better we don't need
* to store it at all - all we need is XImage, so we can transfer it to
* the server easily. That is why to_xim argument is set to ASA_XImage.
* As the result obtained ASImage will not have any data in its buffers,
* but it will have ximage member set to point to valid XImage.
* Subsequently we enjoy that convenience, by setting use_cached to True
* in call to asimage2pixmap(). That ought to save us a lot of processing.
*
* Tinting works in both directions - it can increase intensity of the
* color or decrease it. If any particular channel of the tint_color is
* greater then 127 then intensity is increased, otherwise its decreased.
* EXAMPLE
* tinted_im = tile_asimage( asv, im, tile_x, tile_y,
* tile_width, tile_height,
* tint_color,
* ASA_XImage, 0, ASIMAGE_QUALITY_TOP );
* destroy_asimage( &im );
* NOTES
* SEE ALSO
* tile_asimage().
********/
|
