/* XCB application drawing an updating bitmap in a window
*
* Inspired by the xcb black rectangle in a window example
*
* Copyright 2010 V. R. Sanders, released under the MIT licence
*/
/* compile with:
* gcc -Wall -lxcb-icccm -lxcb -lxcb-image -o disp disp.c
*/
#include <string.h>
#include <xcb/xcb.h>
#include <xcb/xcb_image.h>
#include <xcb/xcb_atom.h>
#include <xcb/xcb_icccm.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
static xcb_format_t *
find_format (xcb_connection_t * c, uint8_t depth, uint8_t bpp)
const xcb_setup_t *setup = xcb_get_setup(c);
xcb_format_t *fmt = xcb_setup_pixmap_formats(setup);
xcb_format_t *fmtend = fmt + xcb_setup_pixmap_formats_length(setup);
for(; fmt != fmtend; ++fmt)
if((fmt->depth == depth) && (fmt->bits_per_pixel == bpp))
/* printf("fmt %p has pad %d depth %d, bpp %d\n",
fmt,fmt->scanline_pad, depth,bpp); */
return fmt;
return 0;
void
fillimage(unsigned char *p, int width, int height)
int i, j;
for(i=0; i < width; i++)
for(j=0; j < height; j++)
if((i < 256)&&(j < 256))
*p++=rand()%256; // blue
*p++=rand()%256; // green
*p++=rand()%256; // red
else
*p++=i%256; // blue
*p++=j%256; // green
if(i < 256)
*p++=i%256; // red
else if(j < 256)
*p++=j%256; // red
else
*p++=(256-j)%256; // red
p++; /* unused byte */
xcb_image_t *
CreateTrueColorImage(xcb_connection_t *c,
int width,
int height)
const xcb_setup_t *setup = xcb_get_setup(c);
unsigned char *image32=(unsigned char *)malloc(width*height*4);
xcb_format_t *fmt = find_format(c, 24, 32);
if (fmt == NULL)
return NULL;
fillimage(image32, width, height);
return xcb_image_create(width,
height,
XCB_IMAGE_FORMAT_Z_PIXMAP,
fmt->scanline_pad,
fmt->depth,
fmt->bits_per_pixel,
0,
setup->image_byte_order,
XCB_IMAGE_ORDER_LSB_FIRST,
image32,
width*height*4,
image32);
int
main (int argc, char **argv)
xcb_connection_t *c;
xcb_screen_t *s;
xcb_window_t w;
xcb_pixmap_t pmap;
xcb_gcontext_t gc;
xcb_generic_event_t *e;
uint32_t mask;
uint32_t values[2];
int done=0;
xcb_image_t *image;
uint8_t *image32;
xcb_expose_event_t *ee;
char *title="Hello World!";
xcb_size_hints_t *hints;
/* open connection with the server */
c = xcb_connect (NULL, NULL);
if (!c)
printf ("Cannot open display\n");
exit (1);
s = xcb_setup_roots_iterator (xcb_get_setup (c)).data;
/* printf("root depth %d\n",s->root_depth); */
/* create image */
image = CreateTrueColorImage(c, 640, 480);
if (image == NULL)
printf ("Cannot create iamge\n");
xcb_disconnect(c);
return 1;
image32 = image->data;
/* create window */
mask = XCB_CW_BACK_PIXEL XCB_CW_EVENT_MASK;
values[0] = s->white_pixel;
values[1] = XCB_EVENT_MASK_EXPOSURE
XCB_EVENT_MASK_KEY_PRESS
XCB_EVENT_MASK_BUTTON_PRESS;
w = xcb_generate_id (c);
xcb_create_window (c, XCB_COPY_FROM_PARENT, w, s->root,
10, 10, image->width, image->height, 1,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
s->root_visual,
mask, values);
/* set title on window */
xcb_set_wm_name(c, w, STRING, strlen(title), title);
/* set size hits on window */
hints = xcb_alloc_size_hints();
xcb_size_hints_set_max_size(hints, image->width,image->height);
xcb_size_hints_set_min_size(hints, image->width,image->height);
xcb_set_wm_size_hints(c, w, WM_NORMAL_HINTS, hints);
/* create backing pixmap */
pmap = xcb_generate_id(c);
xcb_create_pixmap(c, 24, pmap, w, image->width, image->height);
/* create pixmap plot gc */
mask = XCB_GC_FOREGROUND XCB_GC_BACKGROUND;
values[0] = s->black_pixel;
values[1] = 0xffffff;
gc = xcb_generate_id (c);
xcb_create_gc (c, gc, pmap, mask, values);
/* put the image into the pixmap */
xcb_image_put(c, pmap, gc, image, 0, 0, 0);
/* show the window */
xcb_map_window (c, w);
xcb_flush (c);
/* event loop */
while (!done && (e = xcb_wait_for_event (c)))
switch (e->response_type)
case XCB_EXPOSE:
ee=(xcb_expose_event_t *)e;
/* printf ("expose %d,%d - %d,%d\n",
ee->x,ee->y,ee->width,ee->height); */
xcb_copy_area(c, pmap, w, gc,
ee->x,
ee->y,
ee->x,
ee->y,
ee->width,
ee->height);
xcb_flush (c);
image32+=16;
break;
case XCB_KEY_PRESS:
/* exit on keypress */
done = 1;
break;
case XCB_BUTTON_PRESS:
fillimage(image->data, image->width, image->height);
memset(image->data, 0, image32 - image->data);
xcb_image_put(c, pmap, gc, image, 0, 0, 0);
xcb_copy_area(c, pmap, w, gc, 0,0,0,0,image->width,image->height);
xcb_flush (c);
break;
free (e);
/* free pixmap */
xcb_free_pixmap(c, pmap);
/* close connection to server */
xcb_disconnect (c);
return 0;
I d like to extend a warm welcome to our selected students for the 2010 Debian Google Summer of Code!
They should pop up on Debian Planet soon and you re welcome to come talk to them on #debian-soc on irc.debian.org
Aptitude Qt
by Piotr Galiszewski, mentored by Sune Vuorela
Qt GUI for aptitude. Currently, KDE users need to use Aptitude via the console interface, or install the newly developed GTK frontend, which does not fit well into KDE desktop. Making Qt frontend to Aptitude would solve this problem and bring an advanced and fully Debian-compliant graphical package manager to KDE.
Content-aware Config Files Upgrading
by Krzysztof Tyszecki, mentored by Dominique Dumont
When a package deliver configuration files, the problem of merging user data with new configuration instructions will arise during package upgrades on users systems. Sometimes merging can be done with 3 way merge, but this process does not insure that the resulting file is correct or even legal. This project intends to create standards, tools an heuristics to make the scary config file conflict resolution debconf prompt a thing of the past.
Debbugs Bug Reporting and Manipulation API
by David Wendt Jr., mentored by Bastian Venthur
Currently debbugs supports a SOAP interface for querying Debian s Bug Tracking System. Unfortunately this operation is read-only. This project would create an API for debbugs which supports sending and manipulating bug reports, without having to resort to email. This project does not intend to replace email as mean to manipulate the BTS but rather to enhance the BTS to allow other means of bug creation and manipulation.
Debian High Performance Computing on Clouds
by Dominique Belhachemi, mentored by Steffen Moeller
The project paves a way to combine the demands in high performance computing with the dynamics of compute clouds with Debian. Combining the Eucalyptus cloud computing infrastructure with the TORQUE resource manager and preparing the components for dynamically added and removed instances provides the user with a attractive high performance computing environment. Such a system allows users to share resources with large compute centers with minimal changes in their workflow and scripts.
Debian-Installer on Neo FreeRunner and Handheld Devices
by Thibaut Girka, mentored by Gaudenz Steinlin
This project aims to improve the installation experience of Debian on handheld devices by replacing ad-hoc install scripts by a full-blown and adapted Debian-Installer. The Neo FreeRunner is used as it is the most convenient and open device from a development standpoint, but other devices will also be explored.
Hurd port and de-Linux-ization of Debian-Installer
by J r mie Koenig, mentored by Samuel Thibault
The primary means of distributing the Hurd is through Debian GNU/Hurd. However, the installation CDs presently use an ancient, non-native installer. The goal of this project is to port the missing parts of Debian-Installer to Hurd. To achieve this, all problematic Linux-specific code in Debian-Installer will be replaced by less or non-kernel dependent code, paving the way for better support of other non-Linux ports of Debian.
Multi-Arch support in APT
by David Kalnischkies, mentored by Michael Vogt
Hardware like 64bit processors are perfectly able to execute 32bit opcode but until now this potentiality is disregard as the infrastructure tools like dpkg and APT are not able to install and/or solve dependencies across multiple architectures. The project therefore focuses on enabling APT to work out good solutions in a MultiArch aware environments without the need of hacky and partly working biarch packages currently in use.
Package Repository Analysis and Migration Automation
by Ricardo O Donell, mentored by Neil Williams
Emdebian uses a filter to select packages from the main Debian repositories that are considered useful to embedded devices, excluding the majority of packages. The results of processing the filter are automated but maintaining the filter list is manual. This project seeks to automate certain elements of the filtering process to cope with specific conditions. This project will also generalize to more elaborate and intelligent algorithms to improve the transitions of the main Debian archives.
Smart Upload Server for FTP Master
by Petr Jasek, mentored by Joerg Jaspert
Making packages upload smarter, more interactive and painless for uploaders by switching from anonymous FTP and Cron jobs to a robust protocol and modern package checking and processing daemon. This daemon would test early and report early, saving developers time.
More details coming soon on http://wiki.debian.org/gsoc
Congratulations everyone and have a fruitful summer!
Dear Lazyweb:
Can you suggest open source content management software that meets these criteria:
).
Answers to the former question (why are we doing this in the
first place?) are possibly subjectives. My personal belief is that
attending DebConf increases the enthusiasm of
attendees and ultimately will make them better
Debian citizens. It surely happened to me years ago: in
the beginning of my Debian membership (as DD, since DMs did not
exist back then) I just cared about my pet packages. It was only
after meeting the Debian crowd in person at a FOSS event (LinuxTag
2004, IIRC) that I got really enthusiastic about Debian,
gradually increasing my involvement in the project. I've never
regretted it.
I hope it can happen to some of you too, possibly starting with
DebConf10.
Having my primary working Computer, a Lenovo Thinkpad, going into
repair at the end of December I finally got up to ordering on of those
I'm going to Debconf 10:
Even though I do not understand the whole European
campaign-period concept, I kept my mouth shut even
though it was at odds with trying to answer every
question, no matter how stupid. I give props to
Jeroen for his efforts in question-answering that
year, even though the electorate obviously never
cares about that.
I wanted to answer all questions directed to all
candidates (excluding replies for the same reason
that I only responded on-list to questions directed
explicitly at me), but did not.
Quite a bit of the encouragement I have received
after the fact has been from people who are not
DDs. I find this strange since most of what I
have said has been about the enfranchisement of
DDs, and nothing about non-DDs. I could
speculate about why this might be the case, but
I will refrain.
We now return you to your regular program.
I'm helping out on the talks committee for debconf 10 this summer in NYC (so yes, i'm going to be here for it, even though i don't have that little badge thingy). This is a call for interested folks to let us know what you want to see at debconf! Talks If you haven't already, 
I spent the whole last week in bed with an acute case of pharyngitis, so
I haven't been able to gather my thoughts in a blog post up to now.
I'd like to congratulate zack on winning the election, and I have faith
that he will be a great DPL. I'm happy with my second place, I'd like to
thank everybody that supported me and I think that I'll probably try again
in the future, although not necessarily next year.
Since zack is probably not going to have time to keep up with his bug
squashing campaign, I'm going to try and continue that myself. And, if time
permits I'm also going to try to put some of the ideas in my platform into
action.
Finally, last friday both Maxy and me were granted the US visa that we
needed to go to DC10, so we finally can say:
I recently bought a 
I found myself with a problem: trying to linearly edit a movie clip
with a non-linear editor isn't very simple, nor is it meant to be.
Case at hand: I have about 1 hour and 40 minutes of film material
that was recorded with 
One of the features of Windows 7 is that hitting windows+p will pop up a little dialog that allows you to configure your active display outputs. This is an improvement over previous versions of Windows, which would generally instead have a variety of random vendor-specific tools that would function differently, look ugly and make you cry. So, hurrah to Windows for moving into the 21st century.
At my last job, I created several web applications designed to replace
built-in apps on mobile phones. While modern browsers and HTML5 made this
incredibly easy in many ways, we still ended up writing native (i.e. non-web)
code for most of our applications. There were a few different areas where the
browser alone didn't meet our needs, but one that I found suprisingly common
was background processing.
Consider the following mobile applications: