vtorri
/
enlightenment
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Clean up maximization, there is only one unmaximize function now. Think 

this code can do more advanced stuff than the previous code.

The logic is that if the window is first maximized vertically, then
horizontally it should equal that both directions are maximized at once.

unmaximize can only be done in directions already maximized.

The code works, but hasn't been thorougly tested. Please report any errors
to me, and I will fix them!


SVN revision: 23254
This commit is contained in:
sebastid 2006-06-07 21:42:13 +00:00 committed by sebastid
parent f75950ae50
commit a69bc7767c
12 changed files with 295 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
src/bin/e_actions.c
View File

@ -367,63 +367,60 @@ ACT_FN_GO(window_maximized_toggle)
E_Border *bd;
bd = (E_Border *)obj;
/*if (bd->maximized) e_border_unmaximize(bd);*/
if ((bd->maximized != E_MAXIMIZE_NONE) &&
(bd->maximized != E_MAXIMIZE_VERTICAL) &&
(bd->maximized != E_MAXIMIZE_HORIZONTAL))
if ((bd->maximized & E_MAXIMIZE_TYPE) != E_MAXIMIZE_NONE)
{
if (!params)
e_border_unmaximize(bd);
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
else
{
if (!strcmp(params, "vertical"))
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL);
else if (!strcmp(params, "horizontal"))
e_border_unmaximize_vh(bd, E_MAXIMIZE_HORIZONTAL);
char s1[11], s2[11];
/* FIXME: Move this to a parser func which returns an E_Maximize */
if (sscanf(params, "%20s %20s", s1, s2) == 2)
{
if (!strcmp(s2, "vertical"))
e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
else if (!strcmp(s2, "horizontal"))
e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
else
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
}
else
e_border_unmaximize(bd);
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
}
}
else
{
if (!bd->maximized)
{
if (!params)
e_border_maximize(bd, e_config->maximize_policy);
else
{
if (!strcmp(params, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN);
else if (!strcmp(params, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART);
else if (!strcmp(params, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND);
else if (!strcmp(params, "fill")) e_border_maximize(bd, E_MAXIMIZE_FILL);
else if (!strcmp(params, "vertical")) e_border_maximize(bd, E_MAXIMIZE_VERTICAL);
else if (!strcmp(params, "horizontal")) e_border_maximize(bd, E_MAXIMIZE_HORIZONTAL);
else e_border_maximize(bd, e_config->maximize_policy);
}
}
if (!params)
e_border_maximize(bd, e_config->maximize_policy);
else
{
if (!params)
e_border_maximize( bd, e_config->maximize_policy);
else
char s1[32], s2[32];
E_Maximize max;
int ret;
/* FIXME: Move this to a parser func which returns an E_Maximize */
max = (e_config->maximize_policy & E_MAXIMIZE_DIRECTION);
ret = sscanf(params, "%20s %20s", s1, s2);
if (ret == 2)
{
if (!strcmp(params, "vertical"))
{
if (bd->maximized == E_MAXIMIZE_VERTICAL)
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL);
else
e_border_maximize(bd, E_MAXIMIZE_VERTICAL);
}
else if (!strcmp(params, "horizontal"))
{
if (bd->maximized == E_MAXIMIZE_HORIZONTAL)
e_border_unmaximize_vh(bd, E_MAXIMIZE_HORIZONTAL);
else
e_border_maximize(bd, E_MAXIMIZE_HORIZONTAL);
}
if (!strcmp(s2, "horizontal"))
max = E_MAXIMIZE_HORIZONTAL;
else if (!strcmp(s2, "vertical"))
max = E_MAXIMIZE_VERTICAL;
else
e_border_maximize(bd, e_config->maximize_policy);
max = E_MAXIMIZE_BOTH;
}
if (ret > 0)
{
if (!strcmp(s1, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN | max);
else if (!strcmp(s1, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART | max);
else if (!strcmp(s1, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND | max);
else if (!strcmp(s1, "fill")) e_border_maximize(bd, E_MAXIMIZE_FILL | max);
else e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | max);
}
else
e_border_maximize(bd, e_config->maximize_policy);
}
}
}
@ -445,20 +442,33 @@ ACT_FN_GO(window_maximized)
bd = (E_Border *)obj;
if (params)
{
int v;
char buf[32];
E_Maximize max;
int v, ret;
char s1[32], s2[32];
if (sscanf(params, "%i %20s", &v, buf) == 2)
max = (e_config->maximize_policy & E_MAXIMIZE_DIRECTION);
ret = sscanf(params, "%i %20s %20s", &v, s1, s2);
if (ret == 3)
{
if (!strcmp(s2, "horizontal"))
max = E_MAXIMIZE_HORIZONTAL;
else if (!strcmp(s2, "vertical"))
max = E_MAXIMIZE_VERTICAL;
else
max = E_MAXIMIZE_BOTH;
}
if (ret > 1);
{
if (v == 1)
{
if (!strcmp(buf, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN);
else if (!strcmp(buf, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART);
else if (!strcmp(buf, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND);
else if (!strcmp(buf, "fill")) e_border_maximize(bd, E_MAXIMIZE_FILL);
if (!strcmp(s1, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN | max);
else if (!strcmp(s1, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART | max);
else if (!strcmp(s1, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND | max);
else if (!strcmp(s1, "fill")) e_border_maximize(bd, E_MAXIMIZE_FILL | max);
else e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | max);
}
else if (v == 0)
e_border_unmaximize(bd);
e_border_unmaximize(bd, max);
}
}
}

295
src/bin/e_border.c
View File

@ -661,7 +661,7 @@ e_border_move(E_Border *bd, int x, int y)
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) ||
((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
(((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
return;
if (bd->new_client)
{
@ -714,7 +714,7 @@ e_border_resize(E_Border *bd, int w, int h)
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->shaded) || (bd->shading) || (bd->fullscreen) ||
((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
(((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
return;
if (bd->new_client)
{
@ -772,7 +772,7 @@ e_border_move_resize(E_Border *bd, int x, int y, int w, int h)
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) ||
((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
(((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)))
return;
if (bd->new_client)
{
@ -1331,8 +1331,8 @@ e_border_shade(E_Border *bd, E_Direction dir)
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip))
|| (bd->shading)) return;
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) ||
(bd->shading)) return;
if ((bd->client.border.name) &&
(!strcmp("borderless", bd->client.border.name))) return;
if (!bd->shaded)
@ -1419,8 +1419,8 @@ e_border_unshade(E_Border *bd, E_Direction dir)
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip))
|| (bd->shading)) return;
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) ||
(bd->shading)) return;
if (bd->shaded)
{
// printf("UNSHADE!\n");
@ -1525,40 +1525,49 @@ e_border_maximize(E_Border *bd, E_Maximize max)
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if (!(max & E_MAXIMIZE_DIRECTION))
{
printf("BUG: Maximize call without direction!\n");
return;
}
printf("%d %d\n", max & E_MAXIMIZE_HORIZONTAL, max & E_MAXIMIZE_VERTICAL);
if ((bd->shaded) || (bd->shading)) return;
if (bd->fullscreen)
e_border_unfullscreen(bd);
if (bd->maximized == E_MAXIMIZE_VERTICAL && max == E_MAXIMIZE_VERTICAL)
; // ignore. we are already maximized vertical.
else if (bd->maximized == E_MAXIMIZE_HORIZONTAL && max == E_MAXIMIZE_HORIZONTAL)
; // ignore. we are already maximized horizontaly.
else if (( bd->maximized == E_MAXIMIZE_NONE ||
bd->maximized == E_MAXIMIZE_VERTICAL ||
bd->maximized == E_MAXIMIZE_HORIZONTAL))
/* Only allow changes in vertical/ horisontal maximization */
if (((bd->maximized & E_MAXIMIZE_DIRECTION) == (max & E_MAXIMIZE_DIRECTION)) ||
((bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)) return;
if (bd->new_client)
{
bd->need_maximize = 1;
return;
}
{
int x1, y1, x2, y2;
int w, h;
if (bd->new_client)
{
bd->need_maximize = 1;
return;
}
if (!bd->maximized) // E_MAXIMIZE_NONE
if (!(bd->maximized & E_MAXIMIZE_HORIZONTAL))
{
/* Horisontal hasn't been set */
bd->saved.x = bd->x;
bd->saved.y = bd->y;
bd->saved.w = bd->w;
}
if (!(bd->maximized & E_MAXIMIZE_VERTICAL))
{
/* Vertical hasn't been set */
bd->saved.y = bd->y;
bd->saved.h = bd->h;
}
e_hints_window_size_set(bd);
e_border_raise(bd);
switch (max)
switch (max & E_MAXIMIZE_TYPE)
{
case E_MAXIMIZE_NONE:
/* Ignore */
max = E_MAXIMIZE_NONE;
break;
case E_MAXIMIZE_FULLSCREEN:
if (bd->bg_object)
@ -1590,6 +1599,8 @@ e_border_maximize(E_Border *bd, E_Maximize max)
/* center y-direction */
y1 = bd->zone->y + (bd->zone->h - h) / 2;
e_border_move_resize(bd, x1, y1, w, h);
/* FULLSCREEN doesn't work with VERTICAL/HORIZONTAL */
max |= E_MAXIMIZE_BOTH;
break;
case E_MAXIMIZE_SMART:
case E_MAXIMIZE_EXPAND:
@ -1607,7 +1618,12 @@ e_border_maximize(E_Border *bd, E_Maximize max)
w = x2 - x1;
h = y2 - y1;
e_border_resize_limit(bd, &w, &h);
e_border_move_resize(bd, x1, y1, w, h);
if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)
e_border_move_resize(bd, x1, y1, w, h);
else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_VERTICAL)
e_border_move_resize(bd, bd->x, y1, bd->w, h);
else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_HORIZONTAL)
e_border_move_resize(bd, x1, bd->y, w, bd->h);
edje_object_signal_emit(bd->bg_object, "maximize", "");
break;
case E_MAXIMIZE_FILL:
@ -1625,156 +1641,55 @@ e_border_maximize(E_Border *bd, E_Maximize max)
w = x2 - x1;
h = y2 - y1;
e_border_resize_limit(bd, &w, &h);
e_border_move_resize(bd, x1, y1, w, h);
break;
case E_MAXIMIZE_VERTICAL:
x1 = bd->x;
y1 = bd->zone->y;
x2 = bd->x + bd->w;
y2 = bd->zone->y + bd->zone->h;
/* walk through all gadgets */
e_maximize_border_gadman_fit(bd, &x1, &y1, &x2, &y2);
/* walk through docks and toolbars */
//e_maximize_border_dock_fit(bd, &x1, &y1, &x2, &y2);
/* walk through all windows */
//e_maximize_border_border_fill(bd, &x1, &y1, &x2, &y2);
x1 = bd->x;
w = bd->w;
h = y2 - y1;
e_border_resize_limit(bd,&w,&h);
e_border_move_resize(bd,x1,y1,w,h);
break;
case E_MAXIMIZE_HORIZONTAL:
x1 = bd->zone->x;
y1 = bd->y;
x2 = bd->zone->x + bd->zone->w;
y2 = bd->y + bd->h;
/* walk through all gadgets */
e_maximize_border_gadman_fit(bd, &x1, &y1, &x2, &y2);
/* walk through docks and toolbars */
//e_maximize_border_dock_fit(bd, &x1, &y1, &x2, &y2);
/* walk through all windows */
//e_maximize_border_border_fill(bd, &x1, &y1, &x2, &y2);
y1 = bd->y;
h = bd->h;
w = x2 - x1;
e_border_resize_limit(bd,&w,&h);
e_border_move_resize(bd,x1,y1,w,h);
if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)
e_border_move_resize(bd, x1, y1, w, h);
else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_VERTICAL)
e_border_move_resize(bd, bd->x, y1, bd->w, h);
else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_HORIZONTAL)
e_border_move_resize(bd, x1, bd->y, w, bd->h);
break;
}
if ((bd->maximized == E_MAXIMIZE_HORIZONTAL && max == E_MAXIMIZE_VERTICAL) ||
(bd->maximized == E_MAXIMIZE_VERTICAL && max == E_MAXIMIZE_HORIZONTAL))
bd->maximized = e_config->maximize_policy;
else
bd->maximized = max;
/* Remove previous type */
bd->maximized &= ~E_MAXIMIZE_TYPE;
/* Add new maximization. It must be added, so that VERTICAL + HORIZONTAL == BOTH */
bd->maximized |= max;
if (bd->maximized)
e_hints_window_maximized_set(bd, 1);
else
e_hints_window_maximized_set(bd, 0);
e_hints_window_maximized_set(bd, bd->maximized & E_MAXIMIZE_HORIZONTAL,
bd->maximized & E_MAXIMIZE_VERTICAL);
}
}
EAPI void
e_border_unmaximize_vh(E_Border *bd, E_Maximize max)
e_border_unmaximize(E_Border *bd, E_Maximize max)
{
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->shaded) || (bd->shading)) return;
if ((max != E_MAXIMIZE_VERTICAL) && (max != E_MAXIMIZE_HORIZONTAL)) return;
if ((bd->lock_user_maximize) || (!bd->maximized)) return;
switch (bd->maximized)
if (!(max & E_MAXIMIZE_DIRECTION))
{
case E_MAXIMIZE_NONE:
case E_MAXIMIZE_FULLSCREEN:
/* Ignore */
break;
case E_MAXIMIZE_SMART:
case E_MAXIMIZE_EXPAND:
case E_MAXIMIZE_FILL:
if (max == E_MAXIMIZE_VERTICAL)
{
bd->maximized = E_MAXIMIZE_NONE;
e_hints_window_maximized_set(bd, 0);
bd->maximized = E_MAXIMIZE_HORIZONTAL;
e_hints_window_maximized_set(bd, 1);
e_border_move_resize(bd, bd->x, bd->saved.y, bd->w, bd->saved.h);
e_hints_window_size_unset(bd);
//edje_object_signal_emit(bd->bg_object, "unmaximize", "");
}
if (max == E_MAXIMIZE_HORIZONTAL)
{
bd->maximized = E_MAXIMIZE_NONE;
e_hints_window_maximized_set(bd, 0);
bd->maximized = E_MAXIMIZE_VERTICAL;
e_hints_window_maximized_set(bd, 1);
e_border_move_resize(bd, bd->saved.x, bd->y, bd->saved.w, bd->h);
e_hints_window_size_unset(bd);
//edje_object_signal_emit(bd->bg_object, "unmaximize", "");
}
break;
case E_MAXIMIZE_VERTICAL:
if (max == E_MAXIMIZE_HORIZONTAL)
; // do nothing in this case
if (max == E_MAXIMIZE_VERTICAL)
{
bd->maximized = E_MAXIMIZE_NONE;
e_hints_window_maximized_set(bd, 0);
e_border_move_resize(bd, bd->x, bd->saved.y, bd->w, bd->saved.h);
bd->saved.x = bd->saved.y = bd->saved.w = bd->saved.h = 0;
e_hints_window_size_unset(bd);
edje_object_signal_emit(bd->bg_object, "unmaximize", "");
}
break;
case E_MAXIMIZE_HORIZONTAL:
if (max == E_MAXIMIZE_VERTICAL)
; // do nothing in this case.
if (max == E_MAXIMIZE_HORIZONTAL)
{
bd->maximized = E_MAXIMIZE_NONE;
e_hints_window_maximized_set(bd, 0);
e_border_move_resize(bd, bd->saved.x, bd->y, bd->saved.w, bd->h);
bd->saved.x = bd->saved.y = bd->saved.w = bd->saved.h = 0;
e_hints_window_size_unset(bd);
edje_object_signal_emit(bd->bg_object, "unmaximize", "");
}
break;
printf("BUG: Unmaximize call without direction!\n");
return;
}
}
EAPI void
e_border_unmaximize(E_Border *bd)
{
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->shaded) || (bd->shading)) return;
if (bd->maximized)
/* Remove directions not used */
max &= (bd->maximized & E_MAXIMIZE_DIRECTION);
/* Can only remove existing maximization directions */
if (!max) return;
if (bd->maximized & E_MAXIMIZE_TYPE)
{
// printf("UNMAXIMIZE!!\n");
bd->need_maximize = 0;
e_hints_window_maximized_set(bd, 0);
E_Maximize dir;
int signal;
switch (bd->maximized)
/* Get the resulting directions */
dir = (bd->maximized & E_MAXIMIZE_DIRECTION);
dir &= ~max;
bd->need_maximize = 0;
signal = 1;
switch (bd->maximized & E_MAXIMIZE_TYPE)
{
case E_MAXIMIZE_NONE:
/* Ignore */
@ -1785,6 +1700,7 @@ e_border_unmaximize(E_Border *bd)
Evas_Coord cx, cy, cw, ch;
edje_object_signal_emit(bd->bg_object, "unmaximize,fullscreen", "");
signal = 0;
edje_object_message_signal_process(bd->bg_object);
evas_object_resize(bd->bg_object, 1000, 1000);
@ -1801,6 +1717,7 @@ e_border_unmaximize(E_Border *bd)
bd->client_inset.l, bd->client_inset.r,
bd->client_inset.t, bd->client_inset.b);
}
dir = 0;
break;
case E_MAXIMIZE_SMART:
/* Don't have to do anything special */
@ -1818,13 +1735,47 @@ e_border_unmaximize(E_Border *bd)
/*Ignore*/
break;
}
bd->maximized = E_MAXIMIZE_NONE;
if (dir & E_MAXIMIZE_HORIZONTAL)
{
/* Remove vertical */
signal = 0;
bd->maximized &= ~E_MAXIMIZE_VERTICAL;
e_border_move_resize(bd, bd->x, bd->saved.y, bd->w, bd->saved.h);
bd->saved.y = bd->saved.h = 0;
e_hints_window_size_set(bd);
}
else if (dir & E_MAXIMIZE_VERTICAL)
{
/* Remove horisontal */
signal = 0;
bd->maximized &= ~E_MAXIMIZE_HORIZONTAL;
e_border_move_resize(bd, bd->saved.x, bd->y, bd->saved.w, bd->h);
bd->saved.x = bd->saved.w = 0;
e_hints_window_size_set(bd);
}
else
{
int x, y, w, h;
/* Maybe some of the sizes has already been set to 0 */
if (bd->saved.x) x = bd->saved.x;
else x = bd->x;
if (bd->saved.y) y = bd->saved.y;
else y = bd->y;
if (bd->saved.w) w = bd->saved.w;
else w = bd->w;
if (bd->saved.h) h = bd->saved.h;
else h = bd->h;
e_border_move_resize(bd, bd->saved.x, bd->saved.y, bd->saved.w, bd->saved.h);
bd->saved.x = bd->saved.y = bd->saved.w = bd->saved.h = 0;
e_hints_window_size_unset(bd);
bd->maximized = E_MAXIMIZE_NONE;
e_border_move_resize(bd, x, y, w, h);
bd->saved.x = bd->saved.y = bd->saved.w = bd->saved.h = 0;
e_hints_window_size_unset(bd);
}
e_hints_window_maximized_set(bd, bd->maximized & E_MAXIMIZE_HORIZONTAL,
bd->maximized & E_MAXIMIZE_VERTICAL);
edje_object_signal_emit(bd->bg_object, "unmaximize", "");
if (signal)
edje_object_signal_emit(bd->bg_object, "unmaximize", "");
}
}
@ -1836,7 +1787,7 @@ e_border_fullscreen(E_Border *bd, E_Fullscreen policy)
if ((bd->shaded) || (bd->shading)) return;
if (bd->maximized)
e_border_unmaximize(bd);
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
if (bd->new_client)
{
bd->need_fullscreen = 1;
@ -3821,10 +3772,10 @@ _e_border_cb_window_move_resize_request(void *data, int ev_type, void *ev)
bd = e_border_find_by_client_window(e->win);
if (!bd) return 1;
if ((bd->shaded) || (bd->shading)
|| ((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip))
|| (bd->fullscreen) || (bd->moving)
|| (bd->resize_mode != RESIZE_NONE))
if ((bd->shaded) || (bd->shading) ||
(((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
(bd->fullscreen) || (bd->moving) ||
(bd->resize_mode != RESIZE_NONE))
return 1;
if ((e->button >= 1) && (e->button <= 3))
@ -5199,9 +5150,9 @@ _e_border_eval(E_Border *bd)
}
if (bd->shaded)
edje_object_signal_emit(bd->bg_object, "shaded", "");
if (bd->maximized == E_MAXIMIZE_FULLSCREEN)
if ((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN)
edje_object_signal_emit(bd->bg_object, "maximize,fullscreen", "");
else if (bd->maximized > E_MAXIMIZE_FULLSCREEN)
else if ((bd->maximized & E_MAXIMIZE_TYPE) != E_MAXIMIZE_NONE)
edje_object_signal_emit(bd->bg_object, "maximize", "");
if (bd->fullscreen)
edje_object_signal_emit(bd->bg_object, "fullscreen", "");
@ -6412,8 +6363,8 @@ _e_border_resize_begin(E_Border *bd)
if (!bd->lock_user_stacking)
e_border_raise(bd);
if ((bd->shaded) || (bd->shading) ||
((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip))
|| (bd->fullscreen) || (bd->lock_user_size))
(((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
(bd->fullscreen) || (bd->lock_user_size))
return 0;
if ((bd->client.icccm.base_w >= 0) &&
@ -6513,8 +6464,8 @@ _e_border_move_begin(E_Border *bd)
{
if (!bd->lock_user_stacking)
e_border_raise(bd);
if (((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip))
|| (bd->fullscreen) || (bd->lock_user_location))
if ((((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
(bd->fullscreen) || (bd->lock_user_location))
return 0;
if (grabbed)

20
src/bin/e_border.h
View File

@ -43,13 +43,16 @@ typedef enum _E_Focus_Setting
typedef enum _E_Maximize
{
E_MAXIMIZE_NONE,
E_MAXIMIZE_FULLSCREEN,
E_MAXIMIZE_SMART,
E_MAXIMIZE_EXPAND,
E_MAXIMIZE_FILL,
E_MAXIMIZE_VERTICAL,
E_MAXIMIZE_HORIZONTAL
E_MAXIMIZE_NONE = 0x00000000,
E_MAXIMIZE_FULLSCREEN = 0x00000001,
E_MAXIMIZE_SMART = 0x00000002,
E_MAXIMIZE_EXPAND = 0x00000003,
E_MAXIMIZE_FILL = 0x00000004,
E_MAXIMIZE_TYPE = 0x0000000f,
E_MAXIMIZE_VERTICAL = 0x00000010,
E_MAXIMIZE_HORIZONTAL = 0x00000020,
E_MAXIMIZE_BOTH = 0x00000030,
E_MAXIMIZE_DIRECTION = 0x000000f0
} E_Maximize;
typedef enum _E_Fullscreen
@ -523,8 +526,7 @@ EAPI void e_border_focus_set(E_Border *bd, int focus, int set);
EAPI void e_border_shade(E_Border *bd, E_Direction dir);
EAPI void e_border_unshade(E_Border *bd, E_Direction dir);
EAPI void e_border_maximize(E_Border *bd, E_Maximize max);
EAPI void e_border_unmaximize(E_Border *bd);
EAPI void e_border_unmaximize_vh(E_Border *bd, E_Maximize max);
EAPI void e_border_unmaximize(E_Border *bd, E_Maximize max);
EAPI void e_border_fullscreen(E_Border *bd, E_Fullscreen policy);
EAPI void e_border_unfullscreen(E_Border *bd);
EAPI void e_border_iconify(E_Border *bd);

2
src/bin/e_config.c
View File

@ -573,7 +573,7 @@ e_config_init(void)
e_config->winlist_pos_min_h = 0;
e_config->winlist_pos_max_w = 320;
e_config->winlist_pos_max_h = 320;
e_config->maximize_policy = E_MAXIMIZE_SMART;
e_config->maximize_policy = E_MAXIMIZE_SMART | E_MAXIMIZE_BOTH;
e_config->allow_manip = 0;
e_config->kill_if_close_not_possible = 1;
e_config->kill_process = 1;

2
src/bin/e_container.c
View File

@ -1218,7 +1218,7 @@ _e_container_resize_handle(E_Container *con)
E_Maximize max;
max = bd->maximized;
e_border_unmaximize(bd);
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
e_border_maximize(bd, max);
}
else

166
src/bin/e_hints.c
View File

@ -454,7 +454,27 @@ e_hints_window_init(E_Border *bd)
e_border_maximize(bd, e_config->maximize_policy);
}
else
e_hints_window_maximized_set(bd, 0);
e_hints_window_maximized_set(bd, 0, 0);
}
else if (bd->client.netwm.state.maximized_h)
{
if (!bd->lock_client_maximize)
{
e_hints_window_size_get(bd);
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
}
else
e_hints_window_maximized_set(bd, 0, 0);
}
else if (bd->client.netwm.state.maximized_v)
{
if (!bd->lock_client_maximize)
{
e_hints_window_size_get(bd);
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
}
else
e_hints_window_maximized_set(bd, 0, 0);
}
if (bd->client.netwm.state.fullscreen)
{
@ -607,83 +627,43 @@ e_hints_window_state_update(E_Border *bd, Ecore_X_Window_State state,
break;
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
if (bd->lock_client_maximize) return;
/* We might end up in a state where maximized_h or maximized_v is
* set. This doesn't matter, because E only checks if both are
* set for maximization.
*/
changed = 0;
switch (action)
{
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
if (bd->client.netwm.state.maximized_v)
{
bd->client.netwm.state.maximized_v = 0;
changed = 1;
}
if (bd->maximized & E_MAXIMIZE_VERTICAL)
e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
break;
case ECORE_X_WINDOW_STATE_ACTION_ADD:
if (!bd->client.netwm.state.maximized_v)
{
bd->client.netwm.state.maximized_v = 1;
changed = 1;
}
if (!(bd->maximized & E_MAXIMIZE_VERTICAL))
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
break;
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
bd->client.netwm.state.maximized_v = !bd->client.netwm.state.maximized_v;
changed = 1;
if (bd->maximized & E_MAXIMIZE_VERTICAL)
e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
break;
}
if (changed)
{
bd->client.netwm.update.state = 1;
bd->changed = 1;
if ((bd->client.netwm.state.maximized_v) &&
(bd->client.netwm.state.maximized_h))
e_border_maximize(bd, e_config->maximize_policy);
else if ((!bd->client.netwm.state.maximized_v) &&
(!bd->client.netwm.state.maximized_h))
e_border_unmaximize(bd);
}
break;
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
if (bd->lock_client_maximize) return;
/* We might end up in a state where maximized_h or maximized_v is
* set. This doesn't matter, because E only checks if both are
* set for maximization.
*/
changed = 0;
switch (action)
{
case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
if (bd->client.netwm.state.maximized_h)
{
bd->client.netwm.state.maximized_h = 0;
changed = 1;
}
if (bd->maximized & E_MAXIMIZE_HORIZONTAL)
e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
break;
case ECORE_X_WINDOW_STATE_ACTION_ADD:
if (!bd->client.netwm.state.maximized_h)
{
bd->client.netwm.state.maximized_h = 1;
changed = 1;
}
if (!(bd->maximized & E_MAXIMIZE_HORIZONTAL))
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
break;
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
bd->client.netwm.state.maximized_h = !bd->client.netwm.state.maximized_h;
changed = 1;
if (bd->maximized & E_MAXIMIZE_HORIZONTAL)
e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
break;
}
if (changed)
{
bd->client.netwm.update.state = 1;
bd->changed = 1;
if ((bd->client.netwm.state.maximized_v) &&
(bd->client.netwm.state.maximized_h))
e_border_maximize(bd, e_config->maximize_policy);
else if ((!bd->client.netwm.state.maximized_v) &&
(!bd->client.netwm.state.maximized_h))
e_border_unmaximize(bd);
}
break;
case ECORE_X_WINDOW_STATE_SHADED:
if (bd->lock_client_shade) return;
@ -1022,85 +1002,33 @@ e_hints_window_size_get(E_Border *bd)
}
EAPI void
e_hints_window_maximized_set(E_Border *bd, int on)
e_hints_window_maximized_set(E_Border *bd, int horizontal, int vertical)
{
if( on )
{
if( bd->maximized == E_MAXIMIZE_VERTICAL )
{
if( !bd->client.netwm.state.maximized_v )
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 1;
bd->changed = 1;
}
}
else if( bd->maximized == E_MAXIMIZE_HORIZONTAL )
{
if( !bd->client.netwm.state.maximized_h )
{
if ((horizontal) && (!bd->client.netwm.state.maximized_h))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 1;
bd->changed = 1;
}
}
else
{
if( !bd->client.netwm.state.maximized_v )
{
}
else if ((!horizontal) && (bd->client.netwm.state.maximized_h))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 1;
bd->client.netwm.state.maximized_h = 0;
bd->changed = 1;
}
if( !bd->client.netwm.state.maximized_h )
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 1;
bd->changed = 1;
}
}
}
else
{
if( bd->client.netwm.state.maximized_v )
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 0;
bd->changed = 1;
}
if( bd->client.netwm.state.maximized_h )
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 0;
bd->changed = 1;
}
}
/*if ((!bd->client.netwm.state.maximized_v) && (on))
}
if ((vertical) && (!bd->client.netwm.state.maximized_v))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 1;
bd->changed = 1;
}
else if ((bd->client.netwm.state.maximized_v) && (!on))
else if ((!vertical) && (bd->client.netwm.state.maximized_v))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 0;
bd->changed = 1;
}
if ((!bd->client.netwm.state.maximized_h) && (on))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 1;
bd->changed = 1;
}
else if ((bd->client.netwm.state.maximized_h) && (!on))
{
bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 0;
bd->changed = 1;
}*/
}
EAPI void

2
src/bin/e_hints.h
View File

@ -35,7 +35,7 @@ EAPI void e_hints_window_size_unset(E_Border *bd);
EAPI int e_hints_window_size_get(E_Border *bd);
EAPI void e_hints_window_shaded_set(E_Border *bd, int on);
EAPI void e_hints_window_maximized_set(E_Border *bd, int on);
EAPI void e_hints_window_maximized_set(E_Border *bd, int horizontal, int vertical);
EAPI void e_hints_window_fullscreen_set(E_Border *bd, int on);
EAPI void e_hints_window_sticky_set(E_Border *bd, int on);
EAPI void e_hints_window_stacking_set(E_Border *bd, E_Stacking stacking);

100
src/bin/e_int_border_menu.c
View File

@ -83,20 +83,15 @@ e_int_border_menu_show(E_Border *bd, Evas_Coord x, Evas_Coord y, int key, Ecore_
if ((!bd->lock_user_maximize) && (!bd->shaded) &&
((bd->layer == 50) || (bd->layer == 100) || (bd->layer == 150)))
{
int __fullmaximization = 0;
m = e_menu_new();
e_menu_category_set(m,"border/maximize");
e_menu_category_data_set("border/maximize",bd);
bd->border_maximize_menu = m;
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized"));
e_menu_item_label_set(mi, _("Maximize"));
e_menu_item_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_toggle_set( mi, ( ( (__fullmaximization = bd->maximized &&
bd->maximized != E_MAXIMIZE_VERTICAL &&
bd->maximized != E_MAXIMIZE_HORIZONTAL)) ? 1 : 0 ));
e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH);
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
@ -104,13 +99,9 @@ e_int_border_menu_show(E_Border *bd, Evas_Coord x, Evas_Coord y, int key, Ecore_
"widgets/border/default/maximize");
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized vertically"));
e_menu_item_label_set(mi, _("Maximize vertically"));
e_menu_item_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_toggle_set( mi, ( ( (bd->maximized &&
bd->maximized == E_MAXIMIZE_VERTICAL &&
bd->maximized != E_MAXIMIZE_HORIZONTAL) ||
__fullmaximization ) ? 1 : 0 ));
e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_VERTICAL));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_vertically, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
@ -118,13 +109,9 @@ e_int_border_menu_show(E_Border *bd, Evas_Coord x, Evas_Coord y, int key, Ecore_
"widgets/border/default/maximize");
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized horizontally"));
e_menu_item_label_set(mi, _("Maximize horizontally"));
e_menu_item_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_toggle_set( mi, ( ( (bd->maximized &&
bd->maximized != E_MAXIMIZE_VERTICAL &&
bd->maximized == E_MAXIMIZE_HORIZONTAL) ||
__fullmaximization ) ? 1 : 0 ));
e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_HORIZONTAL));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_horizontally, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
@ -209,45 +196,6 @@ e_int_border_menu_show(E_Border *bd, Evas_Coord x, Evas_Coord y, int key, Ecore_
"widgets/border/default/shade");
}
/*if (!bd->lock_user_maximize)
{
mi = e_menu_item_new(m);
e_menu_item_separator_set(mi, 1);
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized"));
e_menu_item_check_set(mi, 1);
e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
"widgets/border/default/maximize"),
"widgets/border/default/maximize");
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized vertically"));
e_menu_item_check_set(mi, 1);
e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
"widgets/border/default/maximize"),
"widgets/border/default/maximize");
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Maximized horizontally"));
e_menu_item_check_set(mi, 1);
e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd);
e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders",
"widgets/border/default/maximize"),
"widgets/border/default/maximize");
mi = e_menu_item_new(m);
e_menu_item_separator_set(mi, 1);
}*/
if (!bd->lock_user_sticky)
{
mi = e_menu_item_new(m);
@ -508,13 +456,13 @@ _e_border_menu_cb_maximize(void *data, E_Menu *m, E_Menu_Item *mi)
bd = data;
if (!bd->lock_user_maximize)
{
if (bd->maximized != E_MAXIMIZE_NONE &&
bd->maximized != E_MAXIMIZE_VERTICAL &&
bd->maximized != E_MAXIMIZE_HORIZONTAL ) e_border_unmaximize(bd);
else e_border_maximize(bd, e_config->maximize_policy);
if (bd->maximized & E_MAXIMIZE_BOTH)
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_BOTH);
}
}
/*** sndev : menu_cb_miximize_vertically callback **************/
static void
_e_border_menu_cb_maximize_vertically(void *data, E_Menu *m, E_Menu_Item *mi)
{
@ -523,12 +471,13 @@ _e_border_menu_cb_maximize_vertically(void *data, E_Menu *m, E_Menu_Item *mi)
bd = data;
if (!bd->lock_user_maximize)
{
if (bd->maximized && bd->maximized != E_MAXIMIZE_HORIZONTAL )
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL );
else e_border_maximize(bd, E_MAXIMIZE_VERTICAL );
if ((bd->maximized & E_MAXIMIZE_VERTICAL))
e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
}
}
/*** sndev : menu_cb_miximize_vertically callback **************/
static void
_e_border_menu_cb_maximize_horizontally(void *data, E_Menu *m, E_Menu_Item *mi)
{
@ -537,11 +486,22 @@ _e_border_menu_cb_maximize_horizontally(void *data, E_Menu *m, E_Menu_Item *mi)
bd = data;
if (!bd->lock_user_maximize)
{
if (bd->maximized && bd->maximized != E_MAXIMIZE_VERTICAL )
e_border_unmaximize_vh(bd, E_MAXIMIZE_HORIZONTAL );
else e_border_maximize(bd, E_MAXIMIZE_HORIZONTAL );
if ((bd->maximized & E_MAXIMIZE_HORIZONTAL))
e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
}
}
static void
_e_border_menu_cb_unmaximize(void *data, E_Menu *m, E_Menu_Item *mi)
{
E_Border *bd;
bd = data;
e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
}
/*************************************************************/
static void
_e_border_menu_cb_shade(void *data, E_Menu *m, E_Menu_Item *mi)

2
src/bin/e_int_config_modules.c
View File

@ -59,7 +59,6 @@ _module_configure(void *data, void *data2)
{
E_Config_Dialog_Data *cfdata;
E_Module *m;
const char *v;
cfdata = data;
if (!cfdata->modname) return;
@ -75,7 +74,6 @@ _module_about(void *data, void *data2)
{
E_Config_Dialog_Data *cfdata;
E_Module *m;
const char *v;
cfdata = data;
if (!cfdata->modname) return;

3
src/bin/e_int_config_startup.c
View File

@ -126,13 +126,12 @@ static void
_load_inits(E_Config_Dialog *cfd, Evas_Object *il)
{
Evas *evas;
Evas_Object *im, *o, *init_obj;
Evas_Object *im;
Evas_List *init_dirs, *init;
Ecore_Evas *eebuf;
Evas *evasbuf;
int i = 0;
int selnum = -1;
const char *s;
char *homedir;
if (!il) return;

23
src/bin/e_int_config_window_manipulation.c
View File

@ -19,6 +19,7 @@ struct _E_Config_Dialog_Data
int use_resist;
int maximize_policy;
/*- ADVANCED -*/
int maximize_direction;
double auto_raise_delay;
int desk_resist;
int window_resist;
@ -57,9 +58,12 @@ _fill_data(E_Config_Dialog_Data *cfdata)
cfdata->desk_resist = e_config->desk_resist;
cfdata->window_resist = e_config->window_resist;
cfdata->gadget_resist = e_config->gadget_resist;
cfdata->maximize_policy = e_config->maximize_policy;
cfdata->maximize_policy = (e_config->maximize_policy & E_MAXIMIZE_TYPE);
if (cfdata->maximize_policy == E_MAXIMIZE_NONE)
cfdata->maximize_policy = E_MAXIMIZE_FULLSCREEN;
cfdata->maximize_direction = (e_config->maximize_policy & E_MAXIMIZE_DIRECTION);
if (!cfdata->maximize_direction)
cfdata->maximize_direction = E_MAXIMIZE_BOTH;
cfdata->allow_manip = e_config->allow_manip;
}
@ -91,7 +95,8 @@ _basic_apply_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
/* Actually take our cfdata settings and apply them in real life */
e_config->use_auto_raise = cfdata->use_auto_raise;
e_config->use_resist = cfdata->use_resist;
e_config->maximize_policy = cfdata->maximize_policy;
e_config->maximize_policy &= ~E_MAXIMIZE_TYPE;
e_config->maximize_policy &= cfdata->maximize_policy;
e_config_save_queue();
return 1; /* Apply was OK */
}
@ -106,7 +111,7 @@ _advanced_apply_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
e_config->desk_resist = cfdata->desk_resist;
e_config->window_resist = cfdata->window_resist;
e_config->gadget_resist = cfdata->gadget_resist;
e_config->maximize_policy = cfdata->maximize_policy;
e_config->maximize_policy = cfdata->maximize_policy | cfdata->maximize_direction;
e_config->allow_manip = cfdata->allow_manip;
e_config_save_queue();
return 1; /* Apply was OK */
@ -178,7 +183,7 @@ _advanced_create_widgets(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data
ob = e_widget_slider_add(evas, 1, 0, _("%2.0f pixels"), 0, 64.0, 1.0, 0, NULL, &(cfdata->gadget_resist), 200);
e_widget_framelist_object_append(of, ob);
e_widget_list_object_append(o, of, 1, 1, 0.5);
of = e_widget_framelist_add(evas, _("Maximize Policy"), 0);
rg = e_widget_radio_group_new(&(cfdata->maximize_policy));
ob = e_widget_radio_add(evas, _("Fullscreen"), E_MAXIMIZE_FULLSCREEN, rg);
@ -189,8 +194,18 @@ _advanced_create_widgets(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data
e_widget_framelist_object_append(of, ob);
ob = e_widget_radio_add(evas, _("Fill available space"), E_MAXIMIZE_FILL, rg);
e_widget_framelist_object_append(of, ob);
rg = e_widget_radio_group_new(&(cfdata->maximize_direction));
ob = e_widget_radio_add(evas, _("Both directions"), E_MAXIMIZE_BOTH, rg);
e_widget_framelist_object_append(of, ob);
ob = e_widget_radio_add(evas, _("Horizontal"), E_MAXIMIZE_HORIZONTAL, rg);
e_widget_framelist_object_append(of, ob);
ob = e_widget_radio_add(evas, _("Vertical"), E_MAXIMIZE_VERTICAL, rg);
e_widget_framelist_object_append(of, ob);
ob = e_widget_check_add(evas, _("Allow window manipulation"), &(cfdata->allow_manip));
e_widget_framelist_object_append(of, ob);
e_widget_list_object_append(o, of, 1, 1, 0.5);
return o;

1
src/bin/e_int_shelf_config.c
View File

@ -199,7 +199,6 @@ _basic_create_widgets(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cf
{
/* generate the core widget layout for a basic dialog */
Evas_Object *o, *of, *ob, *oi, *oj;
E_Radio_Group *rg;
Evas_Coord wmw, wmh;
Evas_List *styles, *l;
int sel, n;