← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/SDL/SDL_pixels.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/SDL/SDL_pixels.h
 
1
/*
 
2
  Simple DirectMedia Layer
 
3
  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
 
4
 
 
5
  This software is provided 'as-is', without any express or implied
 
6
  warranty.  In no event will the authors be held liable for any damages
 
7
  arising from the use of this software.
 
8
 
 
9
  Permission is granted to anyone to use this software for any purpose,
 
10
  including commercial applications, and to alter it and redistribute it
 
11
  freely, subject to the following restrictions:
 
12
 
 
13
  1. The origin of this software must not be misrepresented; you must not
 
14
     claim that you wrote the original software. If you use this software
 
15
     in a product, an acknowledgment in the product documentation would be
 
16
     appreciated but is not required.
 
17
  2. Altered source versions must be plainly marked as such, and must not be
 
18
     misrepresented as being the original software.
 
19
  3. This notice may not be removed or altered from any source distribution.
 
20
*/
 
21
 
 
22
/**
 
23
 *  \file SDL_pixels.h
 
24
 *  
 
25
 *  Header for the enumerated pixel format definitions.
 
26
 */
 
27
 
 
28
#ifndef _SDL_pixels_h
 
29
#define _SDL_pixels_h
 
30
 
 
31
#include "begin_code.h"
 
32
/* Set up for C function definitions, even when using C++ */
 
33
#ifdef __cplusplus
 
34
/* *INDENT-OFF* */
 
