nilix/openbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

new focus cycle popup of doom

Browse source
This commit is contained in:
Dana Jansens 2007-05-19 18:40:37 +00:00
parent 83eb922012
commit 53066b1808
4 changed files with 476 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

432
openbox/focus_cycle_popup.c Normal file
View file

@ -0,0 +1,432 @@
/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
focus_cycle_popup.c for the Openbox window manager
Copyright (c) 2006 Mikael Magnusson
Copyright (c) 2003-2007 Dana Jansens
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
See the COPYING file for a copy of the GNU General Public License.
*/
#include "focus_cycle_popup.h"
#include "popup.h"
#include "client.h"
#include "screen.h"
#include "focus.h"
#include "focus_cycle.h"
#include "openbox.h"
#include "window.h"
#include "render/render.h"
#include <X11/Xlib.h>
#include <glib.h>
#define ICON_SIZE 48
#define ICON_HILITE_WIDTH 2
typedef struct _ObFocusCyclePopup ObFocusCyclePopup;
typedef struct _ObFocusCyclePopupTarget ObFocusCyclePopupTarget;
struct _ObFocusCyclePopupTarget
{
ObClient *client;
gchar *text;
Window win;
};
struct _ObFocusCyclePopup
{
ObWindow obwin;
Window bg;
Window text;
GList *targets;
gint n_targets;
ObFocusCyclePopupTarget *last_target;
gint maxtextw;
RrAppearance *a_bg;
RrAppearance *a_text;
RrAppearance *a_icon;
RrPixel32 *hilite_rgba;
gboolean mapped;
};
static ObFocusCyclePopup popup;
static gchar *popup_get_name (ObClient *c);
static void popup_setup (ObFocusCyclePopup *p,gboolean all_desktops,
gboolean dock_windows, gboolean desktop_windows);
static void popup_render (ObFocusCyclePopup *p, const ObClient *c);
static Window create_window(Window parent, guint bwidth, gulong mask,
XSetWindowAttributes *attr)
{
return XCreateWindow(ob_display, parent, 0, 0, 1, 1, bwidth,
RrDepth(ob_rr_inst), InputOutput,
RrVisual(ob_rr_inst), mask, attr);
}
void focus_cycle_popup_startup(gboolean reconfig)
{
XSetWindowAttributes attrib;
popup.obwin.type = Window_Internal;
popup.a_bg = RrAppearanceCopy(ob_rr_theme->osd_hilite_bg);
popup.a_text = RrAppearanceCopy(ob_rr_theme->osd_hilite_label);
popup.a_icon = RrAppearanceCopy(ob_rr_theme->a_clear_tex);
popup.a_text->surface.parent = popup.a_bg;
popup.a_icon->surface.parent = popup.a_bg;
popup.a_icon->texture[0].type = RR_TEXTURE_RGBA;
RrAppearanceAddTextures(popup.a_bg, 1);
popup.a_bg->texture[0].type = RR_TEXTURE_RGBA;
attrib.override_redirect = True;
attrib.border_pixel=RrColorPixel(ob_rr_theme->frame_focused_border_color);
popup.bg = create_window(RootWindow(ob_display, ob_screen),
ob_rr_theme->fbwidth,
CWOverrideRedirect | CWBorderPixel, &attrib);
popup.text = create_window(popup.bg, 0, 0, NULL);
popup.targets = NULL;
popup.n_targets = 0;
popup.last_target = NULL;
popup.hilite_rgba = NULL;
XMapWindow(ob_display, popup.text);
stacking_add(INTERNAL_AS_WINDOW(&popup));
}
void focus_cycle_popup_shutdown(gboolean reconfig)
{
stacking_remove(INTERNAL_AS_WINDOW(&popup));
while(popup.targets) {
ObFocusCyclePopupTarget *t = popup.targets->data;
g_free(t->text);
XDestroyWindow(ob_display, t->win);
popup.targets = g_list_delete_link(popup.targets, popup.targets);
}
g_free(popup.hilite_rgba);
XDestroyWindow(ob_display, popup.text);
XDestroyWindow(ob_display, popup.bg);
RrAppearanceFree(popup.a_icon);
RrAppearanceFree(popup.a_text);
RrAppearanceFree(popup.a_bg);
}
static void popup_setup(ObFocusCyclePopup *p,gboolean all_desktops,
gboolean dock_windows, gboolean desktop_windows)
{
gint maxwidth, n;
GList *it;
g_assert(p->targets == NULL);
g_assert(p->n_targets == 0);
/* make its width to be the width of all the possible titles */
/* build a list of all the valid focus targets and measure their strings,
and count them */
maxwidth = 0;
n = 0;
for (it = g_list_last(focus_order); it; it = g_list_previous(it)) {
ObClient *ft = it->data;
if (focus_cycle_target_valid(ft,
all_desktops,
dock_windows,
desktop_windows))
{
ObFocusCyclePopupTarget *t = g_new(ObFocusCyclePopupTarget, 1);
t->client = ft;
t->text = popup_get_name(ft);
t->win = create_window(p->bg, 0, 0, NULL);
XMapWindow(ob_display, t->win);
/* measure */
p->a_text->texture[0].data.text.string = t->text;
maxwidth = MAX(maxwidth, RrMinWidth(p->a_text));
p->targets = g_list_prepend(p->targets, t);
++n;
}
}
p->n_targets = n;
p->maxtextw = maxwidth;
}
static gchar *popup_get_name(ObClient *c)
{
ObClient *p;
gchar *title = NULL;
const gchar *desk = NULL;
gchar *ret;
/* find our highest direct parent, including non-normal windows */
for (p = c; p->transient_for && p->transient_for != OB_TRAN_GROUP;
p = p->transient_for);
if (c->desktop != DESKTOP_ALL && c->desktop != screen_desktop)
desk = screen_desktop_names[c->desktop];
/* use the transient's parent's title/icon if we don't have one */
if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title)))
title = g_strdup(p->iconic ? p->icon_title : p->title);
if (title == NULL)
title = g_strdup(c->iconic ? c->icon_title : c->title);
if (desk)
ret = g_strdup_printf("%s [%s]", title, desk);
else {
ret = title;
title = NULL;
}
g_free(title);
return ret;
}
static void popup_render(ObFocusCyclePopup *p, const ObClient *c)
{
gint l, t, r, b;
gint x, y, w, h;
Rect *screen_area;
gint icons_per_row;
gint icon_rows;
gint textx, texty, textw, texth;
gint iconw, iconh;
gint i;
GList *it;
const ObFocusCyclePopupTarget *newtarget;
gint newtargetx, newtargety;
/* XXX find the middle monitor? */
screen_area = screen_physical_area_monitor(0);
/* get the outside margins */
RrMargins(p->a_bg, &l, &t, &r, &b);
l += ob_rr_theme->paddingx;
r += ob_rr_theme->paddingx;
t += ob_rr_theme->paddingy;
b += ob_rr_theme->paddingy;
/* get the icons sizes */
iconw = ICON_SIZE - (ICON_HILITE_WIDTH + ob_rr_theme->paddingx) * 2;
iconh = ICON_SIZE - (ICON_HILITE_WIDTH + ob_rr_theme->paddingy) * 2;
/* get the width from the text and keep it within limits */
w = l + r + p->maxtextw;
w = MIN(w, MAX(screen_area->width/3, POPUP_WIDTH)); /* max width */
w = MAX(w, POPUP_WIDTH); /* min width */
/* how many icons will fit in that row? make the width fit that */
w -= l + r;
icons_per_row = w / ICON_SIZE;
w = icons_per_row * ICON_SIZE + l + r;
/* how many rows do we need? */
icon_rows = (p->n_targets-1) / icons_per_row + 1;
/* get the text dimensions */
textw = w - l - r;
texth = RrMinHeight(p->a_text);
/* find the height of the dialog */
h = t + b + (icon_rows * ICON_SIZE) + (ob_rr_theme->paddingy + texth);
/* get the position of the text */
textx = l;
texty = h - texth;
/* find the position for the popup (include the outer borders) */
x = screen_area->x + (screen_area->width -
(w + ob_rr_theme->fbwidth * 2)) / 2;
y = screen_area->y + (screen_area->height -
(h + ob_rr_theme->fbwidth * 2)) / 2;
if (!p->mapped) {
/* position the background but don't draw it*/
XMoveResizeWindow(ob_display, p->bg, x, y, w, h);
/* set up the hilite texture for the background */
p->a_bg->texture[0].data.rgba.width = w;
p->a_bg->texture[0].data.rgba.height = h;
p->hilite_rgba = g_new(RrPixel32, w * h);
p->a_bg->texture[0].data.rgba.data = p->hilite_rgba;
/* position the text, but don't draw it */
XMoveResizeWindow(ob_display, p->text, textx, texty, textw, texth);
p->a_text->surface.parentx = textx;
p->a_text->surface.parenty = texty;
}
/* find the focused target */
for (i = 0, it = p->targets; it; ++i, it = g_list_next(it)) {
const ObFocusCyclePopupTarget *target = it->data;
const gint row = i / icons_per_row; /* starting from 0 */
const gint col = i % icons_per_row; /* starting from 0 */
if (target->client == c) {
/* save the target */
newtarget = target;
newtargetx = l + (col * ICON_SIZE);
newtargety = t + (row * ICON_SIZE);
if (!p->mapped)
break; /* if we're not dimensioning, then we're done */
}
}
g_assert(newtarget != NULL);
/* create the hilite under the target icon */
{
RrPixel32 color = 0;
gint i, j;
memset(p->hilite_rgba, color, w * h * sizeof(RrPixel32));
for (i = 0; i < ICON_SIZE; ++i)
for (j = 0; j < ICON_SIZE; ++j) {
guchar a;
if (i < ICON_HILITE_WIDTH ||
i >= ICON_SIZE-ICON_HILITE_WIDTH ||
j < ICON_HILITE_WIDTH ||
j >= ICON_SIZE-ICON_HILITE_WIDTH)
{
/* the border of the target */
a = 0x88;
}
else {
/* the background of the target */
a = 0x33;
}
p->hilite_rgba[(i+newtargety) * w + (j+newtargetx)] =
color + (a << RrDefaultAlphaOffset);
}
}
/* * * draw everything * * */
/* draw the background */
RrPaint(p->a_bg, p->bg, w, h);
/* draw the icons */
for (i = 0, it = p->targets; it; ++i, it = g_list_next(it)) {
const ObFocusCyclePopupTarget *target = it->data;
/* have to redraw the targetted icon and last targetted icon,
they can pick up the hilite changes in the backgroud */
if (!p->mapped || newtarget == target || p->last_target == target) {
const ObClientIcon *icon;
const gint row = i / icons_per_row; /* starting from 0 */
const gint col = i % icons_per_row; /* starting from 0 */
gint iconx, icony;
/* find the dimensions of the icon inside it */
iconx = l + (col * ICON_SIZE) + ICON_HILITE_WIDTH +
ob_rr_theme->paddingx;
icony = t + (row * ICON_SIZE) + ICON_HILITE_WIDTH +
ob_rr_theme->paddingy;
/* move the icon */
XMoveResizeWindow(ob_display, target->win,
iconx, icony, iconw, iconh);
/* get the icon from the client */
icon = client_icon(target->client, iconw, iconh);
p->a_icon->texture[0].data.rgba.width = icon->width;
p->a_icon->texture[0].data.rgba.height = icon->height;
p->a_icon->texture[0].data.rgba.data = icon->data;
/* draw the icon */
p->a_icon->surface.parentx = iconx;
p->a_icon->surface.parenty = icony;
RrPaint(p->a_icon, target->win, iconw, iconh);
}
}
/* draw the text */
p->a_text->texture[0].data.text.string = newtarget->text;
p->a_text->surface.parentx = textx;
p->a_text->surface.parenty = texty;
RrPaint(p->a_text, p->text, textw, texth);
p->last_target = newtarget;
}
void focus_cycle_popup_show(ObClient *c,
gboolean all_desktops, gboolean dock_windows,
gboolean desktop_windows)
{
g_assert(c != NULL);
/* do this stuff only when the dialog is first showing */
if (!popup.mapped)
popup_setup(&popup, all_desktops, dock_windows, desktop_windows);
g_assert(popup.targets != NULL);
popup_render(&popup, c);
if (!popup.mapped) {
/* show the dialog */
XMapWindow(ob_display, popup.bg);
XFlush(ob_display);
popup.mapped = TRUE;
}
}
void focus_cycle_popup_hide()
{
XUnmapWindow(ob_display, popup.bg);
XFlush(ob_display);
popup.mapped = FALSE;
while(popup.targets) {
ObFocusCyclePopupTarget *t = popup.targets->data;
g_free(t->text);
XDestroyWindow(ob_display, t->win);
popup.targets = g_list_delete_link(popup.targets, popup.targets);
}
popup.n_targets = 0;
popup.last_target = NULL;
g_free(popup.hilite_rgba);
popup.hilite_rgba = NULL;
}

