Mabox/tint2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup: area.h

Browse Source
This commit is contained in:
o9000
2015-11-18 21:57:10 +01:00
parent 5f41544089
commit c0e62e2e79
19 changed files with 502 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
src/util/area.c
View File

@@ -30,50 +30,9 @@
#include "server.h"
#include "panel.h"
/************************************************************
* !!! This design is experimental and not yet fully implemented !!!!!!!!!!!!!
*
* DATA ORGANISATION :
* Areas in tint2 are similar to widgets in a GUI.
* All graphical objects (panel, taskbar, task, systray, clock, ...) 'inherit' an abstract class 'Area'.
* This class 'Area' manage the background, border, size, position and padding.
* Area is at the begining of each object (&object == &area).
*
* tint2 define one panel per monitor. And each panel have a tree of Area.
* The root of the tree is Panel.Area. And task, clock, systray, taskbar,... are nodes.
*
* The tree give the localisation of each object :
* - tree's root is in the background while tree's leafe are foreground objects
* - position of a node/Area depend on the layout : parent's position (posx, posy), size of previous brothers and parent's padding
* - size of a node/Area depend on the content (SIZE_BY_CONTENT objects) or on the layout (SIZE_BY_LAYOUT objects)
*
* DRAWING AND LAYERING ENGINE :
* Redrawing an object (like the clock) could come from an 'external event' (date change)
* or from a 'layering event' (position change).
* The following 'drawing engine' take care of :
* - posx/posy of all Area
* - 'layering event' propagation between object
* 1) browse tree SIZE_BY_CONTENT
* - resize SIZE_BY_CONTENT node : children are resized before parent
* - if 'size' changed then 'resize = 1' on the parent
* 2) browse tree SIZE_BY_LAYOUT and POSITION
* - resize SIZE_BY_LAYOUT node : parent is resized before children
* - calculate position (posx,posy) : parent is calculated before children
* - if 'position' changed then 'redraw = 1'
* 3) browse tree REDRAW
* - redraw needed objects : parent is drawn before children
*
* CONFIGURE PANEL'S LAYOUT :
* 'panel_items' parameter (in config) define the list and the order of nodes in tree's panel.
* 'panel_items = SC' define a panel with just Systray and Clock.
* So the tree 'Panel.Area' will have 2 childs (Systray and Clock).
*
************************************************************/
Area *mouse_over_area = NULL;
void init_rendering(void *obj, int pos)
void initialize_positions(void *obj, int pos)
{
Area *a = (Area*)obj;
@@ -86,58 +45,47 @@ void init_rendering(void *obj, int pos)
child->height = a->height - (2 * (a->bg->border.width + a->paddingy));
if (child->_on_change_layout)
child->_on_change_layout(child);
init_rendering(child, child->posy);
initialize_positions(child, child->posy);
}
else {
child->posx = pos + a->bg->border.width + a->paddingy;
child->width = a->width - (2 * (a->bg->border.width + a->paddingy));
if (child->_on_change_layout)
child->_on_change_layout(child);
init_rendering(child, child->posx);
initialize_positions(child, child->posx);
}
}
}
void rendering(void *obj)
void _relayout_fixed(Area *a)
{
Panel *panel = (Panel*)obj;
size_by_content(&panel->area);
size_by_layout(&panel->area, 1);
refresh(&panel->area);
}
void size_by_content (Area *a)
{
// don't resize hiden objects
if (!a->on_screen)
return;
// children node are resized before its parent
// Children are resized before the parent
GList *l;
for (l = a->children; l ; l = l->next)
size_by_content(l->data);
_relayout_fixed(l->data);
// calculate area's size
a->on_changed = 0;
if (a->resize && a->size_mode == SIZE_BY_CONTENT) {
a->resize = 0;
// Recalculate size
a->_changed = 0;
if (a->resize_needed && a->size_mode == LAYOUT_FIXED) {
a->resize_needed = 0;
if (a->_resize) {
if (a->_resize(a)) {
// 'size' changed => 'resize = 1' on the parent
((Area*)a->parent)->resize = 1;
a->on_changed = 1;
// The size hash changed => resize needed for the parent
if (a->parent)
((Area*)a->parent)->resize_needed = 1;
a->_changed = 1;
}
}
}
}
void size_by_layout (Area *a, int level)
void _relayout_dynamic(Area *a, int level)
{
// don't resize hiden objects
if (!a->on_screen)
@@ -146,16 +94,16 @@ void size_by_layout (Area *a, int level)
// parent node is resized before its children
// calculate area's size
GList *l;
if (a->resize && a->size_mode == SIZE_BY_LAYOUT) {
a->resize = 0;
if (a->resize_needed && a->size_mode == LAYOUT_DYNAMIC) {
a->resize_needed = 0;
if (a->_resize) {
a->_resize(a);
// resize childs with SIZE_BY_LAYOUT
// resize children with LAYOUT_DYNAMIC
for (l = a->children; l ; l = l->next) {
Area *child = ((Area*)l->data);
if (child->size_mode == SIZE_BY_LAYOUT && child->children)
child->resize = 1;
if (child->size_mode == LAYOUT_DYNAMIC && child->children)
child->resize_needed = 1;
}
}
}
@@ -174,17 +122,17 @@ void size_by_layout (Area *a, int level)
if (pos != child->posx) {
// pos changed => redraw
child->posx = pos;
child->on_changed = 1;
child->_changed = 1;
}
} else {
if (pos != child->posy) {
// pos changed => redraw
child->posy = pos;
child->on_changed = 1;
child->_changed = 1;
}
}
size_by_layout(child, level+1);
_relayout_dynamic(child, level+1);
pos += panel_horizontal ? child->width + a->paddingx : child->height + a->paddingx;
}
@@ -202,17 +150,17 @@ void size_by_layout (Area *a, int level)
if (pos != child->posx) {
// pos changed => redraw
child->posx = pos;
child->on_changed = 1;
child->_changed = 1;
}
} else {
if (pos != child->posy) {
// pos changed => redraw
child->posy = pos;
child->on_changed = 1;
child->_changed = 1;
}
}
size_by_layout(child, level+1);
_relayout_dynamic(child, level+1);
pos -= a->paddingx;
}
@@ -241,76 +189,77 @@ void size_by_layout (Area *a, int level)
if (pos != child->posx) {
// pos changed => redraw
child->posx = pos;
child->on_changed = 1;
child->_changed = 1;
}
} else {
if (pos != child->posy) {
// pos changed => redraw
child->posy = pos;
child->on_changed = 1;
child->_changed = 1;
}
}
size_by_layout(child, level+1);
_relayout_dynamic(child, level+1);
pos += panel_horizontal ? child->width + a->paddingx : child->height + a->paddingx;
}
}
}
if (a->on_changed) {
if (a->_changed) {
// pos/size changed
a->redraw = 1;
a->redraw_needed = 1;
if (a->_on_change_layout)
a->_on_change_layout (a);
}
}
void refresh (Area *a)
void draw_tree (Area *a)
{
// don't draw and resize hide objects
if (!a->on_screen) return;
if (!a->on_screen)
return;
// don't draw transparent objects (without foreground and without background)
if (a->redraw) {
a->redraw = 0;
if (a->redraw_needed) {
a->redraw_needed = 0;
// force redraw of child
//GList *l;
//for (l = a->children ; l ; l = l->next)
//((Area*)l->data)->redraw = 1;
//((Area*)l->data)->redraw_needed = 1;
//printf("draw area posx %d, width %d\n", a->posx, a->width);
draw(a);
}
// draw current Area
if (a->pix == 0) printf("empty area posx %d, width %d\n", a->posx, a->width);
XCopyArea (server.dsp, a->pix, ((Panel *)a->panel)->temp_pmap, server.gc, 0, 0, a->width, a->height, a->posx, a->posy);
if (a->pix == 0)
printf("empty area posx %d, width %d\n", a->posx, a->width);
XCopyArea(server.dsp, a->pix, ((Panel *)a->panel)->temp_pmap, server.gc, 0, 0, a->width, a->height, a->posx, a->posy);
// and then refresh child object
// and then draw child objects
GList *l;
for (l = a->children; l ; l = l->next)
refresh((Area*)l->data);
draw_tree((Area*)l->data);
}
int resize_by_layout(void *obj, int maximum_size)
int relayout_with_constraint(Area *a, int maximum_size)
{
Area *child, *a = (Area*)obj;
Area *child;
int size, nb_by_content=0, nb_by_layout=0;
if (panel_horizontal) {
// detect free size for SIZE_BY_LAYOUT's Area
// detect free size for LAYOUT_DYNAMIC's Area
size = a->width - (2 * (a->paddingxlr + a->bg->border.width));
GList *l;
for (l = a->children ; l ; l = l->next) {
child = (Area*)l->data;
if (child->on_screen && child->size_mode == SIZE_BY_CONTENT) {
if (child->on_screen && child->size_mode == LAYOUT_FIXED) {
size -= child->width;
nb_by_content++;
}
if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT)
if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC)
nb_by_layout++;
}
//printf(" resize_by_layout Deb %d, %d\n", nb_by_content, nb_by_layout);
@@ -327,10 +276,10 @@ int resize_by_layout(void *obj, int maximum_size)
}
}
// resize SIZE_BY_LAYOUT objects
// resize LAYOUT_DYNAMIC objects
for (l = a->children ; l ; l = l->next) {
child = (Area*)l->data;
if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT) {
if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC) {
old_width = child->width;
child->width = width;
if (modulo) {
@@ -338,21 +287,21 @@ int resize_by_layout(void *obj, int maximum_size)
modulo--;
}
if (child->width != old_width)
child->on_changed = 1;
child->_changed = 1;
}
}
}
else {
// detect free size for SIZE_BY_LAYOUT's Area
// detect free size for LAYOUT_DYNAMIC's Area
size = a->height - (2 * (a->paddingxlr + a->bg->border.width));
GList *l;
for (l = a->children ; l ; l = l->next) {
child = (Area*)l->data;
if (child->on_screen && child->size_mode == SIZE_BY_CONTENT) {
if (child->on_screen && child->size_mode == LAYOUT_FIXED) {
size -= child->height;
nb_by_content++;
}
if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT)
if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC)
nb_by_layout++;
}
if (nb_by_content+nb_by_layout)
@@ -368,10 +317,10 @@ int resize_by_layout(void *obj, int maximum_size)
}
}
// resize SIZE_BY_LAYOUT objects
// resize LAYOUT_DYNAMIC objects
for (l = a->children ; l ; l = l->next) {
child = (Area*)l->data;
if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT) {
if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC) {
int old_height = child->height;
child->height = height;
if (modulo) {
@@ -379,7 +328,7 @@ int resize_by_layout(void *obj, int maximum_size)
modulo--;
}
if (child->height != old_height)
child->on_changed = 1;
child->_changed = 1;
}
}
}
@@ -387,13 +336,13 @@ int resize_by_layout(void *obj, int maximum_size)
}
void set_redraw (Area *a)
void schedule_redraw(Area *a)
{
a->redraw = 1;
a->redraw_needed = 1;
GList *l;
for (l = a->children ; l ; l = l->next)
set_redraw((Area*)l->data);
schedule_redraw((Area*)l->data);
}
void hide(Area *a)
@@ -401,7 +350,8 @@ void hide(Area *a)
Area *parent = (Area*)a->parent;
a->on_screen = 0;
parent->resize = 1;
if (parent)
parent->resize_needed = 1;
if (panel_horizontal)
a->width = 0;
else
@@ -413,19 +363,21 @@ void show(Area *a)
Area *parent = (Area*)a->parent;
a->on_screen = 1;
parent->resize = 1;
a->resize = 1;
if (parent)
parent->resize_needed = 1;
a->resize_needed = 1;
}
void draw (Area *a)
void draw(Area *a)
{
if (a->pix) XFreePixmap (server.dsp, a->pix);
a->pix = XCreatePixmap (server.dsp, server.root_win, a->width, a->height, server.depth);
if (a->pix)
XFreePixmap(server.dsp, a->pix);
a->pix = XCreatePixmap(server.dsp, server.root_win, a->width, a->height, server.depth);
// add layer of root pixmap (or clear pixmap if real_transparency==true)
if (server.real_transparency)
clear_pixmap(a->pix, 0 ,0, a->width, a->height);
XCopyArea (server.dsp, ((Panel *)a->panel)->temp_pmap, a->pix, server.gc, a->posx, a->posy, a->width, a->height, 0, 0);
XCopyArea(server.dsp, ((Panel *)a->panel)->temp_pmap, a->pix, server.gc, a->posx, a->posy, a->width, a->height, 0, 0);
cairo_surface_t *cs;
cairo_t *c;
@@ -433,28 +385,28 @@ void draw (Area *a)
cs = cairo_xlib_surface_create (server.dsp, a->pix, server.visual, a->width, a->height);
c = cairo_create (cs);
draw_background (a, c);
draw_background(a, c);
if (a->_draw_foreground)
a->_draw_foreground(a, c);
cairo_destroy (c);
cairo_surface_destroy (cs);
cairo_destroy(c);
cairo_surface_destroy(cs);
}
void draw_background (Area *a, cairo_t *c)
{
if (a->bg->back.alpha > 0.0 ||
(panel_config.mouse_effects && (a->mouse_over_effect || a->mouse_press_effect))) {
//printf(" draw_background (%d %d) RGBA (%lf, %lf, %lf, %lf)\n", a->posx, a->posy, pix->back.color[0], pix->back.color[1], pix->back.color[2], pix->back.alpha);
if (a->bg->fill_color.alpha > 0.0 ||
(panel_config.mouse_effects && (a->has_mouse_over_effect || a->has_mouse_press_effect))) {
//printf(" draw_background (%d %d) RGBA (%lf, %lf, %lf, %lf)\n", a->posx, a->posy, pix->fill_color.rgb[0], pix->fill_color.rgb[1], pix->fill_color.rgb[2], pix->fill_color.alpha);
if (a->mouse_state == MOUSE_OVER)
cairo_set_source_rgba(c, a->bg->back_hover.color[0], a->bg->back_hover.color[1], a->bg->back_hover.color[2], a->bg->back_hover.alpha);
cairo_set_source_rgba(c, a->bg->fill_color_hover.rgb[0], a->bg->fill_color_hover.rgb[1], a->bg->fill_color_hover.rgb[2], a->bg->fill_color_hover.alpha);
else if (a->mouse_state == MOUSE_DOWN)
cairo_set_source_rgba(c, a->bg->back_pressed.color[0], a->bg->back_pressed.color[1], a->bg->back_pressed.color[2], a->bg->back_pressed.alpha);
cairo_set_source_rgba(c, a->bg->fill_color_pressed.rgb[0], a->bg->fill_color_pressed.rgb[1], a->bg->fill_color_pressed.rgb[2], a->bg->fill_color_pressed.alpha);
else
cairo_set_source_rgba(c, a->bg->back.color[0], a->bg->back.color[1], a->bg->back.color[2], a->bg->back.alpha);
draw_rect(c, a->bg->border.width, a->bg->border.width, a->width-(2.0 * a->bg->border.width), a->height-(2.0*a->bg->border.width), a->bg->border.rounded - a->bg->border.width/1.571);
cairo_set_source_rgba(c, a->bg->fill_color.rgb[0], a->bg->fill_color.rgb[1], a->bg->fill_color.rgb[2], a->bg->fill_color.alpha);
draw_rect(c, a->bg->border.width, a->bg->border.width, a->width-(2.0 * a->bg->border.width), a->height-(2.0*a->bg->border.width), a->bg->border.radius - a->bg->border.width/1.571);
cairo_fill(c);
}
@@ -463,27 +415,27 @@ void draw_background (Area *a, cairo_t *c)
// draw border inside (x, y, width, height)
if (a->mouse_state == MOUSE_OVER)
cairo_set_source_rgba(c, a->bg->border_hover.color[0], a->bg->border_hover.color[1], a->bg->border_hover.color[2], a->bg->border_hover.alpha);
cairo_set_source_rgba(c, a->bg->border_color_hover.rgb[0], a->bg->border_color_hover.rgb[1], a->bg->border_color_hover.rgb[2], a->bg->border_color_hover.alpha);
else if (a->mouse_state == MOUSE_DOWN)
cairo_set_source_rgba(c, a->bg->border_pressed.color[0], a->bg->border_pressed.color[1], a->bg->border_pressed.color[2], a->bg->border_pressed.alpha);
cairo_set_source_rgba(c, a->bg->border_color_pressed.rgb[0], a->bg->border_color_pressed.rgb[1], a->bg->border_color_pressed.rgb[2], a->bg->border_color_pressed.alpha);
else
cairo_set_source_rgba(c, a->bg->border.color[0], a->bg->border.color[1], a->bg->border.color[2], a->bg->border.alpha);
draw_rect(c, a->bg->border.width/2.0, a->bg->border.width/2.0, a->width - a->bg->border.width, a->height - a->bg->border.width, a->bg->border.rounded);
cairo_set_source_rgba(c, a->bg->border.color.rgb[0], a->bg->border.color.rgb[1], a->bg->border.color.rgb[2], a->bg->border.color.alpha);
draw_rect(c, a->bg->border.width/2.0, a->bg->border.width/2.0, a->width - a->bg->border.width, a->height - a->bg->border.width, a->bg->border.radius);
cairo_stroke(c);
}
}
void remove_area (void *a)
void remove_area(Area *a)
{
Area *area = (Area*)a;
Area *parent = (Area*)area->parent;
if (parent) {
parent->children = g_list_remove(parent->children, area);
parent->resize = 1;
set_redraw(parent);
parent->resize_needed = 1;
schedule_redraw(parent);
}
if (mouse_over_area == a) {
@@ -492,13 +444,15 @@ void remove_area (void *a)
}
void add_area (Area *a)
void add_area(Area *a, Area *parent)
{
Area *parent = (Area*)a->parent;
parent->children = g_list_append(parent->children, a);
set_redraw (parent);
g_assert_null(a->parent);
a->parent = parent;
if (parent) {
parent->children = g_list_append(parent->children, a);
schedule_redraw(parent);
}
}
@@ -525,34 +479,6 @@ void free_area (Area *a)
}
void draw_rect(cairo_t *c, double x, double y, double w, double h, double r)
{
if (r > 0.0) {
double c1 = 0.55228475 * r;
cairo_move_to(c, x+r, y);
cairo_rel_line_to(c, w-2*r, 0);
cairo_rel_curve_to(c, c1, 0.0, r, c1, r, r);
cairo_rel_line_to(c, 0, h-2*r);
cairo_rel_curve_to(c, 0.0, c1, c1-r, r, -r, r);
cairo_rel_line_to (c, -w +2*r, 0);
cairo_rel_curve_to (c, -c1, 0, -r, -c1, -r, -r);
cairo_rel_line_to (c, 0, -h + 2 * r);
cairo_rel_curve_to (c, 0, -c1, r - c1, -r, r, -r);
}
else
cairo_rectangle(c, x, y, w, h);
}
void clear_pixmap(Pixmap p, int x, int y, int w, int h)
{
Picture pict = XRenderCreatePicture(server.dsp, p, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0);
XRenderColor col = { .red=0, .green=0, .blue=0, .alpha=0 };
XRenderFillRectangle(server.dsp, PictOpSrc, pict, &col, x, y, w, h);
XRenderFreePicture(server.dsp, pict);
}
void mouse_over(Area *area, int pressed)
{
if (mouse_over_area == area && !area)
@@ -561,11 +487,11 @@ void mouse_over(Area *area, int pressed)
MouseState new_state = MOUSE_NORMAL;
if (area) {
if (!pressed) {
new_state = area->mouse_over_effect ? MOUSE_OVER : MOUSE_NORMAL;
new_state = area->has_mouse_over_effect ? MOUSE_OVER : MOUSE_NORMAL;
} else {
new_state = area->mouse_press_effect
new_state = area->has_mouse_press_effect
? MOUSE_DOWN
: area->mouse_over_effect
: area->has_mouse_over_effect
? MOUSE_OVER
: MOUSE_NORMAL;
}
@@ -579,7 +505,7 @@ void mouse_over(Area *area, int pressed)
mouse_over_area = area;
mouse_over_area->mouse_state = new_state;
set_redraw(mouse_over_area);
schedule_redraw(mouse_over_area);
panel_refresh = 1;
}
@@ -588,7 +514,7 @@ void mouse_out()
if (!mouse_over_area)
return;
mouse_over_area->mouse_state = MOUSE_NORMAL;
set_redraw(mouse_over_area);
schedule_redraw(mouse_over_area);
panel_refresh = 1;
mouse_over_area = NULL;
}
@@ -597,3 +523,9 @@ void init_background(Background *bg)
{
memset(bg, 0, sizeof(Background));
}
void relayout(Area *a)
{
_relayout_fixed(a);
_relayout_dynamic(a, 1);
}