35
extern "C" {
 
36
/* *INDENT-ON* */
 
37
#endif
 
38
 
 
39
/**
 
40
 *  \name Transparency definitions
 
41
 *  
 
42
 *  These define alpha as the opacity of a surface.
 
43
 */
 
44
/*@{*/
 
45
#define SDL_ALPHA_OPAQUE 255
 
46
#define SDL_ALPHA_TRANSPARENT 0
 
47
/*@}*/
 
48
 
 
49
/** Pixel type. */
 
50
enum
 
51
{
 
52
    SDL_PIXELTYPE_UNKNOWN,
 
53
    SDL_PIXELTYPE_INDEX1,
 
54
    SDL_PIXELTYPE_INDEX4,
 
55
    SDL_PIXELTYPE_INDEX8,
 
56
    SDL_PIXELTYPE_PACKED8,
 
57
    SDL_PIXELTYPE_PACKED16,
 
58
    SDL_PIXELTYPE_PACKED32,
 
59
    SDL_PIXELTYPE_ARRAYU8,
 
60
    SDL_PIXELTYPE_ARRAYU16,
 
61
    SDL_PIXELTYPE_ARRAYU32,
 
62
    SDL_PIXELTYPE_ARRAYF16,
 
63
    SDL_PIXELTYPE_ARRAYF32
 
64
};
 
65
 
 
66
/** Bitmap pixel order, high bit -> low bit. */
 
67
enum
 
68
{
 
69
    SDL_BITMAPORDER_NONE,
 
70
    SDL_BITMAPORDER_4321,
 
71
    SDL_BITMAPORDER_1234
 
72
};
 
73
 
 
74
/** Packed component order, high bit -> low bit. */
 
75
enum
 
76
{
 
77
    SDL_PACKEDORDER_NONE,
 
78
    SDL_PACKEDORDER_XRGB,
 
79
    SDL_PACKEDORDER_RGBX,
 
80
    SDL_PACKEDORDER_ARGB,
 
81
    SDL_PACKEDORDER_RGBA,
 
82
    SDL_PACKEDORDER_XBGR,
 
83
    SDL_PACKEDORDER_BGRX,
 
84
    SDL_PACKEDORDER_ABGR,
 
85
    SDL_PACKEDORDER_BGRA
 
86
};
 
87
 
 
88
/** Array component order, low byte -> high byte. */
 
89
enum
 
90
{
 
91
    SDL_ARRAYORDER_NONE,
 
92
    SDL_ARRAYORDER_RGB,
 
93
    SDL_ARRAYORDER_RGBA,
 
94
    SDL_ARRAYORDER_ARGB,
 
95
    SDL_ARRAYORDER_BGR,
 
96
    SDL_ARRAYORDER_BGRA,
 
97
    SDL_ARRAYORDER_ABGR
 
98
};
 
99
 
 
100
/** Packed component layout. */
 
101
enum
 
102
{
 
103
    SDL_PACKEDLAYOUT_NONE,
 
104
    SDL_PACKEDLAYOUT_332,
 
105
    SDL_PACKEDLAYOUT_4444,
 
106
    SDL_PACKEDLAYOUT_1555,
 
107
    SDL_PACKEDLAYOUT_5551,
 
108
    SDL_PACKEDLAYOUT_565,
 
109
    SDL_PACKEDLAYOUT_8888,
 
110
    SDL_PACKEDLAYOUT_2101010,
 
111
    SDL_PACKEDLAYOUT_1010102
 
112
};
 
113
 
 
114
#define SDL_DEFINE_PIXELFOURCC(A, B, C, D) SDL_FOURCC(A, B, C, D)
 
115
 
 
116
#define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \
 
117
    ((1 << 31) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
 
118
     ((bits) << 8) | ((bytes) << 0))
 
119
 
 
120
#define SDL_PIXELTYPE(X)        (((X) >> 24) & 0x0F)
 
121
#define SDL_PIXELORDER(X)       (((X) >> 20) & 0x0F)
 
122
#define SDL_PIXELLAYOUT(X)      (((X) >> 16) & 0x0F)
 
123
#define SDL_BITSPERPIXEL(X)     (((X) >> 8) & 0xFF)
 
124
#define SDL_BYTESPERPIXEL(X) \
 
125
    (SDL_ISPIXELFORMAT_FOURCC(X) ? \
 
126
        ((((X) == SDL_PIXELFORMAT_YUY2) || \
 
127
          ((X) == SDL_PIXELFORMAT_UYVY) || \
 
128
          ((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
 
129
 
 
130
#define SDL_ISPIXELFORMAT_INDEXED(format)   \
 
131
    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
 
132
     ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \
 
133
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \
 
134
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)))
 
135
 
 
136
#define SDL_ISPIXELFORMAT_ALPHA(format)   \
 
137
    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
 
138
     ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \
 
139
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \
 
140
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \
 
141
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA)))
 
142
 
 
143
#define SDL_ISPIXELFORMAT_FOURCC(format)    \
 
144
    ((format) && !((format) & 0x80000000))
 
145
 
 
146
/* Note: If you modify this list, update SDL_GetPixelFormatName() */
 
147
enum
 
148
{
 
149
    SDL_PIXELFORMAT_UNKNOWN,
 
150
    SDL_PIXELFORMAT_INDEX1LSB =
 
151
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0,
 
152
                               1, 0),
 
153
    SDL_PIXELFORMAT_INDEX1MSB =
 
154
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0,
 
155
                               1, 0),
 
156
    SDL_PIXELFORMAT_INDEX4LSB =
 
157
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0,
 
158
                               4, 0),
 
159
    SDL_PIXELFORMAT_INDEX4MSB =
 
160
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0,
 
161
                               4, 0),
 
162
    SDL_PIXELFORMAT_INDEX8 =
 
163
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1),
 
164
    SDL_PIXELFORMAT_RGB332 =
 
165
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB,
 
166
                               SDL_PACKEDLAYOUT_332, 8, 1),
 
167
    SDL_PIXELFORMAT_RGB444 =
 
168
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
 
169
                               SDL_PACKEDLAYOUT_4444, 12, 2),
 
170
    SDL_PIXELFORMAT_RGB555 =
 
171
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
 
172
                               SDL_PACKEDLAYOUT_1555, 15, 2),
 
