speed up moving a lot with glxrender and fix its stacking of shadows

the callback for restack is called even when window is not visible now (and disabling profiling in the makefile)

use the depth buffer when rendering in gl, but it's pretty slow right now.  add --gl and --xrender to choose which rendering method you want to use, and --help for help.

render based on a variable number of vertices per window (for shaped windows in the future!)

use translate to place windows, and draw them based on 0,0

draw the root pixmap with the gl renderer, and honor windows restacking when they are not mapped

give windows drop shadows in gl

made the opengl renderer work - used Xlib's glX instead of xcb's which is all broked somehow.  tricks were needed to make fading work, but it is good now!

i dunno, even the clear isn't working for gl right now

i've reimplemented glXChooseFBConfig for xcb

i dont know why the pixmap creation fails but it does. bed time :(

make sure we don't draw the overlay window into itself

glxCreatePixmap is failing for some reason.  if that works, then probably glx rendering will work.

the xcb_screen_t has extra hidden stuff off the bottom that i need to preserve

the code is more or less there.  have to figure out how to find the fbconfigs right, it is looking for depths 0 and 1 or something right now.  and have to figure out how to do BIND_EXT with xcb

find the visuals to use, and the fbconfig we want to use for all available depths

initialize gl on the overlay window

excess

set the clip before drawing the root pixmap, and add an ifdef for debugging-like that lets you draw without double buffering

don't fade on startup/shutdown, make fading a bit quicker

make sure that when a window is shown it stops being a zombie

some better timing for fading maybe.  and reset the opacity when a window is finished being a zombie

trying to improve the timers some

rename some vars to be more clear

make fades a little faster

super fading

gc?

read the _NET_WM_WINDOW_OPACITY property that transset sets, and use it when determining the opacity level for windows.

make the render code use the window's opacity

find out a window's type when it is shown

use the window as an alpha mask, so that shadows on argb windows will have their shape match the window

give argb windows shadows too

add shadows.  they even take the same shape as the window. hee!

add support for shaped windows, and the circulatenotify event

blend argb windows, but just blit non-argb windows which is faster

add support for the root pixmap properties

don't check the result of composite_name_window_pixmap().  it ends up hanging sometimes, like the X server never returns an error or success code.  chuh.

don't wait for the pixmap reply if we're just going to make a new one.  just free it, whether it is valid or not

don't request hard-coded atoms from the server, it won't work

fix cases of getting confused if something is mapped or not.  only use the mapped value from xgetwindowattributes when we start up, otherwise it may just have mapped quickly after creating itself.

fix more memory problems :)

fix some more memory problems

fix some memory problems

fix memory leaks

add a signal handler

make rendering much faster

make the select always prefer X events over the timeouts for painting. also don't hide windows when they get configured *^^*

make transparency work

the compmgr works.. hooray!

handle configure notify events

remove a todo comment that is done

add the root window to the stacking list and everything like it's a normal window

get attributes/geometry/pixmap for windows

remove a debug print, and make it wait 0 instead of 1 microsecond when it needs to draw immediately

fix the select() call to work after it has timed out, and always flush at the end of everything, before going back to the select()

use the list for holding all the managed screens in the display.  limit the number of redraws to 60/second, but it's not working right atm, the select goes forever sometimes

setting up architecture for plugins.  have a render-based drawer that doesn't do anything just yet

add a next_repaint time to each screen

read all the available events at once

call a painting function

use select to tell when there are events to read

add existing windows on startup

renaming

add windows to the stacking order when they are created, and allow zombie windows, which also live in the stacking order

free the screen's stuff properly. add a stacking list to the screen.

add a list data structure that's much more efficient that glists

redirect rendering and get the composite overlay window

check if we connected to a display correctly

move more display code into the display file/struct

check for composite version 0.3

successfully queries the server for atoms and extensions

making some nice batch-query stuff for initializing the display statics

query extensions on the display

create a d_display_t type that encompasses a connection to a display

add an error handler

windows are added and created on create/destroy/reparent

lots more structure, for windws and such.  starting to get event.

set the root event mask to listen for substructure events

no globals

comment

split things off into screen.c/h

take the selecton for the screens that we will be managing, and skip the ones where a CM is already running

add .gitignore

initial commit