#include "group.h"
#include "config.h"
#include "menu.h"
-#include "render/render.h"
+#include "render2/render.h"
#include <glib.h>
#include <X11/Xutil.h>
w = self->icons[j].width = data[i++];
h = self->icons[j].height = data[i++];
- self->icons[j].data = g_new(pixel32, w * h);
+ self->icons[j].data = g_new(RrData32, w * h);
for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
if (x >= w) {
x = 0;
++y;
}
+ /* XXX optimize me, less shifts pls */
self->icons[j].data[t] =
- (((data[i] >> 24) & 0xff) << default_alpha_offset) +
- (((data[i] >> 16) & 0xff) << default_red_offset) +
- (((data[i] >> 8) & 0xff) << default_green_offset) +
- (((data[i] >> 0) & 0xff) << default_blue_offset);
+ (((data[i] >> 24) & 0xff) << 0) +
+ (((data[i] >> 16) & 0xff) << 24) +
+ (((data[i] >> 8) & 0xff) << 16) +
+ (((data[i] >> 0) & 0xff) << 8);
}
g_assert(i <= num);
}
g_free(data);
- } else if (PROP_GETA32(self->window, kwm_win_icon,
+ }/* XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
+ else if (PROP_GETA32(self->window, kwm_win_icon,
kwm_win_icon, &data, &num)) {
if (num == 2) {
self->nicons++;
XFree(hints);
}
}
+*/
if (self->frame)
frame_adjust_icon(self->frame);
#include "geom.h"
#include "stacking.h"
-#include "render/color.h"
+#include "render2/render.h"
#include <glib.h>
#include <X11/Xlib.h>
/*! Holds an icon in ARGB format */
typedef struct Icon {
int width, height;
- pixel32 *data;
+ RrData32 *data;
} Icon;
/*! The MWM Hints as retrieved from the window property
#include "config.h"
#include "grab.h"
#include "openbox.h"
-#include "render/theme.h"
+
+/* XXX temp */
+static int theme_bwidth = 3;
#define DOCK_EVENT_MASK (ButtonPressMask | ButtonReleaseMask | \
EnterWindowMask | LeaveWindowMask)
attrib.event_mask = DOCK_EVENT_MASK;
attrib.override_redirect = True;
dock->frame = XCreateWindow(ob_display, ob_root, 0, 0, 1, 1, 0,
- render_depth, InputOutput, render_visual,
+ RrInstanceDepth(ob_render_inst), InputOutput,
+ RrInstanceVisual(ob_render_inst),
CWOverrideRedirect | CWEventMask,
&attrib);
+ dock->s_frame = RrSurfaceNew(ob_render_inst, RR_SURFACE_PLANAR,
+ dock->frame, 0);
+ /* XXX COPY THE APPEARANCE FROM THE THEME !#&*(# LIKE THIS SORTA...
dock->a_frame = appearance_copy(theme_a_unfocused_title);
- XSetWindowBorderWidth(ob_display, dock->frame, theme_bwidth);
+ */
g_hash_table_insert(window_map, &dock->frame, dock);
stacking_add(DOCK_AS_WINDOW(dock));
void dock_shutdown()
{
+ RrSurfaceFree(dock->s_frame);
XDestroyWindow(ob_display, dock->frame);
- appearance_free(dock->a_frame);
g_hash_table_remove(window_map, &dock->frame);
stacking_remove(dock);
}
}
}
+ dock->w += theme_bwidth * 2;
+ dock->h += theme_bwidth * 2;
+
/* position the apps */
for (it = dock->dock_apps; it; it = it->next) {
struct DockApp *app = it->data;
XMoveWindow(ob_display, app->icon_win, app->x, app->y);
}
- /* used for calculating offsets */
- dock->w += theme_bwidth * 2;
- dock->h += theme_bwidth * 2;
-
/* calculate position */
switch (config_dock_pos) {
case DockPos_Floating:
break;
}
- /* not used for actually sizing shit */
- dock->w -= theme_bwidth * 2;
- dock->h -= theme_bwidth * 2;
-
if (dock->w > 0 && dock->h > 0) {
- RECT_SET(dock->a_frame->area, 0, 0, dock->w, dock->h);
- XMoveResizeWindow(ob_display, dock->frame,
- dock->x, dock->y, dock->w, dock->h);
-
- paint(dock->frame, dock->a_frame);
- XMapWindow(ob_display, dock->frame);
+ RrSurfaceSetArea(dock->s_frame, dock->x, dock->y, dock->w, dock->h);
+ RrSurfaceShow(dock->s_frame);
} else
- XUnmapWindow(ob_display, dock->frame);
-
- /* but they are useful outside of this function! */
- dock->w += theme_bwidth * 2;
- dock->h += theme_bwidth * 2;
+ RrSurfaceHide(dock->s_frame);
screen_update_struts();
}
#include "window.h"
#include "stacking.h"
#include "geom.h"
-#include "render/render.h"
+#include "render2/render.h"
#include <glib.h>
#include <X11/Xlib.h>
ObWindow obwin;
Window frame;
- Appearance *a_frame;
+ struct RrSurface *s_frame;
/* actual position (when not auto-hidden) */
int x, y;
#include "openbox.h"
#include "extensions.h"
#include "framerender.h"
-#include "render/theme.h"
#define PLATE_EVENTMASK (SubstructureRedirectMask | ButtonPressMask)
#define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
#define ELEMENT_EVENTMASK (ButtonPressMask | ButtonReleaseMask | \
ButtonMotionMask | ExposureMask)
+/* XXX temp */
+static int theme_bwidth = 3;
+static int theme_cbwidth = 3;
+static int theme_title_height = 8;
+
void frame_startup()
{
}
XSetWindowAttributes *attrib)
{
return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
- render_depth, InputOutput, render_visual,
+ RrInstanceDepth(ob_render_inst),
+ InputOutput, RrInstanceVisual(ob_render_inst),
mask, attrib);
}
g_assert(obwin);
if (client->frame->window == win) {
-printf("frame context\n");
+g_print("frame context\n");
return Context_Frame;
}
if (client->frame->plate == win)
return Context_Client;
-printf("decoration clicked\n");
+g_print("decoration clicked\n");
g_assert(WINDOW_IS_DECORATION(obwin));
return WINDOW_AS_DECORATION(obwin)->context;
}
r->height = d->frame->client->area.height * d->area.height / 100;
break;
}
-printf("area of decoration is %d, %d, %d, %d\n", r->x, r->y, r->width,
+g_print("area of decoration is %d, %d, %d, %d\n", r->x, r->y, r->width,
r->height);
}
#include "geom.h"
#include "client.h"
-#include "render/render.h"
+/*#include "render2/render.h"*/
#include "window.h"
typedef enum {
#include "openbox.h"
#include "screen.h"
#include "framerender.h"
-#include "render/theme.h"
void framerender_frame(Frame *self)
{
#include "openbox.h"
#include "stacking.h"
#include "grab.h"
-#include "render/theme.h"
#include "screen.h"
#include "geom.h"
#include "plugin.h"
g_free(self->label);
g_free(self->name);
- g_hash_table_remove(window_map, &self->title);
- g_hash_table_remove(window_map, &self->frame);
- g_hash_table_remove(window_map, &self->items);
+ g_hash_table_remove(window_map, &self->w_title);
+ g_hash_table_remove(window_map, &self->w_frame);
+ g_hash_table_remove(window_map, &self->w_items);
stacking_remove(self);
- appearance_free(self->a_title);
- XDestroyWindow(ob_display, self->title);
- XDestroyWindow(ob_display, self->frame);
- XDestroyWindow(ob_display, self->items);
+ RrSurfaceFree(self->s_title);
+ RrSurfaceFree(self->s_items);
+ RrSurfaceFree(self->s_frame);
+
+ XDestroyWindow(ob_display, self->w_frame);
g_free(self);
}
g_free(self->label);
action_free(self->action);
- g_hash_table_remove(window_map, &self->item);
+ g_hash_table_remove(window_map, &self->w_item);
+ g_hash_table_remove(window_map, &self->w_disabled);
+ g_hash_table_remove(window_map, &self->w_hilite);
- appearance_free(self->a_item);
- appearance_free(self->a_disabled);
- appearance_free(self->a_hilite);
- XDestroyWindow(ob_display, self->item);
+ RrSurfaceFree(self->s_item);
+ RrSurfaceFree(self->s_disabled);
+ RrSurfaceFree(self->s_hilite);
g_free(self);
}
void menu_startup()
{
Menu *m;
+/*
Menu *s;
Menu *t;
+*/
Action *a;
menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
- menu_destroy_hash_key,
+ (GDestroyNotify)menu_destroy_hash_key,
(GDestroyNotify)menu_destroy_hash_value);
m = menu_new("sex menu", "root", NULL);
XSetWindowAttributes *attrib)
{
return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
- render_depth, InputOutput, render_visual,
+ RrInstanceDepth(ob_render_inst), InputOutput,
+ RrInstanceVisual(ob_render_inst),
mask, attrib);
}
attrib.override_redirect = TRUE;
attrib.event_mask = FRAME_EVENTMASK;
- self->frame = createWindow(ob_root, CWOverrideRedirect|CWEventMask, &attrib);
- attrib.event_mask = TITLE_EVENTMASK;
- self->title = createWindow(self->frame, CWEventMask, &attrib);
- self->items = createWindow(self->frame, 0, &attrib);
-/*
- XSetWindowBorderWidth(ob_display, self->frame, theme_bwidth);
- XSetWindowBackground(ob_display, self->frame, theme_b_color->pixel);
- XSetWindowBorderWidth(ob_display, self->title, theme_bwidth);
- XSetWindowBorder(ob_display, self->frame, theme_b_color->pixel);
- XSetWindowBorder(ob_display, self->title, theme_b_color->pixel);
-*/
- XMapWindow(ob_display, self->title);
- XMapWindow(ob_display, self->items);
-
+ self->w_frame = createWindow(ob_root, CWOverrideRedirect|CWEventMask,
+ &attrib),
+ self->s_frame = RrSurfaceNew(ob_render_inst, RR_SURFACE_PLANAR,
+ self->w_frame, 0);
+
+ /* XXX COPY THESE FROM THE THEME@&#*(&!# */
+ self->s_title = RrSurfaceNewChild(RR_SURFACE_PLANAR, self->s_frame, 1);
+ self->w_title = RrSurfaceWindow(self->s_title);
+ self->s_items = RrSurfaceNewChild(RR_SURFACE_PLANAR, self->s_frame, 0);
+ self->w_items = RrSurfaceWindow(self->s_items);
+ /* XXX LIKE THIS SORTA...
self->a_title = appearance_copy(theme_a_menu_title);
self->a_items = appearance_copy(theme_a_menu);
+ */
- g_hash_table_insert(window_map, &self->frame, self);
- g_hash_table_insert(window_map, &self->title, self);
- g_hash_table_insert(window_map, &self->items, self);
+ /* event masks */
+ XSelectInput(ob_display, self->w_title, TITLE_EVENTMASK);
+
+ g_hash_table_insert(window_map, &self->w_frame, self);
+ g_hash_table_insert(window_map, &self->w_title, self);
+ g_hash_table_insert(window_map, &self->w_items, self);
g_hash_table_insert(menu_hash, g_strdup(name), self);
stacking_add(MENU_AS_WINDOW(self));
g_assert(menu != NULL);
g_assert(entry != NULL);
- g_assert(entry->item == None);
+ g_assert(entry->s_item == NULL);
menu->entries = g_list_append(menu->entries, entry);
entry->parent = menu;
attrib.event_mask = ENTRY_EVENTMASK;
- entry->item = createWindow(menu->items, CWEventMask, &attrib);
- XMapWindow(ob_display, entry->item);
+ /* XXX COPY FROM THEME SURFACES @#&!#&*!@ */
+ entry->s_item = RrSurfaceNewChild(RR_SURFACE_PLANAR, menu->s_items, 1);
+ entry->w_item = RrSurfaceWindow(entry->s_item);
+ entry->s_disabled = RrSurfaceNewChild(RR_SURFACE_PLANAR, menu->s_items,1);
+ entry->w_disabled = RrSurfaceWindow(entry->s_disabled);
+ entry->s_hilite = RrSurfaceNewChild(RR_SURFACE_PLANAR, menu->s_items, 1);
+ entry->w_hilite = RrSurfaceWindow(entry->s_hilite);
+ /* XXX LIKE THIS SORTA....
entry->a_item = appearance_copy(theme_a_menu_item);
entry->a_disabled = appearance_copy(theme_a_menu_disabled);
entry->a_hilite = appearance_copy(theme_a_menu_hilite);
+ */
+
+ /* event masks */
+ XSelectInput(ob_display, entry->w_item, ENTRY_EVENTMASK);
+ XSelectInput(ob_display, entry->w_disabled, ENTRY_EVENTMASK);
+ XSelectInput(ob_display, entry->w_hilite, ENTRY_EVENTMASK);
menu->invalid = TRUE;
- g_hash_table_insert(window_map, &entry->item, menu);
+ g_hash_table_insert(window_map, &entry->w_item, menu);
+ g_hash_table_insert(window_map, &entry->w_disabled, menu);
+ g_hash_table_insert(window_map, &entry->w_hilite, menu);
}
void menu_show(char *name, int x, int y, Client *client)
void menu_hide(Menu *self) {
if (self->shown) {
- XUnmapWindow(ob_display, self->frame);
+ RrSurfaceHide(self->s_frame);
self->shown = FALSE;
if (self->open_submenu)
menu_hide(self->open_submenu);
for (it = menu->entries; it; it = it->next) {
MenuEntry *entry = it->data;
- if (entry->item == win)
+ if (entry->w_item == win ||
+ entry->w_disabled == win ||
+ entry->w_hilite == win)
return entry;
}
return NULL;
void menu_control_show(Menu *self, int x, int y, Client *client) {
g_assert(!self->invalid);
-
- XMoveWindow(ob_display, self->frame,
- MIN(x, screen_physical_size.width - self->size.width),
- MIN(y, screen_physical_size.height - self->size.height));
- POINT_SET(self->location,
- MIN(x, screen_physical_size.width - self->size.width),
- MIN(y, screen_physical_size.height - self->size.height));
+
+ POINT_SET(self->location, x, y);
+ menu_render(self);
if (!self->shown) {
- XMapWindow(ob_display, self->frame);
+ RrSurfaceShow(self->s_frame);
stacking_raise(MENU_AS_WINDOW(self));
self->shown = TRUE;
} else if (self->shown && self->open_submenu) {
g_assert(!self->parent->invalid);
/* TODO: I don't understand why these bevels should be here.
Something must be wrong in the width calculation */
- x = self->parent->location.x + self->parent->size.width +
- theme_bevel;
+ x = self->parent->location.x + self->parent->size.width;
/* need to get the width. is this bad?*/
menu_render(self->submenu);
if (self->submenu->size.width + x > screen_physical_size.width)
- x = self->parent->location.x - self->submenu->size.width -
- theme_bevel;
+ x = self->parent->location.x - self->submenu->size.width;
menu_show_full(self->submenu, x,
self->parent->location.y + self->y,
#define __menu_h
#include "action.h"
-#include "render/render.h"
#include "geom.h"
+#include "render2/render.h"
#include <glib.h>
/* render stuff */
Client *client;
- Window frame;
- Window title;
- Appearance *a_title;
+ struct RrSurface *s_frame;
+ Window w_frame;
+ struct RrSurface *s_title;
+ Window w_title;
+ struct RrSurface *s_items;
+ Window w_items;
int title_min_w, title_h;
- Window items;
- Appearance *a_items;
int bullet_w;
int item_h;
Point location;
MenuEntryRenderType_Other = 1 << 7
} MenuEntryRenderType;
-typedef struct {
+typedef struct MenuEntry {
char *label;
Menu *parent;
Menu *submenu;
/* render stuff */
- Window item;
- Appearance *a_item;
- Appearance *a_disabled;
- Appearance *a_hilite;
+ struct RrSurface *s_item;
+ Window w_item;
+ struct RrSurface *s_disabled;
+ Window w_disabled;
+ struct RrSurface *s_hilite;
+ Window w_hilite;
int y;
int min_w;
} MenuEntry;
#include "menu.h"
#include "openbox.h"
-#include "render/theme.h"
+#include "screen.h"
+#include "render2/render.h"
+
+/* XXX temp */
+static int theme_bevel = 1;
+static int theme_bwidth = 0;
void menu_render_full(Menu *self);
int item_y;
self->size.width = 1;
+ self->size.height = 1;
self->item_h = 1;
/* set texture data and size them mofos out */
if (self->label) {
- self->a_title->texture[0].data.text.string = self->label;
- appearance_minsize(self->a_title, &self->title_min_w, &self->title_h);
+ RrTextureSetText(self->s_title, 0, NULL, RR_CENTER,
+ self->label);
+ RrSurfaceMinSize(self->s_title, &self->title_min_w, &self->title_h);
self->title_min_w += theme_bevel * 2;
self->title_h += theme_bevel * 2;
self->size.width = MAX(self->size.width, self->title_min_w);
+ self->size.height = MAX(self->size.height,
+ self->title_h + theme_bwidth);
}
for (it = self->entries; it; it = it->next) {
MenuEntry *e = it->data;
int h;
- e->a_item->texture[0].data.text.string = e->label;
- appearance_minsize(e->a_item, &e->min_w, &self->item_h);
+ RrTextureSetText(e->s_item, 0, NULL, RR_LEFT, e->label);
+ RrSurfaceMinSize(e->s_item, &e->min_w, &self->item_h);
self->size.width = MAX(self->size.width, e->min_w);
- e->a_disabled->texture[0].data.text.string = e->label;
- appearance_minsize(e->a_disabled, &e->min_w, &h);
+ RrTextureSetText(e->s_disabled, 0, NULL, RR_LEFT, e->label);
+ RrSurfaceMinSize(e->s_disabled, &e->min_w, &h);
self->item_h = MAX(self->item_h, h);
self->size.width = MAX(self->size.width, e->min_w);
- e->a_hilite->texture[0].data.text.string = e->label;
- appearance_minsize(e->a_hilite, &e->min_w, &h);
+ RrTextureSetText(e->s_hilite, 0, NULL, RR_LEFT, e->label);
+ RrSurfaceMinSize(e->s_hilite, &e->min_w, &h);
self->item_h = MAX(self->item_h, h);
self->size.width = MAX(self->size.width, e->min_w);
++nitems;
}
self->bullet_w = self->item_h + theme_bevel;
- self->size.width += 2 * self->bullet_w + 2 * theme_bevel;
+ self->size.width += 2*self->bullet_w + 2*theme_bevel + 2*theme_bwidth;
self->item_h += theme_bevel * 2;
items_h = self->item_h * MAX(nitems, 1);
+ self->size.height += items_h + theme_bwidth * 2;
if (self->label) {
- RECT_SET(self->a_title->area, 0, 0, self->size.width,
- self->title_h);
- RECT_SET(self->a_title->texture[0].position, 0, 0, self->size.width,
- self->title_h);
+ RrSurfaceSetArea(self->s_title, theme_bwidth, theme_bwidth,
+ self->size.width - theme_bwidth * 2,
+ self->title_h);
}
- RECT_SET(self->a_items->area, 0, 0, self->size.width, items_h);
-
- XResizeWindow(ob_display, self->frame, self->size.width,
- MAX(self->title_h + items_h, 1));
- if (self->label)
- XMoveResizeWindow(ob_display, self->title, -theme_bwidth,
- -theme_bwidth, self->size.width, self->title_h);
-
- XMoveResizeWindow(ob_display, self->items, 0,
- self->title_h + theme_bwidth, self->size.width,
- items_h);
+ RrSurfaceSetArea(self->s_items, theme_bwidth,
+ theme_bwidth * 2 + self->title_h,
+ self->size.width - theme_bwidth * 2, items_h);
- if (self->label)
- paint(self->title, self->a_title);
- paint(self->items, self->a_items);
+
+ RrSurfaceSetArea(self->s_frame,
+ MIN(self->location.x,
+ screen_physical_size.width - self->size.width),
+ MIN(self->location.y,
+ screen_physical_size.height - self->size.height),
+ self->size.width,
+ self->size.height);
item_y = 0;
for (it = self->entries; it; it = it->next) {
- ((MenuEntry*)it->data)->y = item_y;
+ MenuEntry *e = it->data;
+ RrSurfaceSetArea(e->s_item, self->bullet_w, item_y,
+ self->size.width - 2*theme_bwidth - 2*self->bullet_w,
+ self->item_h);
+ RrSurfaceSetArea(e->s_disabled, self->bullet_w, item_y,
+ self->size.width - 2*theme_bwidth - 2*self->bullet_w,
+ self->item_h);
+ RrSurfaceSetArea(e->s_hilite, self->bullet_w, item_y,
+ self->size.width - 2*theme_bwidth - 2*self->bullet_w,
+ self->item_h);
menu_entry_render(it->data);
item_y += self->item_h;
}
- self->size.height = item_y;
self->invalid = FALSE;
}
void menu_entry_render(MenuEntry *self)
{
- Menu *menu = self->parent;
- Appearance *a;
-
switch (self->render_type) {
case MenuEntryRenderType_Submenu:
/* TODO: submenu mask */
case MenuEntryRenderType_Boolean:
- /* TODO: boolean check */
- a = self->enabled ? (self->hilite ? self->a_hilite : self->a_item)
- : self->a_disabled;
- break;
case MenuEntryRenderType_None:
- a = self->enabled ? (self->hilite ? self->a_hilite : self->a_item )
- : self->a_disabled;
+ /* TODO: boolean check */
+ if (self->enabled) {
+ if (self->hilite) {
+ RrSurfaceHide(self->s_disabled);
+ RrSurfaceHide(self->s_item);
+ RrSurfaceShow(self->s_hilite);
+ } else {
+ RrSurfaceHide(self->s_disabled);
+ RrSurfaceShow(self->s_item);
+ RrSurfaceHide(self->s_hilite);
+ }
+ } else {
+ RrSurfaceShow(self->s_disabled);
+ RrSurfaceHide(self->s_item);
+ RrSurfaceHide(self->s_hilite);
+ }
break;
case MenuEntryRenderType_Separator:
- a = self->a_item;
+ RrSurfaceHide(self->s_disabled);
+ RrSurfaceShow(self->s_item);
+ RrSurfaceHide(self->s_hilite);
break;
default:
g_message("unhandled render_type");
+ if (self->enabled) {
+ if (self->hilite) {
+ RrSurfaceHide(self->s_disabled);
+ RrSurfaceHide(self->s_item);
+ RrSurfaceShow(self->s_hilite);
+ } else {
+ RrSurfaceHide(self->s_disabled);
+ RrSurfaceShow(self->s_item);
+ RrSurfaceHide(self->s_hilite);
+ }
+ } else {
+ RrSurfaceShow(self->s_disabled);
+ RrSurfaceHide(self->s_item);
+ RrSurfaceHide(self->s_hilite);
+ }
+/* used to be this... looks repetative from above
a = !self->enabled ? self->a_disabled :
(self->hilite &&
(self->action || self->render_type == MenuEntryRenderType_Submenu) ?
self->a_hilite : self->a_item);
+*/
break;
}
-
- RECT_SET(a->area, 0, 0, menu->size.width,
- menu->item_h);
- RECT_SET(a->texture[0].position, menu->bullet_w,
- 0, menu->size.width - 2 * menu->bullet_w,
- menu->item_h);
-
- XMoveResizeWindow(ob_display, self->item, 0, self->y,
- menu->size.width, menu->item_h);
- a->surface.data.planar.parent = menu->a_items;
- a->surface.data.planar.parentx = 0;
- a->surface.data.planar.parenty = self->y;
-
- paint(self->item, a);
}
#include "openbox.h"
#include "popup.h"
#include "config.h"
-#include "render/render.h"
-#include "render/theme.h"
+#include "render2/render.h"
#include <X11/Xlib.h>
#include <glib.h>
+/* XXX temp */
+static int theme_bwidth = 1;
+
gboolean moveresize_in_progress = FALSE;
Client *moveresize_client = NULL;
attrib.save_under = True;
opaque_window.win = XCreateWindow(ob_display, ob_root, 0, 0, 1, 1, 0,
- render_depth, InputOutput, render_visual,
+ RrInstanceDepth(ob_render_inst),
+ InputOutput,
+ RrInstanceVisual(ob_render_inst),
CWSaveUnder, &attrib);
stacking_add(INTERNAL_AS_WINDOW(&opaque_window));
stacking_raise(INTERNAL_AS_WINDOW(&opaque_window));
#include "config.h"
#include "gettext.h"
#include "parser/parse.h"
-#include "render/render.h"
-#include "render/font.h"
-#include "render/theme.h"
+#include "render2/render.h"
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
Display *ob_display = NULL;
int ob_screen;
Window ob_root;
+struct RrInstance *ob_render_inst = NULL;
State ob_state;
gboolean ob_shutdown = FALSE;
gboolean ob_restart = FALSE;
startup_save();
if (screen_annex()) { /* it will be ours! */
+ ob_render_inst = RrInstanceNew(ob_display, ob_screen);
+
/* startup the parsing so everything can register sections of the rc */
parse_startup();
/* anything that is going to read data from the rc file needs to be
in this group */
timer_startup();
- render_startup();
- font_startup();
- theme_startup();
event_startup();
grab_startup();
plugin_startup();
parse_shutdown();
/* load the theme specified in the rc file */
+/*
theme = theme_load(config_theme);
g_free(theme);
if (!theme) return 1;
+*/
window_startup();
menu_startup();
window_shutdown();
grab_shutdown();
event_shutdown();
- theme_shutdown();
- render_shutdown();
timer_shutdown();
config_shutdown();
+
+ RrInstanceFree(ob_render_inst);
}
dispatch_shutdown();
/*! The root window */
extern Window ob_root;
+struct RrInstance;
+extern struct RrInstance *ob_render_inst;
+
/*! States of execution for Openbox */
typedef enum {
State_Starting,
#include "frame.h"
#include "window.h"
#include "stacking.h"
-#include "render/render.h"
-#include "render/theme.h"
+#include "render2/render.h"
+
+/* XXX temp */
+static int theme_bevel = 1;
+static int theme_bwidth = 3;
typedef struct Popup {
ObWindow obwin;
Window text;
gboolean hasicon;
- Appearance *a_bg;
- Appearance *a_icon;
- Appearance *a_text;
+ struct RrSurface *s_bg;
+ struct RrSurface *s_icon;
+ struct RrSurface *s_text;
int gravity;
int x;
int y;
int w;
int h;
- gboolean mapped;
} Popup;
Popup *popup_new(gboolean hasicon)
{
- Popup *self = g_new(Popup, 1);
+ XSetWindowAttributes attrib;
+ Popup *self;
+
+ self = g_new(Popup, 1);
self->obwin.type = Window_Internal;
self->hasicon = hasicon;
- self->bg = None;
- self->a_text = NULL;
self->gravity = NorthWestGravity;
self->x = self->y = self->w = self->h = 0;
- self->mapped = FALSE;
stacking_add(INTERNAL_AS_WINDOW(self));
stacking_raise(INTERNAL_AS_WINDOW(self));
+
+ attrib.override_redirect = True;
+ self->bg = XCreateWindow(ob_display, ob_root,
+ 0, 0, 1, 1, 0, RrInstanceDepth(ob_render_inst),
+ InputOutput, RrInstanceVisual(ob_render_inst),
+ CWOverrideRedirect, &attrib);
+ self->s_bg = RrSurfaceNew(ob_render_inst, RR_SURFACE_PLANAR, self->bg, 0);
+ self->s_text = RrSurfaceNewChild(RR_SURFACE_PLANAR, self->s_bg, 1);
+ self->text = RrSurfaceWindow(self->s_text);
+ if (self->hasicon) {
+ self->s_icon = RrSurfaceNewChild(RR_SURFACE_PLANAR, self->s_bg, 1);
+ self->icon = RrSurfaceWindow(self->s_icon);
+ } else {
+ self->s_icon = NULL;
+ self->icon = None;
+ }
+
+ /* XXX COPY THE APPEARANCES FROM THE THEME...... LIKE THIS SORTA!
+ self->a_text = appearance_copy(theme_app_hilite_label);
+ */
+
return self;
}
void popup_free(Popup *self)
{
- if (self->bg) {
- XDestroyWindow(ob_display, self->bg);
- XDestroyWindow(ob_display, self->text);
- XDestroyWindow(ob_display, self->icon);
- appearance_free(self->a_bg);
- if (self->hasicon)
- appearance_free(self->a_icon);
- }
- if (self->a_text)
- appearance_free(self->a_text);
+ RrSurfaceFree(self->s_bg);
+ RrSurfaceFree(self->s_icon);
+ RrSurfaceFree(self->s_text);
+ XDestroyWindow(ob_display, self->bg);
stacking_remove(self);
g_free(self);
}
int textw, texth;
int iconw;
- if (!self->a_text)
- self->a_text = appearance_copy(theme_app_hilite_label);
-
- self->a_text->texture[0].data.text.string = text;
- appearance_minsize(self->a_text, &textw, &texth);
+ RrTextureSetText(self->s_text, 0, NULL, RR_LEFT, text);
+ RrSurfaceMinSize(self->s_text, &textw, &texth);
textw += theme_bevel * 2;
texth += theme_bevel * 2;
- self->h = texth + theme_bevel * 2;
- iconw = (self->hasicon ? texth : 0);
- self->w = textw + iconw + theme_bevel * 3;
+ self->h = texth + theme_bevel * 2 + theme_bwidth * 2;
+ iconw = (self->hasicon ? texth + theme_bevel : 0);
+ self->w = textw + iconw + theme_bevel * 2 + theme_bwidth * 2;
}
void popup_show(Popup *self, char *text, Icon *icon)
{
- XSetWindowAttributes attrib;
int x, y, w, h;
int textw, texth;
int iconw;
- /* create the shit if needed */
- if (!self->bg) {
- attrib.override_redirect = True;
- self->bg = XCreateWindow(ob_display, ob_root,
- 0, 0, 1, 1, 0, render_depth, InputOutput,
- render_visual, CWOverrideRedirect, &attrib);
-/*
- XSetWindowBorderWidth(ob_display, self->bg, theme_bwidth);
- XSetWindowBorder(ob_display, self->bg, theme_b_color->pixel);
-*/
- self->text = XCreateWindow(ob_display, self->bg,
- 0, 0, 1, 1, 0, render_depth, InputOutput,
- render_visual, 0, NULL);
- if (self->hasicon)
- self->icon = XCreateWindow(ob_display, self->bg,
- 0, 0, 1, 1, 0,
- render_depth, InputOutput,
- render_visual, 0, NULL);
-
- XMapWindow(ob_display, self->text);
- XMapWindow(ob_display, self->icon);
-
- self->a_bg = appearance_copy(theme_app_hilite_bg);
- if (self->hasicon)
- self->a_icon = appearance_copy(theme_app_icon);
- }
- if (!self->a_text)
- self->a_text = appearance_copy(theme_app_hilite_label);
-
/* set up the textures */
- self->a_text->texture[0].data.text.string = text;
- if (self->hasicon) {
- if (icon) {
- self->a_icon->texture[0].type = RGBA;
- self->a_icon->texture[0].data.rgba.width = icon->width;
- self->a_icon->texture[0].data.rgba.height = icon->height;
- self->a_icon->texture[0].data.rgba.data = icon->data;
- } else
- self->a_icon->texture[0].type = NoTexture;
- }
+ RrTextureSetText(self->s_text, 0, NULL, RR_LEFT, text);
/* measure the shit out */
- appearance_minsize(self->a_text, &textw, &texth);
+ RrSurfaceMinSize(self->s_text, &textw, &texth);
textw += theme_bevel * 2;
texth += theme_bevel * 2;
iconw = (self->hasicon ? texth : 0);
if (self->w) {
w = self->w;
- textw = w - (iconw + theme_bevel * 3);
+ textw = w - (iconw + theme_bevel * (self->hasicon ? 3 : 2));
} else
- w = textw + iconw + theme_bevel * 3;
+ w = textw + iconw + theme_bevel * (self->hasicon ? 3 : 2);
/* sanity checks to avoid crashes! */
if (w < 1) w = 1;
if (h < 1) h = 1;
break;
}
- /* set the windows/appearances up */
- RECT_SET(self->a_bg->area, 0, 0, w, h);
- XMoveResizeWindow(ob_display, self->bg, x, y, w, h);
+ /* set the surfaces up */
+ RrSurfaceSetArea(self->s_bg, x, y, w, h);
- RECT_SET(self->a_text->area, 0, 0, textw, texth);
- RECT_SET(self->a_text->texture[0].position, theme_bevel, theme_bevel,
- textw - theme_bevel * 2, texth - theme_bevel * 2);
- self->a_text->surface.data.planar.parent = self->a_bg;
- self->a_text->surface.data.planar.parentx = iconw + theme_bevel * 2;
- self->a_text->surface.data.planar.parenty = theme_bevel;
- XMoveResizeWindow(ob_display, self->text,
- iconw + theme_bevel * 2, theme_bevel, textw, texth);
+ RrSurfaceSetArea(self->s_text,
+ iconw + theme_bevel * (self->hasicon ? 3 : 2) +
+ theme_bwidth,
+ theme_bevel + theme_bwidth,
+ textw, texth);
if (self->hasicon) {
+ RrTextureSetRGBA(self->s_icon, 0, icon->data, 0, 0, icon->width,
+ icon->height);
if (iconw < 1) iconw = 1; /* sanity check for crashes */
- RECT_SET(self->a_icon->area, 0, 0, iconw, texth);
- RECT_SET(self->a_icon->texture[0].position, 0, 0, iconw, texth);
- self->a_icon->surface.data.planar.parent = self->a_bg;
- self->a_icon->surface.data.planar.parentx = theme_bevel;
- self->a_icon->surface.data.planar.parenty = theme_bevel;
- XMoveResizeWindow(ob_display, self->icon,
- theme_bevel, theme_bevel, iconw, texth);
+ RrSurfaceSetArea(self->s_icon,
+ theme_bwidth + theme_bevel,
+ theme_bwidth + theme_bevel,
+ iconw, iconw);
}
- paint(self->bg, self->a_bg);
- paint(self->text, self->a_text);
- if (self->hasicon)
- paint(self->icon, self->a_icon);
-
- if (!self->mapped) {
- XMapWindow(ob_display, self->bg);
+ if (!RrSurfaceVisible(self->s_bg)) {
+ RrSurfaceShow(self->s_bg);
stacking_raise(INTERNAL_AS_WINDOW(self));
- self->mapped = TRUE;
}
}
void popup_hide(Popup *self)
{
- if (self->mapped) {
- XUnmapWindow(ob_display, self->bg);
- self->mapped = FALSE;
+ if (RrSurfaceVisible(self->s_bg)) {
+ RrSurfaceHide(self->s_bg);
}
}
#include "focus.h"
#include "dispatch.h"
#include "extensions.h"
-#include "../render/render.h"
#ifdef USE_LIBSN
# define SN_API_NOT_YET_FROZEN
{
switch (self->type) {
case Window_Menu:
- return ((Menu*)self)->frame;
+ return ((Menu*)self)->w_frame;
case Window_Dock:
return ((Dock*)self)->frame;
case Window_DockApp:
#include "kernel/frame.h"
-#include "render/theme.h"
-
static char *PLUGIN_NAME = "client_menu";
static Menu *send_to_menu;
g_assert(!self->invalid);
g_assert(client);
-/* XXX
- newy = MAX(client->frame->area.y +
- client->frame->a_focused_title->area.height + theme_bwidth,
- y - theme_bwidth);
-XXX */
-
+ newy = MAX(client->frame->area.y + client->frame->size.top, y);
+
POINT_SET(self->location,
- MIN(x, screen_physical_size.width - self->size.width -
- theme_bwidth * 2),
- MIN(newy, screen_physical_size.height - self->size.height -
- theme_bwidth * 2));
- XMoveWindow(ob_display, self->frame, self->location.x, self->location.y);
+ MIN(x, screen_physical_size.width - self->size.width),
+ MIN(newy, screen_physical_size.height - self->size.height));
+ menu_render(self);
if (!self->shown) {
- XMapWindow(ob_display, self->frame);
+ RrSurfaceShow(self->s_frame);
stacking_raise(MENU_AS_WINDOW(self));
self->shown = TRUE;
- } else if (self->shown && self->open_submenu) {
- menu_hide(self->open_submenu);
+ } else if (self->shown && self->open_submenu) { /* XXX is this right? */
+ RrSurfaceHide(self->s_frame);
+ self->shown = FALSE;
}
}
projects / dana / openbox.git / commitdiff