← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/3rdparty/xcb/xcb-util/xcb_aux.c

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/xcb/xcb-util/xcb_aux.c
 
1
/*
 
2
 * Copyright © 2008 Bart Massey <bart@cs.pdx.edu>
 
3
 * Copyright © 2008 Ian Osgood <iano@quirkster.com>
 
4
 * Copyright © 2008 Jamey Sharp <jamey@minilop.net>
 
5
 * Copyright © 2008 Josh Triplett <josh@freedesktop.org>
 
6
 *
 
7
 * Permission is hereby granted, free of charge, to any person
 
8
 * obtaining a copy of this software and associated documentation
 
9
 * files (the "Software"), to deal in the Software without
 
10
 * restriction, including without limitation the rights to use, copy,
 
11
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 
12
 * of the Software, and to permit persons to whom the Software is
 
13
 * furnished to do so, subject to the following conditions:
 
14
 *
 
15
 * The above copyright notice and this permission notice shall be
 
16
 * included in all copies or substantial portions of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
19
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
20
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
21
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 
22
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 
23
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
24
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
25
 *
 
26
 * Except as contained in this notice, the names of the authors or
 
27
 * their institutions shall not be used in advertising or otherwise to
 
28
 * promote the sale, use or other dealings in this Software without
 
29
 * prior written authorization from the authors.
 
30
 */
 
31
 
 
32
#include <stdio.h>
 
33
#include <stdlib.h>
 
34
#include <string.h>
 
35
 
 
36
#include <xcb/xcb.h>
 
37
#include "xcb_aux.h"
 
38
 
 
39
/* Connection related functions */
 
40
 
 
41
uint8_t
 
42
xcb_aux_get_depth (xcb_connection_t *c,
 
43
                   xcb_screen_t     *screen)
 
44
{
 
45
  xcb_drawable_t            drawable;
 
46
  xcb_get_geometry_reply_t *geom;
 
47
  int                       depth = 0;
 
48
 
 
49
  drawable = screen->root;
 
50
  geom = xcb_get_geometry_reply (c, xcb_get_geometry(c, drawable), 0);
 
51
 
 
52
  if (geom) {
 
53
    depth = geom->depth;
 
54
    free (geom);
 
55
  }
 
56
 
 
57
  return depth;
 
58
}
 
59
 
 
60
uint8_t
 
61
xcb_aux_get_depth_of_visual (xcb_screen_t *screen,
 
62
                             xcb_visualid_t id)
 
63
{
 
64
    xcb_depth_iterator_t i;
 
65
    xcb_visualtype_iterator_t j;
 
66
    for (i = xcb_screen_allowed_depths_iterator(screen);
 
67
         i.rem; xcb_depth_next(&i))
 
68
        for (j = xcb_depth_visuals_iterator(i.data);
 
69
             j.rem; xcb_visualtype_next(&j))
 
70
            if (j.data->visual_id == id)
 
71
                return i.data->depth;
 
72
    return 0;
 
73
}
 
74
 
 
75
xcb_screen_t *
 
76
xcb_aux_get_screen (xcb_connection_t *c,
 
77
                    int               screen)
 
78
{
 
79
  xcb_screen_iterator_t i = xcb_setup_roots_iterator(xcb_get_setup(c));
 
80
  for (; i.rem; --screen, xcb_screen_next(&i))
 
81
    if (screen == 0)
 
82
      return i.data;
 
83
  return 0;
 
84
}
 
85
 
 
86
xcb_visualtype_t *
 
87
xcb_aux_get_visualtype (xcb_connection_t *c,
 
88
                        int               scr,
 
89
                        xcb_visualid_t    vid)
 