173
    SDL_PIXELFORMAT_BGR555 =
 
174
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
 
175
                               SDL_PACKEDLAYOUT_1555, 15, 2),
 
176
    SDL_PIXELFORMAT_ARGB4444 =
 
177
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
 
178
                               SDL_PACKEDLAYOUT_4444, 16, 2),
 
179
    SDL_PIXELFORMAT_RGBA4444 =
 
180
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA,
 
181
                               SDL_PACKEDLAYOUT_4444, 16, 2),
 
182
    SDL_PIXELFORMAT_ABGR4444 =
 
183
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR,
 
184
                               SDL_PACKEDLAYOUT_4444, 16, 2),
 
185
    SDL_PIXELFORMAT_BGRA4444 =
 
186
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA,
 
187
                               SDL_PACKEDLAYOUT_4444, 16, 2),
 
188
    SDL_PIXELFORMAT_ARGB1555 =
 
189
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
 
190
                               SDL_PACKEDLAYOUT_1555, 16, 2),
 
191
    SDL_PIXELFORMAT_RGBA5551 =
 
192
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA,
 
193
                               SDL_PACKEDLAYOUT_5551, 16, 2),
 
194
    SDL_PIXELFORMAT_ABGR1555 =
 
195
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR,
 
196
                               SDL_PACKEDLAYOUT_1555, 16, 2),
 
197
    SDL_PIXELFORMAT_BGRA5551 =
 
198
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA,
 
199
                               SDL_PACKEDLAYOUT_5551, 16, 2),
 
200
    SDL_PIXELFORMAT_RGB565 =
 
201
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
 
202
                               SDL_PACKEDLAYOUT_565, 16, 2),
 
203
    SDL_PIXELFORMAT_BGR565 =
 
204
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
 
205
                               SDL_PACKEDLAYOUT_565, 16, 2),
 
206
    SDL_PIXELFORMAT_RGB24 =
 
207
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0,
 
208
                               24, 3),
 
209
    SDL_PIXELFORMAT_BGR24 =
 
210
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0,
 
211
                               24, 3),
 
212
    SDL_PIXELFORMAT_RGB888 =
 
213
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB,
 
214
                               SDL_PACKEDLAYOUT_8888, 24, 4),
 
215
    SDL_PIXELFORMAT_BGR888 =
 
216
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR,
 
217
                               SDL_PACKEDLAYOUT_8888, 24, 4),
 
218
    SDL_PIXELFORMAT_ARGB8888 =
 
219
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB,
 
220
                               SDL_PACKEDLAYOUT_8888, 32, 4),
 
221
    SDL_PIXELFORMAT_RGBA8888 =
 
222
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA,
 
223
                               SDL_PACKEDLAYOUT_8888, 32, 4),
 
224
    SDL_PIXELFORMAT_ABGR8888 =
 
225
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR,
 
226
                               SDL_PACKEDLAYOUT_8888, 32, 4),
 
227
    SDL_PIXELFORMAT_BGRA8888 =
 
228
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA,
 
229
                               SDL_PACKEDLAYOUT_8888, 32, 4),
 
230
    SDL_PIXELFORMAT_ARGB2101010 =
 
231
        SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB,
 
232
                               SDL_PACKEDLAYOUT_2101010, 32, 4),
 
233
 
 
234
    SDL_PIXELFORMAT_YV12 =      /**< Planar mode: Y + V + U  (3 planes) */
 
235
        SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'),
 
236
    SDL_PIXELFORMAT_IYUV =      /**< Planar mode: Y + U + V  (3 planes) */
 
237
        SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'),
 
238
    SDL_PIXELFORMAT_YUY2 =      /**< Packed mode: Y0+U0+Y1+V0 (1 plane) */
 
239
        SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'),
 
240
    SDL_PIXELFORMAT_UYVY =      /**< Packed mode: U0+Y0+V0+Y1 (1 plane) */
 