35
openbox/focus_cycle_popup.h Normal file
View file

@ -0,0 +1,35 @@
/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
focus_cycle.h for the Openbox window manager
Copyright (c) 2006 Mikael Magnusson
Copyright (c) 2003-2007 Dana Jansens
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
See the COPYING file for a copy of the GNU General Public License.
*/
#ifndef __focus_cycle_popup_h
#define __focus_cycle_popup_h
struct _ObClient;
#include <glib.h>
void focus_cycle_popup_startup(gboolean reconfig);
void focus_cycle_popup_shutdown(gboolean reconfig);
void focus_cycle_popup_show(struct _ObClient *c,
gboolean all_desktops, gboolean dock_windows,
gboolean desktop_windows);
void focus_cycle_popup_hide();
#endif

8
render/render.c
View file

@ -194,6 +194,14 @@ RrAppearance *RrAppearanceNew(const RrInstance *inst, gint numtex)
return out;
}
void RrAppearanceAddTextures(RrAppearance *a, gint numtex)
{
g_assert(a->textures == 0);
a->textures = numtex;
if (numtex) a->texture = g_new0(RrTexture, numtex);
}
RrAppearance *RrAppearanceCopy(RrAppearance *orig)
{
RrSurface *spo, *spc;

1
render/render.h
View file

@ -230,6 +230,7 @@ GC RrColorGC (RrColor *c);
RrAppearance *RrAppearanceNew (const RrInstance *inst, gint numtex);
RrAppearance *RrAppearanceCopy (RrAppearance *a);
void RrAppearanceFree (RrAppearance *a);
void RrAppearanceAddTextures(RrAppearance *a, gint numtex);
RrFont *RrFontOpen (const RrInstance *inst, const gchar *name, gint size,
RrFontWeight weight, RrFontSlant slant);