90
{
 
91
  xcb_screen_t        *screen;
 
92
  xcb_depth_t         *depth;
 
93
  xcb_visualtype_iterator_t iter;
 
94
  int               cur;
 
95
 
 
96
  screen = xcb_aux_get_screen (c, scr);
 
97
  if (!screen) return NULL;
 
98
 
 
99
  depth = xcb_screen_allowed_depths_iterator(screen).data;
 
100
  if (!depth) return NULL;
 
101
   
 
102
   iter = xcb_depth_visuals_iterator(depth);
 
103
   for (cur = 0 ; cur < iter.rem ; xcb_visualtype_next(&iter), ++cur)
 
104
      if (vid == iter.data->visual_id)
 
105
         return iter.data;
 
106
 
 
107
   return NULL;
 
108
}
 
109
 
 
110
xcb_visualtype_t *
 
111
xcb_aux_find_visual_by_id (xcb_screen_t *screen,
 
112
                           xcb_visualid_t id)
 
113
{
 
114
    xcb_depth_iterator_t i;
 
115
    xcb_visualtype_iterator_t j;
 
116
    for (i = xcb_screen_allowed_depths_iterator(screen);
 
117
         i.rem; xcb_depth_next(&i))
 
118
        for (j = xcb_depth_visuals_iterator(i.data);
 
119
             j.rem; xcb_visualtype_next(&j))
 
120
            if (j.data->visual_id == id)
 
121
                return j.data;
 
122
    return 0;
 
123
}
 
124
 
 
125
xcb_visualtype_t *
 
126
xcb_aux_find_visual_by_attrs (xcb_screen_t *screen,
 
127
                              int8_t class,
 
128
                              int8_t depth)
 
129
{
 
130
    xcb_depth_iterator_t i;
 
131
    xcb_visualtype_iterator_t j;
 
132
    for (i = xcb_screen_allowed_depths_iterator(screen);
 
133
         i.rem; xcb_depth_next(&i)) {
 
134
        if (depth != -1 && i.data->depth != depth)
 
135
            continue;
 
136
        for (j = xcb_depth_visuals_iterator(i.data);
 
137
             j.rem; xcb_visualtype_next(&j))
 
138
            if (class == -1 || j.data->_class == class)
 
139
                return j.data;
 
140
    }
 
141
    return 0;
 
142
}
 
143
 
 
144
void
 
145
xcb_aux_sync (xcb_connection_t *c)
 
146
{
 
147
    free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), NULL));
 
148
}
 
149
 
 
150
/* structs instead of value lists */
 
151
/* TODO: generate the struct types and functions from protocol masks and descriptions */
 
152
 
 
153
/* This generic implementation of pack_list depends on:
 
154
   a) structs packed to uint32_t size
 
155
   b) structs consist of just uint32_t/int32_t fields in the same order as bitmask
 
156
*/
 
157
 
 
158
static void
 
159
pack_list( uint32_t mask, const uint32_t *src, uint32_t *dest )
 
160
{
 
161
        for ( ; mask; mask >>= 1, src++)
 
162
                if (mask & 1)
 
163
                        *dest++ = *src;
 
164
}
 
165
 
 
166
xcb_void_cookie_t
 
167
xcb_aux_create_window (xcb_connection_t       *c,
 
168
                       uint8_t                depth,
 
169
                       xcb_window_t           wid,
 
170
                       xcb_window_t           parent,
 
171
                       int16_t                x,
 
172
                       int16_t                y,
 
173
                       uint16_t               width,
 
174
                       uint16_t               height,
 
175
                       uint16_t               border_width,
 
176
                       uint16_t               _class,
 
177
                       xcb_visualid_t         visual,
 
178
                       uint32_t               mask,
 
179
                       const xcb_params_cw_t *params)
 
180
{
 
181
        uint32_t value_list[16];
 
182
        pack_list(mask, (const uint32_t *)params, value_list);
 
183
        return xcb_create_window(c, depth, wid, parent,
 
184
                x, y, width, height, border_width,
 
185
                _class, visual, mask, value_list);
 
186
}
 
187
 
 
188
xcb_void_cookie_t
 