241
        SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'),
 
242
    SDL_PIXELFORMAT_YVYU =      /**< Packed mode: Y0+V0+Y1+U0 (1 plane) */
 
243
        SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U')
 
244
};
 
245
 
 
246
typedef struct SDL_Color
 
247
{
 
248
    Uint8 r;
 
249
    Uint8 g;
 
250
    Uint8 b;
 
251
    Uint8 unused;
 
252
} SDL_Color;
 
253
#define SDL_Colour SDL_Color
 
254
 
 
255
typedef struct SDL_Palette
 
256
{
 
257
    int ncolors;
 
258
    SDL_Color *colors;
 
259
    Uint32 version;
 
260
    int refcount;
 
261
} SDL_Palette;
 
262
 
 
263
/**
 
264
 *  \note Everything in the pixel format structure is read-only.
 
265
 */
 
266
typedef struct SDL_PixelFormat
 
267
{
 
268
    Uint32 format;
 
269
    SDL_Palette *palette;
 
270
    Uint8 BitsPerPixel;
 
271
    Uint8 BytesPerPixel;
 
272
    Uint8 padding[2];
 
273
    Uint32 Rmask;
 
274
    Uint32 Gmask;
 
275
    Uint32 Bmask;
 
276
    Uint32 Amask;
 
277
    Uint8 Rloss;
 
278
    Uint8 Gloss;
 
279
    Uint8 Bloss;
 
280
    Uint8 Aloss;
 
281
    Uint8 Rshift;
 
282
    Uint8 Gshift;
 
283
    Uint8 Bshift;
 
284
    Uint8 Ashift;
 
285
    int refcount;
 
286
    struct SDL_PixelFormat *next;
 
287
} SDL_PixelFormat;
 
288
 
 
289
/**
 
290
 * \brief Get the human readable name of a pixel format
 
291
 */
 
292
extern DECLSPEC const char* SDLCALL SDL_GetPixelFormatName(Uint32 format);
 
293
 
 
294
/**
 
295
 *  \brief Convert one of the enumerated pixel formats to a bpp and RGBA masks.
 
296
 *  
 
297
 *  \return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
 
298
 *  
 
299
 *  \sa SDL_MasksToPixelFormatEnum()
 
300
 */
 
301
extern DECLSPEC SDL_bool SDLCALL SDL_PixelFormatEnumToMasks(Uint32 format,
 
302
                                                            int *bpp,
 
303
                                                            Uint32 * Rmask,
 
304
                                                            Uint32 * Gmask,
 
305
                                                            Uint32 * Bmask,
 
306
                                                            Uint32 * Amask);
 
307
 
 
308
/**
 
309
 *  \brief Convert a bpp and RGBA masks to an enumerated pixel format.
 
310
 *  
 
311
 *  \return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion 
 
312
 *          wasn't possible.
 
313
 *  
 
314
 *  \sa SDL_PixelFormatEnumToMasks()
 
315
 */
 
316
extern DECLSPEC Uint32 SDLCALL SDL_MasksToPixelFormatEnum(int bpp,
 
317
                                                          Uint32 Rmask,
 
318
                                                          Uint32 Gmask,
 
319
                                                          Uint32 Bmask,
 
320
                                                          Uint32 Amask);
 
321
 
 
322
/**
 
323
 *  \brief Create an SDL_PixelFormat structure from a pixel format enum.
 
324
 */
 
325
extern DECLSPEC SDL_PixelFormat * SDLCALL SDL_AllocFormat(Uint32 pixel_format);
 
326
 
 
327
/**
 
328
 *  \brief Free an SDL_PixelFormat structure.
 
329
 */
 
330
extern DECLSPEC void SDLCALL SDL_FreeFormat(SDL_PixelFormat *format);
 