300
src/util/area.h
View File

@@ -1,19 +1,6 @@
/**************************************************************************
* Copyright (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr)
*
* base class for all graphical objects (panel, taskbar, task, systray, clock, ...).
* Area is at the begining of each object (&object == &area).
*
* Area manage the background and border drawing, size and padding.
* Each Area has one Pixmap (pix).
*
* Area manage the tree of all objects. Parent object drawn before child object.
* panel -> taskbars -> tasks
* -> systray -> icons
* -> clock
*
* draw_foreground(obj) and resize(obj) are virtual function.
*
**************************************************************************/
#ifndef AREA_H
@@ -24,129 +11,250 @@
#include <cairo.h>
#include <cairo-xlib.h>
// DATA ORGANISATION
//
// Areas in tint2 are similar to widgets in a GUI.
// All graphical objects (panel, taskbar, task, systray, clock, ...) inherit the abstract class Area.
// This class 'Area' stores data about the background, border, size, position, padding and the child areas.
// Inheritance is simulated by having an Area member as the first member of each object (thus &object == &area).
//
// tint2 uses multiple panels, one per monitor. Each panel has an area containing the children objects in a tree of
// areas. The level in the tree gives the z-order: child areas are always displayed on top of their parents.
//
//
// LAYOUT
//
// Sibling areas never overlap.
//
// The position of an Area (posx, posy) is relative to the window (i.e. absolute) and
// is computed based on a simple box model:
// * parent position + parent padding + sum of the sizes of the previous siblings and spacing
//
// The size of an Area is:
// * SIZE_BY_CONTENT objects:
// * fixed and set by the Area
// * childred are resized before the parent
// * if a child size has changed then the parent is resized
// * SIZE_BY_LAYOUT objects:
// * expandable and computed as the total size of the parent - padding -
// the size of the fixed sized siblings - spacing and divided by the number of expandable siblings
// * the parent is resized before the children
//
//
// RENDERING
//
// Redrawing an object (like the clock) could come from an 'external event' (date change)
// or from a 'layout event' (position change).
//
//
// WIDGET LIFECYCLE
//
// Each widget that occurs once per panel is defined as a struct (e.g. Clock) which is stored as a member of Panel.
// Widgets that can occur more than once should be stored as an array, still as a member of Panel.
//
// There is a special Panel instance called 'panel_config' which stores the config options and the state variables
// of the widgets (however some config options are stored as global variables by the widgets).
//
// Tint2 maintains an array of Panel instances, one for each monitor. These contain the actual Areas that are used to
// render the panels on screen, interact with user input etc.
// Each Panel is initialized as a raw copy (memcpy, see init_panel()) of panel_config.
//
// Normally, widgets should implement the following functions:
//
// * void default_widget();
//
// Called before the config is read and panel_config/panels are created.
// Afterwards, the config parsing code creates the widget/widget array in panel_config and
// populates the configuration fields.
// If the widget uses global variables to store config options or other state variables, they should be initialized
// here (e.g. with zero, NULL etc).
//
// * void init_widget();
//
// Called after the config is read and panel_config is populated, but before panels are created.
// Initializes the state of the widget in panel_config.
// If the widget uses global variables to store config options or other state variables which depend on the config
// options but not on the panel instance, they should be initialized here.
// panel_config.panel_items can be used to determine which backend items are enabled.
//
// * void init_widget_panel(void *panel);
//
// Called after each on-screen panel is created, with a pointer to the panel.
// Completes the initialization of the widget.
// At this point the widget Area has not been added yet to the GUI tree, but it will be added right afterwards.
//
// * void cleanup_widget();
//
// Called just before the panels are destroyed. Afterwards, tint2 exits or restarts and reads the config again.
// Must releases all resources.
// The widget itself should not be freed by this function, only its members or global variables that were set.
// The widget is freed by the Area tree cleanup function (remove_area).
//
// * void draw_widget(void *obj, cairo_t *c);
//
// Called on draw, obj = pointer to the widget instance from the panel that is redrawn.
// The Area's _draw_foreground member must point to this function.
//
// * int resize_widget(void *obj);
//
// Called on resize, obj = pointer to the front-end Execp item.
// Returns 1 if the new size is different than the previous size.
// The Area's _resize member must point to this function.
//
// * void widget_action(void *obj, int button);
//
// Called on mouse click event.
//
// * void widget_on_change_layout(void *obj);
//
// Implemented only to override the default layout algorithm for this widget.
// For example, if this widget is a cell in a table, its position and size should be computed here.
// The Area's _on_change_layout member must point to this function.
//
// * char* widget_get_tooltip_text(void *obj);
//
// Returns a copy of the tooltip to be displayed for this widget.
// The caller takes ownership of the pointer.
// The Area's _get_tooltip_text member must point to this function.
typedef struct
{
double color[3];
double alpha;
int width;
int rounded;
} Border;
typedef struct
{
double color[3];
typedef struct Color {
// Values are in [0, 1], with 0 meaning no intensity.
double rgb[3];
// Values are in [0, 1], with 0 meaning fully transparent, 1 meaning fully opaque.
double alpha;
} Color;
typedef struct
{
Color back;
typedef struct Border {
// It's essential that the first member is color
Color color;
// Width in pixels
int width;
// Corner radius
int radius;
} Border;
typedef struct Background {
// Normal state
Color fill_color;
Border border;
Color back_hover;
Color border_hover;
Color back_pressed;
Color border_pressed;
// On mouse hover
Color fill_color_hover;
Color border_color_hover;
// On mouse press
Color fill_color_pressed;
Color border_color_pressed;
} Background;
typedef enum Layout {
LAYOUT_DYNAMIC,
LAYOUT_FIXED
} Layout;
// way to calculate the size
// SIZE_BY_LAYOUT objects : taskbar and task
// SIZE_BY_CONTENT objects : clock, battery, launcher, systray
enum { SIZE_BY_LAYOUT, SIZE_BY_CONTENT };
enum { ALIGN_LEFT = 0, ALIGN_CENTER = 1, ALIGN_RIGHT = 2 };
typedef enum Alignment {
ALIGN_LEFT = 0,
ALIGN_CENTER = 1,
ALIGN_RIGHT = 2
} Alignment;
typedef enum {
typedef enum MouseState {
MOUSE_NORMAL = 0,
MOUSE_OVER = 1,
MOUSE_DOWN = 2
} MouseState;
typedef struct {
// coordinate relative to panel window
typedef struct Area {
// Position relative to the panel window
int posx, posy;
// width and height including border
// Size, including borders
int width, height;
Pixmap pix;
Background *bg;
// list of child : Area object
// List of children, each one a pointer to Area
GList *children;
// object visible on screen.
// An object (like systray) could be enabled but hidden (because no tray icon).
int on_screen;
// way to calculate the size (SIZE_BY_CONTENT or SIZE_BY_LAYOUT)
int size_mode;
int alignment;
// need to calculate position and width
int resize;
// need redraw Pixmap
int redraw;
// paddingxlr = horizontal padding left/right
// paddingx = horizontal padding between childs
int paddingxlr, paddingx, paddingy;
// parent Area
// Pointer to the parent Area or NULL
void *parent;
// panel
// Pointer to the Panel that contains this Area
void *panel;
int mouse_over_effect;
int mouse_press_effect;
Layout size_mode;
Alignment alignment;
gboolean has_mouse_over_effect;
gboolean has_mouse_press_effect;
// TODO padding/spacing is a clusterfuck
// paddingxlr = padding
// paddingy = vertical padding, sometimes
// paddingx = spacing
int paddingxlr, paddingx, paddingy;
MouseState mouse_state;
// Set to non-zero if the Area is visible. An object may exist but stay hidden.
gboolean on_screen;
// Set to non-zero if the size of the Area has to be recalculated.
gboolean resize_needed;
// Set to non-zero if the Area has to be redrawn.
gboolean redraw_needed;
// Set to non-zero if the position/size has changed, thus _on_change_layout needs to be called
gboolean _changed;
// This is the pixmap on which the Area is rendered. Render to it directly if needed.
Pixmap pix;
// each object can overwrite following function
// Callbacks
// Called on draw, obj = pointer to the Area
void (*_draw_foreground)(void *obj, cairo_t *c);
// update area's content and update size (width/heith).
// return '1' if size changed, '0' otherwise.
// Called on resize, obj = pointer to the Area
// Returns 1 if the new size is different than the previous size.
int (*_resize)(void *obj);
// after pos/size changed, the rendering engine will call _on_change_layout(Area*)
int on_changed;
// Implemented only to override the default layout algorithm for this widget.
// For example, if this widget is a cell in a table, its position and size should be computed here.
void (*_on_change_layout)(void *obj);
// returns allocated string, that must be free'd after usage
// Returns a copy of the tooltip to be displayed for this widget.
// The caller takes ownership of the pointer.
char* (*_get_tooltip_text)(void *obj);
} Area;
// Initializes the Background member to default values.
void init_background(Background *bg);
// on startup, initialize fixed pos/size
void init_rendering(void *obj, int pos);
// Layout
void rendering(void *obj);
void size_by_content (Area *a);
void size_by_layout (Area *a, int level);
// draw background and foreground
void refresh (Area *a);
// generic resize for SIZE_BY_LAYOUT objects
int resize_by_layout(void *obj, int maximum_size);
// Called on startup to initialize the positions of all Areas in the Area tree.
// Parameters:
// * obj: pointer to Area
// * pos: offset in pixels from left/top
void initialize_positions(void *obj, int pos);
// Relayouts the Area and its children. Normally called on the root of the tree (i.e. the Panel).
void relayout(Area *a);
// Distributes the Area's size to its children, repositioning them as needed.
// If maximum_size > 0, it is an upper limit for the child size.
int relayout_with_constraint(Area *a, int maximum_size);
// set 'redraw' on an area and childs
void set_redraw (Area *a);
// Rendering
// hide/unhide area
// Sets the redraw_needed flag on the area and its descendants
void schedule_redraw(Area *a);
// Recreates the Area pixmap and draws the background and the foreground
void draw(Area *a);
// Draws the background of the Area
void draw_background(Area *a, cairo_t *c);
// Explores the entire Area subtree (only if the on_screen flag set)
// and draws the areas with the redraw_needed flag set
void draw_tree(Area *a);
// Clears the on_screen flag, sets the size to zero and triggers a parent resize
void hide(Area *a);
// Sets the on_screen flag and triggers a parent and area resize
void show(Area *a);
// draw pixmap
void draw (Area *a);
void draw_background (Area *a, cairo_t *c);
// Area tree
void remove_area (void *a);
void add_area (Area *a);
void free_area (Area *a);
void add_area(Area *a, Area *parent);
void remove_area(Area *a);
void free_area(Area *a);
// draw rounded rectangle
void draw_rect(cairo_t *c, double x, double y, double w, double h, double r);
// clear pixmap with transparent color
void clear_pixmap(Pixmap p, int x, int y, int w, int h);
// Mouse move events
void mouse_over(Area *area, int pressed);
void mouse_out();
#endif

30
src/util/common.c
View File

@@ -455,7 +455,7 @@ void draw_text(PangoLayout *layout, cairo_t *c, int posx, int posy, Color *color
}
}
}
cairo_set_source_rgba (c, color->color[0], color->color[1], color->color[2], color->alpha);
cairo_set_source_rgba (c, color->rgb[0], color->rgb[1], color->rgb[2], color->alpha);
pango_cairo_update_layout (c, layout);
cairo_move_to (c, posx, posy);
pango_cairo_show_layout (c, layout);
@@ -524,3 +524,31 @@ Imlib_Image adjust_icon(Imlib_Image original, int alpha, int saturation, int bri
imlib_image_put_back_data(data);
return copy;
}
void draw_rect(cairo_t *c, double x, double y, double w, double h, double r)
{
if (r > 0.0) {
double c1 = 0.55228475 * r;
cairo_move_to(c, x+r, y);
cairo_rel_line_to(c, w-2*r, 0);
cairo_rel_curve_to(c, c1, 0.0, r, c1, r, r);
cairo_rel_line_to(c, 0, h-2*r);
cairo_rel_curve_to(c, 0.0, c1, c1-r, r, -r, r);
cairo_rel_line_to (c, -w +2*r, 0);
cairo_rel_curve_to (c, -c1, 0, -r, -c1, -r, -r);
cairo_rel_line_to (c, 0, -h + 2 * r);
cairo_rel_curve_to (c, 0, -c1, r - c1, -r, r, -r);
}
else
cairo_rectangle(c, x, y, w, h);
}
void clear_pixmap(Pixmap p, int x, int y, int w, int h)
{
Picture pict = XRenderCreatePicture(server.dsp, p, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0);
XRenderColor col = { .red=0, .green=0, .blue=0, .alpha=0 };
XRenderFillRectangle(server.dsp, PictOpSrc, pict, &col, x, y, w, h);
XRenderFreePicture(server.dsp, pict);
}

6
src/util/common.h
View File

@@ -78,5 +78,11 @@ Imlib_Image load_image(const char *path, int cached);
Imlib_Image adjust_icon(Imlib_Image original, int alpha, int saturation, int brightness);
// draw rounded rectangle
void draw_rect(cairo_t *c, double x, double y, double w, double h, double r);
// clear pixmap with transparent color
void clear_pixmap(Pixmap p, int x, int y, int w, int h);
#endif