189
xcb_aux_create_window_checked (xcb_connection_t       *c,
 
190
                               uint8_t                depth,
 
191
                               xcb_window_t           wid,
 
192
                               xcb_window_t           parent,
 
193
                               int16_t                x,
 
194
                               int16_t                y,
 
195
                               uint16_t               width,
 
196
                               uint16_t               height,
 
197
                               uint16_t               border_width,
 
198
                               uint16_t               _class,
 
199
                               xcb_visualid_t         visual,
 
200
                               uint32_t               mask,
 
201
                               const xcb_params_cw_t *params)
 
202
{
 
203
        uint32_t value_list[16];
 
204
        pack_list(mask, (const uint32_t *)params, value_list);
 
205
        return xcb_create_window_checked(c, depth, wid, parent,
 
206
                                         x, y, width, height, border_width,
 
207
                                         _class, visual, mask, value_list);
 
208
}
 
209
 
 
210
xcb_void_cookie_t
 
211
xcb_aux_change_window_attributes_checked (xcb_connection_t      *c,
 
212
                                          xcb_window_t           window,
 
213
                                          uint32_t               mask,
 
214
                                          const xcb_params_cw_t *params)
 
215
{
 
216
        uint32_t value_list[16];
 
217
        pack_list(mask, (const uint32_t *)params, value_list);
 
218
        return xcb_change_window_attributes_checked( c, window, mask, value_list );
 
219
}
 
220
 
 
221
xcb_void_cookie_t
 
222
xcb_aux_change_window_attributes (xcb_connection_t      *c,
 
223
                                  xcb_window_t           window,
 
224
                                  uint32_t               mask,
 
225
                                  const xcb_params_cw_t *params)
 
226
{
 
227
        uint32_t value_list[16];
 
228
        pack_list(mask, (const uint32_t *)params, value_list);
 
229
        return xcb_change_window_attributes( c, window, mask, value_list );
 
230
}
 
231
 
 
232
xcb_void_cookie_t
 
233
xcb_aux_configure_window (xcb_connection_t                    *c,
 
234
                          xcb_window_t                         window,
 
235
                          uint16_t                             mask,
 
236
                          const xcb_params_configure_window_t *params)
 
237
{
 
238
        uint32_t value_list[8];
 
239
        pack_list(mask, (const uint32_t *)params, value_list);
 
240
        return xcb_configure_window( c, window, mask, value_list );
 
241
}
 
242
 
 
243
xcb_void_cookie_t
 
244
xcb_aux_create_gc (xcb_connection_t      *c,
 
245
                   xcb_gcontext_t         gid,
 
246
                   xcb_drawable_t         drawable,
 
247
                   uint32_t               mask,
 
248
                   const xcb_params_gc_t *params)
 
249
{
 
250
        uint32_t value_list[32];
 
251
        pack_list(mask, (const uint32_t *)params, value_list);
 
252
        return xcb_create_gc( c, gid, drawable, mask, value_list );
 
253
}
 
254
 
 
255
xcb_void_cookie_t
 
256
xcb_aux_create_gc_checked (xcb_connection_t      *c,
 
257
                           xcb_gcontext_t         gid,
 
258
                           xcb_drawable_t         drawable,
 
259
                           uint32_t               mask,
 
260
                           const xcb_params_gc_t *params)
 
261
{
 
262
        uint32_t value_list[32];
 
263
        pack_list(mask, (const uint32_t *)params, value_list);
 
264
        return xcb_create_gc_checked( c, gid, drawable, mask, value_list);
 
265
}
 
266
 
 
267
xcb_void_cookie_t
 
268
xcb_aux_change_gc (xcb_connection_t     *c,
 
269
                   xcb_gcontext_t        gc,
 
270
                   uint32_t              mask,
 
271
                   const xcb_params_gc_t *params)
 
272
{
 
273
        uint32_t value_list[32];
 
274
        pack_list(mask, (const uint32_t *)params, value_list);
 
275
        return xcb_change_gc( c, gc, mask, value_list );
 
276
}
 
277
 
 
278
xcb_void_cookie_t
 
279
xcb_aux_change_gc_checked (xcb_connection_t     *c,
 
280
                           xcb_gcontext_t        gc,
 
281
                           uint32_t              mask,
 
282
                           const xcb_params_gc_t *params)
 