331
 
 
332
/**
 
333
 *  \brief Create a palette structure with the specified number of color 
 
334
 *         entries.
 
335
 *  
 
336
 *  \return A new palette, or NULL if there wasn't enough memory.
 
337
 *  
 
338
 *  \note The palette entries are initialized to white.
 
339
 *  
 
340
 *  \sa SDL_FreePalette()
 
341
 */
 
342
extern DECLSPEC SDL_Palette *SDLCALL SDL_AllocPalette(int ncolors);
 
343
 
 
344
/**
 
345
 *  \brief Set the palette for a pixel format structure.
 
346
 */
 
347
extern DECLSPEC int SDLCALL SDL_SetPixelFormatPalette(SDL_PixelFormat * format,
 
348
                                                      SDL_Palette *palette);
 
349
 
 
350
/**
 
351
 *  \brief Set a range of colors in a palette.
 
352
 *  
 
353
 *  \param palette    The palette to modify.
 
354
 *  \param colors     An array of colors to copy into the palette.
 
355
 *  \param firstcolor The index of the first palette entry to modify.
 
356
 *  \param ncolors    The number of entries to modify.
 
357
 *  
 
358
 *  \return 0 on success, or -1 if not all of the colors could be set.
 
359
 */
 
360
extern DECLSPEC int SDLCALL SDL_SetPaletteColors(SDL_Palette * palette,
 
361
                                                 const SDL_Color * colors,
 
362
                                                 int firstcolor, int ncolors);
 
363
 
 
364
/**
 
365
 *  \brief Free a palette created with SDL_AllocPalette().
 
366
 *  
 
367
 *  \sa SDL_AllocPalette()
 
368
 */
 
369
extern DECLSPEC void SDLCALL SDL_FreePalette(SDL_Palette * palette);
 
370
 
 
371
/**
 
372
 *  \brief Maps an RGB triple to an opaque pixel value for a given pixel format.
 
373
 *  
 
374
 *  \sa SDL_MapRGBA
 
375
 */
 
376
extern DECLSPEC Uint32 SDLCALL SDL_MapRGB(const SDL_PixelFormat * format,
 
377
                                          Uint8 r, Uint8 g, Uint8 b);
 
378
 
 
379
/**
 
380
 *  \brief Maps an RGBA quadruple to a pixel value for a given pixel format.
 
381
 *  
 
382
 *  \sa SDL_MapRGB
 
383
 */
 
384
extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(const SDL_PixelFormat * format,
 
385
                                           Uint8 r, Uint8 g, Uint8 b,
 
386
                                           Uint8 a);
 
387
 
 
388
/**
 
389
 *  \brief Get the RGB components from a pixel of the specified format.
 
390
 *  
 
391
 *  \sa SDL_GetRGBA
 
392
 */
 
393
extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel,
 
394
                                        const SDL_PixelFormat * format,
 
395
                                        Uint8 * r, Uint8 * g, Uint8 * b);
 
396
 
 
397
/**
 
398
 *  \brief Get the RGBA components from a pixel of the specified format.
 
399
 *  
 
400
 *  \sa SDL_GetRGB
 
401
 */
 
402
extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel,
 
403
                                         const SDL_PixelFormat * format,
 
404
                                         Uint8 * r, Uint8 * g, Uint8 * b,
 
405
                                         Uint8 * a);
 
406
 
 
407
/**
 
408
 *  \brief Calculate a 256 entry gamma ramp for a gamma value.
 
409
 */
 
410
extern DECLSPEC void SDLCALL SDL_CalculateGammaRamp(float gamma, Uint16 * ramp);
 
411
 
 
412
 
 
413
/* Ends C function definitions when using C++ */
 
414
#ifdef __cplusplus
 
415
/* *INDENT-OFF* */
 
416
}
 
417
/* *INDENT-ON* */
 
418
#endif
 
419
#include "close_code.h"
 
420
 
 
421
#endif /* _SDL_pixels_h */
 
422
 
 
423
/* vi: set ts=4 sw=4 expandtab: */