283
{
 
284
        uint32_t value_list[32];
 
285
        pack_list(mask, (const uint32_t *)params, value_list);
 
286
        return xcb_change_gc_checked( c, gc, mask, value_list );
 
287
}
 
288
 
 
289
xcb_void_cookie_t
 
290
xcb_aux_change_keyboard_control (xcb_connection_t            *c,
 
291
                                 uint32_t                     mask,
 
292
                                 const xcb_params_keyboard_t *params)
 
293
{
 
294
        uint32_t value_list[16];
 
295
        pack_list(mask, (const uint32_t *)params, value_list);
 
296
        return xcb_change_keyboard_control( c, mask, value_list );
 
297
}
 
298
 
 
299
/* Color related functions */
 
300
 
 
301
/* Return true if the given color name can be translated locally,
 
302
   in which case load the components.  Otherwise, a lookup_color request
 
303
   will be needed, so return false. */
 
304
int
 
305
xcb_aux_parse_color(char *color_name,
 
306
                    uint16_t *red,  uint16_t *green,  uint16_t *blue)
 
307
{
 
308
    int n, r, g, b, i;
 
309
    if (!color_name || *color_name != '#')
 
310
        return 0;
 
311
    /*
 
312
     * Excitingly weird RGB parsing code from Xlib.
 
313
     */
 
314
    n = strlen (color_name);
 
315
    color_name++;
 
316
    n--;
 
317
    if (n != 3 && n != 6 && n != 9 && n != 12)
 
318
        return 0;
 
319
    n /= 3;
 
320
    g = b = 0;
 
321
    do {
 
322
        r = g;
 
323
        g = b;
 
324
        b = 0;
 
325
        for (i = n; --i >= 0; ) {
 
326
            char c = *color_name++;
 
327
            b <<= 4;
 
328
            if (c >= '0' && c <= '9')
 
329
                b |= c - '0';
 
330
            else if (c >= 'A' && c <= 'F')
 
331
                b |= c - ('A' - 10);
 
332
            else if (c >= 'a' && c <= 'f')
 
333
                b |= c - ('a' - 10);
 
334
            else return 0;
 
335
        }
 
336
    } while (*color_name != '\0');
 
337
    n <<= 2;
 
338
    n = 16 - n;
 
339
    *red = r << n;
 
340
    *green = g << n;
 
341
    *blue = b << n;
 
342
    return 1;
 
343
}
 
344
 
 
345
/* Drawing related functions */
 
346
 
 
347
/* Adapted from Xlib */
 
348
xcb_void_cookie_t
 
349
xcb_aux_set_line_attributes_checked (xcb_connection_t *dpy,
 
350
                                     xcb_gcontext_t gc,
 
351
                                     uint16_t linewidth,
 
352
                                     int32_t linestyle,
 
353
                                     int32_t capstyle,
 
354
                                     int32_t joinstyle)
 
355
{
 
356
    uint32_t mask = 0;
 
357
    xcb_params_gc_t gv;
 
358
 
 
359
    XCB_AUX_ADD_PARAM(&mask, &gv, line_width, linewidth);
 
360
    XCB_AUX_ADD_PARAM(&mask, &gv, line_style, linestyle);
 
361
    XCB_AUX_ADD_PARAM(&mask, &gv, cap_style, capstyle);
 
362
    XCB_AUX_ADD_PARAM(&mask, &gv, join_style, joinstyle);
 
363
    return xcb_aux_change_gc_checked(dpy, gc, mask, &gv);
 
364
}
 
365
 
 
366
/* Adapted from Xlib */
 
367
/* XXX It would be wiser for apps just to call
 
368
   clear_area() directly. */
 
369
xcb_void_cookie_t
 
370
xcb_aux_clear_window(xcb_connection_t *  dpy,
 
371
                     xcb_window_t        w)
 
372
{
 
373
    return xcb_clear_area(dpy, 0, w, 0, 0, 0, 0);
 
374
}