NorwayFun
/
enlightenment
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Packages 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; E_Border *bd;
bd = (E_Border *)obj; bd = (E_Border *)obj;
/*if (bd->maximized) e_border_unmaximize(bd);*/ if ((bd->maximized & E_MAXIMIZE_TYPE) != E_MAXIMIZE_NONE)
if ((bd->maximized != E_MAXIMIZE_NONE) &&
(bd->maximized != E_MAXIMIZE_VERTICAL) &&
(bd->maximized != E_MAXIMIZE_HORIZONTAL))
{ {
if (!params) if (!params)
e_border_unmaximize(bd); e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
else else
{ {
if (!strcmp(params, "vertical")) char s1[11], s2[11];
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL);
else if (!strcmp(params, "horizontal")) /* FIXME: Move this to a parser func which returns an E_Maximize */
e_border_unmaximize_vh(bd, E_MAXIMIZE_HORIZONTAL); 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 else
e_border_unmaximize(bd); e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
} }
} }
else else
{ {
if (!bd->maximized) if (!params)
{ e_border_maximize(bd, e_config->maximize_policy);
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);
}
}
else else
{ {
if (!params) char s1[32], s2[32];
e_border_maximize( bd, e_config->maximize_policy); E_Maximize max;
else 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 (!strcmp(s2, "horizontal"))
{ max = E_MAXIMIZE_HORIZONTAL;
if (bd->maximized == E_MAXIMIZE_VERTICAL) else if (!strcmp(s2, "vertical"))
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL); max = 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);
}
else 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; bd = (E_Border *)obj;
if (params) if (params)
{ {
int v; E_Maximize max;
char buf[32]; 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 (v == 1)
{ {
if (!strcmp(buf, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN); if (!strcmp(s1, "fullscreen")) e_border_maximize(bd, E_MAXIMIZE_FULLSCREEN | max);
else if (!strcmp(buf, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART); else if (!strcmp(s1, "smart")) e_border_maximize(bd, E_MAXIMIZE_SMART | max);
else if (!strcmp(buf, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND); else if (!strcmp(s1, "expand")) e_border_maximize(bd, E_MAXIMIZE_EXPAND | max);
else if (!strcmp(buf, "fill")) e_border_maximize(bd, E_MAXIMIZE_FILL); 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) 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); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || 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; return;
if (bd->new_client) 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); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->shaded) || (bd->shading) || (bd->fullscreen) || 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; return;
if (bd->new_client) 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); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || 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; return;
if (bd->new_client) if (bd->new_client)
{ {
@ -1331,8 +1331,8 @@ e_border_shade(E_Border *bd, E_Direction dir)
E_OBJECT_CHECK(bd); E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) ||
|| (bd->shading)) return; (bd->shading)) return;
if ((bd->client.border.name) && if ((bd->client.border.name) &&
(!strcmp("borderless", bd->client.border.name))) return; (!strcmp("borderless", bd->client.border.name))) return;
if (!bd->shaded) if (!bd->shaded)
@ -1419,8 +1419,8 @@ e_border_unshade(E_Border *bd, E_Direction dir)
E_OBJECT_CHECK(bd); E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) if ((bd->fullscreen) || ((bd->maximized) && (!e_config->allow_manip)) ||
|| (bd->shading)) return; (bd->shading)) return;
if (bd->shaded) if (bd->shaded)
{ {
// printf("UNSHADE!\n"); // printf("UNSHADE!\n");
@ -1525,40 +1525,49 @@ e_border_maximize(E_Border *bd, E_Maximize max)
E_OBJECT_CHECK(bd); E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE); 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->shaded) || (bd->shading)) return;
if (bd->fullscreen) if (bd->fullscreen)
e_border_unfullscreen(bd); e_border_unfullscreen(bd);
if (bd->maximized == E_MAXIMIZE_VERTICAL && max == E_MAXIMIZE_VERTICAL) /* Only allow changes in vertical/ horisontal maximization */
; // ignore. we are already maximized vertical. if (((bd->maximized & E_MAXIMIZE_DIRECTION) == (max & E_MAXIMIZE_DIRECTION)) ||
else if (bd->maximized == E_MAXIMIZE_HORIZONTAL && max == E_MAXIMIZE_HORIZONTAL) ((bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)) return;
; // ignore. we are already maximized horizontaly. if (bd->new_client)
else if (( bd->maximized == E_MAXIMIZE_NONE || {
bd->maximized == E_MAXIMIZE_VERTICAL || bd->need_maximize = 1;
bd->maximized == E_MAXIMIZE_HORIZONTAL)) return;
}
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
int w, h; int w, h;
if (bd->new_client) if (!(bd->maximized & E_MAXIMIZE_HORIZONTAL))
{
bd->need_maximize = 1;
return;
}
if (!bd->maximized) // E_MAXIMIZE_NONE
{ {
/* Horisontal hasn't been set */
bd->saved.x = bd->x; bd->saved.x = bd->x;
bd->saved.y = bd->y;
bd->saved.w = bd->w; 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; bd->saved.h = bd->h;
} }
e_hints_window_size_set(bd); e_hints_window_size_set(bd);
e_border_raise(bd); e_border_raise(bd);
switch (max) switch (max & E_MAXIMIZE_TYPE)
{ {
case E_MAXIMIZE_NONE: case E_MAXIMIZE_NONE:
/* Ignore */ /* Ignore */
max = E_MAXIMIZE_NONE;
break; break;
case E_MAXIMIZE_FULLSCREEN: case E_MAXIMIZE_FULLSCREEN:
if (bd->bg_object) if (bd->bg_object)
@ -1590,6 +1599,8 @@ e_border_maximize(E_Border *bd, E_Maximize max)
/* center y-direction */ /* center y-direction */
y1 = bd->zone->y + (bd->zone->h - h) / 2; y1 = bd->zone->y + (bd->zone->h - h) / 2;
e_border_move_resize(bd, x1, y1, w, h); e_border_move_resize(bd, x1, y1, w, h);
/* FULLSCREEN doesn't work with VERTICAL/HORIZONTAL */
max |= E_MAXIMIZE_BOTH;
break; break;
case E_MAXIMIZE_SMART: case E_MAXIMIZE_SMART:
case E_MAXIMIZE_EXPAND: case E_MAXIMIZE_EXPAND:
@ -1607,7 +1618,12 @@ e_border_maximize(E_Border *bd, E_Maximize max)
w = x2 - x1; w = x2 - x1;
h = y2 - y1; h = y2 - y1;
e_border_resize_limit(bd, &w, &h); 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", ""); edje_object_signal_emit(bd->bg_object, "maximize", "");
break; break;
case E_MAXIMIZE_FILL: case E_MAXIMIZE_FILL:
@ -1625,156 +1641,55 @@ e_border_maximize(E_Border *bd, E_Maximize max)
w = x2 - x1; w = x2 - x1;
h = y2 - y1; h = y2 - y1;
e_border_resize_limit(bd, &w, &h); e_border_resize_limit(bd, &w, &h);
e_border_move_resize(bd, x1, y1, w, h); if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)
break; e_border_move_resize(bd, x1, y1, w, h);
case E_MAXIMIZE_VERTICAL: else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_VERTICAL)
x1 = bd->x; e_border_move_resize(bd, bd->x, y1, bd->w, h);
y1 = bd->zone->y; else if ((max & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_HORIZONTAL)
x2 = bd->x + bd->w; e_border_move_resize(bd, x1, bd->y, w, bd->h);
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);
break; break;
} }
if ((bd->maximized == E_MAXIMIZE_HORIZONTAL && max == E_MAXIMIZE_VERTICAL) || /* Remove previous type */
(bd->maximized == E_MAXIMIZE_VERTICAL && max == E_MAXIMIZE_HORIZONTAL)) bd->maximized &= ~E_MAXIMIZE_TYPE;
bd->maximized = e_config->maximize_policy; /* Add new maximization. It must be added, so that VERTICAL + HORIZONTAL == BOTH */
else bd->maximized |= max;
bd->maximized = max;
if (bd->maximized) e_hints_window_maximized_set(bd, bd->maximized & E_MAXIMIZE_HORIZONTAL,
e_hints_window_maximized_set(bd, 1); bd->maximized & E_MAXIMIZE_VERTICAL);
else
e_hints_window_maximized_set(bd, 0);
} }
} }
EAPI void 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_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE); E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
if ((bd->shaded) || (bd->shading)) return; if (!(max & E_MAXIMIZE_DIRECTION))
if ((max != E_MAXIMIZE_VERTICAL) && (max != E_MAXIMIZE_HORIZONTAL)) return;
if ((bd->lock_user_maximize) || (!bd->maximized)) return;
switch (bd->maximized)
{ {
case E_MAXIMIZE_NONE: printf("BUG: Unmaximize call without direction!\n");
case E_MAXIMIZE_FULLSCREEN: return;
/* 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;
} }
}
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->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"); // printf("UNMAXIMIZE!!\n");
bd->need_maximize = 0; E_Maximize dir;
e_hints_window_maximized_set(bd, 0); 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: case E_MAXIMIZE_NONE:
/* Ignore */ /* Ignore */
@ -1785,6 +1700,7 @@ e_border_unmaximize(E_Border *bd)
Evas_Coord cx, cy, cw, ch; Evas_Coord cx, cy, cw, ch;
edje_object_signal_emit(bd->bg_object, "unmaximize,fullscreen", ""); edje_object_signal_emit(bd->bg_object, "unmaximize,fullscreen", "");
signal = 0;
edje_object_message_signal_process(bd->bg_object); edje_object_message_signal_process(bd->bg_object);
evas_object_resize(bd->bg_object, 1000, 1000); 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.l, bd->client_inset.r,
bd->client_inset.t, bd->client_inset.b); bd->client_inset.t, bd->client_inset.b);
} }
dir = 0;
break; break;
case E_MAXIMIZE_SMART: case E_MAXIMIZE_SMART:
/* Don't have to do anything special */ /* Don't have to do anything special */
@ -1818,13 +1735,47 @@ e_border_unmaximize(E_Border *bd)
/*Ignore*/ /*Ignore*/
break; 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->maximized = E_MAXIMIZE_NONE;
bd->saved.x = bd->saved.y = bd->saved.w = bd->saved.h = 0; e_border_move_resize(bd, x, y, w, h);
e_hints_window_size_unset(bd); 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->shaded) || (bd->shading)) return;
if (bd->maximized) if (bd->maximized)
e_border_unmaximize(bd); e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
if (bd->new_client) if (bd->new_client)
{ {
bd->need_fullscreen = 1; 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); bd = e_border_find_by_client_window(e->win);
if (!bd) return 1; if (!bd) return 1;
if ((bd->shaded) || (bd->shading) if ((bd->shaded) || (bd->shading) ||
|| ((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) (((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
|| (bd->fullscreen) || (bd->moving) (bd->fullscreen) || (bd->moving) ||
|| (bd->resize_mode != RESIZE_NONE)) (bd->resize_mode != RESIZE_NONE))
return 1; return 1;
if ((e->button >= 1) && (e->button <= 3)) if ((e->button >= 1) && (e->button <= 3))
@ -5199,9 +5150,9 @@ _e_border_eval(E_Border *bd)
} }
if (bd->shaded) if (bd->shaded)
edje_object_signal_emit(bd->bg_object, "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", ""); 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", ""); edje_object_signal_emit(bd->bg_object, "maximize", "");
if (bd->fullscreen) if (bd->fullscreen)
edje_object_signal_emit(bd->bg_object, "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) if (!bd->lock_user_stacking)
e_border_raise(bd); e_border_raise(bd);
if ((bd->shaded) || (bd->shading) || if ((bd->shaded) || (bd->shading) ||
((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) (((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
|| (bd->fullscreen) || (bd->lock_user_size)) (bd->fullscreen) || (bd->lock_user_size))
return 0; return 0;
if ((bd->client.icccm.base_w >= 0) && if ((bd->client.icccm.base_w >= 0) &&
@ -6513,8 +6464,8 @@ _e_border_move_begin(E_Border *bd)
{ {
if (!bd->lock_user_stacking) if (!bd->lock_user_stacking)
e_border_raise(bd); e_border_raise(bd);
if (((bd->maximized == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) if ((((bd->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN) && (!e_config->allow_manip)) ||
|| (bd->fullscreen) || (bd->lock_user_location)) (bd->fullscreen) || (bd->lock_user_location))
return 0; return 0;
if (grabbed) if (grabbed)

20
src/bin/e_border.h
View File

@ -43,13 +43,16 @@ typedef enum _E_Focus_Setting
typedef enum _E_Maximize typedef enum _E_Maximize
{ {
E_MAXIMIZE_NONE, E_MAXIMIZE_NONE = 0x00000000,
E_MAXIMIZE_FULLSCREEN, E_MAXIMIZE_FULLSCREEN = 0x00000001,
E_MAXIMIZE_SMART, E_MAXIMIZE_SMART = 0x00000002,
E_MAXIMIZE_EXPAND, E_MAXIMIZE_EXPAND = 0x00000003,
E_MAXIMIZE_FILL, E_MAXIMIZE_FILL = 0x00000004,
E_MAXIMIZE_VERTICAL, E_MAXIMIZE_TYPE = 0x0000000f,
E_MAXIMIZE_HORIZONTAL E_MAXIMIZE_VERTICAL = 0x00000010,
E_MAXIMIZE_HORIZONTAL = 0x00000020,
E_MAXIMIZE_BOTH = 0x00000030,
E_MAXIMIZE_DIRECTION = 0x000000f0
} E_Maximize; } E_Maximize;
typedef enum _E_Fullscreen 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_shade(E_Border *bd, E_Direction dir);
EAPI void e_border_unshade(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_maximize(E_Border *bd, E_Maximize max);
EAPI void e_border_unmaximize(E_Border *bd); EAPI void e_border_unmaximize(E_Border *bd, E_Maximize max);
EAPI void e_border_unmaximize_vh(E_Border *bd, E_Maximize max);
EAPI void e_border_fullscreen(E_Border *bd, E_Fullscreen policy); EAPI void e_border_fullscreen(E_Border *bd, E_Fullscreen policy);
EAPI void e_border_unfullscreen(E_Border *bd); EAPI void e_border_unfullscreen(E_Border *bd);
EAPI void e_border_iconify(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_min_h = 0;
e_config->winlist_pos_max_w = 320; e_config->winlist_pos_max_w = 320;
e_config->winlist_pos_max_h = 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->allow_manip = 0;
e_config->kill_if_close_not_possible = 1; e_config->kill_if_close_not_possible = 1;
e_config->kill_process = 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; E_Maximize max;
max = bd->maximized; max = bd->maximized;
e_border_unmaximize(bd); e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
e_border_maximize(bd, max); e_border_maximize(bd, max);
} }
else 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); e_border_maximize(bd, e_config->maximize_policy);
} }
else 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) if (bd->client.netwm.state.fullscreen)
{ {
@ -607,83 +627,43 @@ e_hints_window_state_update(E_Border *bd, Ecore_X_Window_State state,
break; break;
case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT: case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
if (bd->lock_client_maximize) return; 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) switch (action)
{ {
case ECORE_X_WINDOW_STATE_ACTION_REMOVE: case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
if (bd->client.netwm.state.maximized_v) if (bd->maximized & E_MAXIMIZE_VERTICAL)
{ e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
bd->client.netwm.state.maximized_v = 0;
changed = 1;
}
break; break;
case ECORE_X_WINDOW_STATE_ACTION_ADD: case ECORE_X_WINDOW_STATE_ACTION_ADD:
if (!bd->client.netwm.state.maximized_v) if (!(bd->maximized & E_MAXIMIZE_VERTICAL))
{ e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
bd->client.netwm.state.maximized_v = 1;
changed = 1;
}
break; break;
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE: case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
bd->client.netwm.state.maximized_v = !bd->client.netwm.state.maximized_v; if (bd->maximized & E_MAXIMIZE_VERTICAL)
changed = 1; e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_VERTICAL);
break; 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; break;
case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ: case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
if (bd->lock_client_maximize) return; 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) switch (action)
{ {
case ECORE_X_WINDOW_STATE_ACTION_REMOVE: case ECORE_X_WINDOW_STATE_ACTION_REMOVE:
if (bd->client.netwm.state.maximized_h) if (bd->maximized & E_MAXIMIZE_HORIZONTAL)
{ e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
bd->client.netwm.state.maximized_h = 0;
changed = 1;
}
break; break;
case ECORE_X_WINDOW_STATE_ACTION_ADD: case ECORE_X_WINDOW_STATE_ACTION_ADD:
if (!bd->client.netwm.state.maximized_h) if (!(bd->maximized & E_MAXIMIZE_HORIZONTAL))
{ e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
bd->client.netwm.state.maximized_h = 1;
changed = 1;
}
break; break;
case ECORE_X_WINDOW_STATE_ACTION_TOGGLE: case ECORE_X_WINDOW_STATE_ACTION_TOGGLE:
bd->client.netwm.state.maximized_h = !bd->client.netwm.state.maximized_h; if (bd->maximized & E_MAXIMIZE_HORIZONTAL)
changed = 1; e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
else
e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_HORIZONTAL);
break; 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; break;
case ECORE_X_WINDOW_STATE_SHADED: case ECORE_X_WINDOW_STATE_SHADED:
if (bd->lock_client_shade) return; if (bd->lock_client_shade) return;
@ -1022,85 +1002,33 @@ e_hints_window_size_get(E_Border *bd)
} }
EAPI void 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 ((horizontal) && (!bd->client.netwm.state.maximized_h))
{ {
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 )
{
bd->client.netwm.update.state = 1; bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_h = 1; bd->client.netwm.state.maximized_h = 1;
bd->changed = 1; bd->changed = 1;
} }
} else if ((!horizontal) && (bd->client.netwm.state.maximized_h))
else {
{
if( !bd->client.netwm.state.maximized_v )
{
bd->client.netwm.update.state = 1; bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 1; bd->client.netwm.state.maximized_h = 0;
bd->changed = 1; bd->changed = 1;
} }
if( !bd->client.netwm.state.maximized_h ) if ((vertical) && (!bd->client.netwm.state.maximized_v))
{
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))
{ {
bd->client.netwm.update.state = 1; bd->client.netwm.update.state = 1;
bd->client.netwm.state.maximized_v = 1; bd->client.netwm.state.maximized_v = 1;
bd->changed = 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.update.state = 1;
bd->client.netwm.state.maximized_v = 0; bd->client.netwm.state.maximized_v = 0;
bd->changed = 1; 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 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 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_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_fullscreen_set(E_Border *bd, int on);
EAPI void e_hints_window_sticky_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); 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) && if ((!bd->lock_user_maximize) && (!bd->shaded) &&
((bd->layer == 50) || (bd->layer == 100) || (bd->layer == 150))) ((bd->layer == 50) || (bd->layer == 100) || (bd->layer == 150)))
{ {
int __fullmaximization = 0;
m = e_menu_new(); m = e_menu_new();
e_menu_category_set(m,"border/maximize"); e_menu_category_set(m,"border/maximize");
e_menu_category_data_set("border/maximize",bd); e_menu_category_data_set("border/maximize",bd);
bd->border_maximize_menu = m; bd->border_maximize_menu = m;
mi = e_menu_item_new(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_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0)); e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH);
e_menu_item_toggle_set( mi, ( ( (__fullmaximization = bd->maximized &&
bd->maximized != E_MAXIMIZE_VERTICAL &&
bd->maximized != E_MAXIMIZE_HORIZONTAL)) ? 1 : 0 ));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd); e_menu_item_callback_set(mi, _e_border_menu_cb_maximize, bd);
e_menu_item_icon_edje_set(mi, e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders", (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"); "widgets/border/default/maximize");
mi = e_menu_item_new(m); 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_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0)); e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_VERTICAL));
e_menu_item_toggle_set( mi, ( ( (bd->maximized &&
bd->maximized == E_MAXIMIZE_VERTICAL &&
bd->maximized != E_MAXIMIZE_HORIZONTAL) ||
__fullmaximization ) ? 1 : 0 ));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_vertically, bd); e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_vertically, bd);
e_menu_item_icon_edje_set(mi, e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders", (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"); "widgets/border/default/maximize");
mi = e_menu_item_new(m); 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_check_set(mi, 1);
//e_menu_item_toggle_set(mi, (bd->maximized ? 1 : 0)); e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_HORIZONTAL));
e_menu_item_toggle_set( mi, ( ( (bd->maximized &&
bd->maximized != E_MAXIMIZE_VERTICAL &&
bd->maximized == E_MAXIMIZE_HORIZONTAL) ||
__fullmaximization ) ? 1 : 0 ));
e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_horizontally, bd); e_menu_item_callback_set(mi, _e_border_menu_cb_maximize_horizontally, bd);
e_menu_item_icon_edje_set(mi, e_menu_item_icon_edje_set(mi,
(char *)e_theme_edje_file_get("base/theme/borders", (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"); "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) if (!bd->lock_user_sticky)
{ {
mi = e_menu_item_new(m); 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; bd = data;
if (!bd->lock_user_maximize) if (!bd->lock_user_maximize)
{ {
if (bd->maximized != E_MAXIMIZE_NONE && if (bd->maximized & E_MAXIMIZE_BOTH)
bd->maximized != E_MAXIMIZE_VERTICAL && e_border_unmaximize(bd, E_MAXIMIZE_BOTH);
bd->maximized != E_MAXIMIZE_HORIZONTAL ) e_border_unmaximize(bd); else
else e_border_maximize(bd, e_config->maximize_policy); e_border_maximize(bd, (e_config->maximize_policy & E_MAXIMIZE_TYPE) | E_MAXIMIZE_BOTH);
} }
} }
/*** sndev : menu_cb_miximize_vertically callback **************/
static void static void
_e_border_menu_cb_maximize_vertically(void *data, E_Menu *m, E_Menu_Item *mi) _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; bd = data;
if (!bd->lock_user_maximize) if (!bd->lock_user_maximize)
{ {
if (bd->maximized && bd->maximized != E_MAXIMIZE_HORIZONTAL ) if ((bd->maximized & E_MAXIMIZE_VERTICAL))
e_border_unmaximize_vh(bd, E_MAXIMIZE_VERTICAL ); e_border_unmaximize(bd, E_MAXIMIZE_VERTICAL);
else e_border_maximize(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 static void
_e_border_menu_cb_maximize_horizontally(void *data, E_Menu *m, E_Menu_Item *mi) _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; bd = data;
if (!bd->lock_user_maximize) if (!bd->lock_user_maximize)
{ {
if (bd->maximized && bd->maximized != E_MAXIMIZE_VERTICAL ) if ((bd->maximized & E_MAXIMIZE_HORIZONTAL))
e_border_unmaximize_vh(bd, E_MAXIMIZE_HORIZONTAL ); e_border_unmaximize(bd, E_MAXIMIZE_HORIZONTAL);
else e_border_maximize(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 static void
_e_border_menu_cb_shade(void *data, E_Menu *m, E_Menu_Item *mi) _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_Config_Dialog_Data *cfdata;
E_Module *m; E_Module *m;
const char *v;
cfdata = data; cfdata = data;
if (!cfdata->modname) return; if (!cfdata->modname) return;
@ -75,7 +74,6 @@ _module_about(void *data, void *data2)
{ {
E_Config_Dialog_Data *cfdata; E_Config_Dialog_Data *cfdata;
E_Module *m; E_Module *m;
const char *v;
cfdata = data; cfdata = data;
if (!cfdata->modname) return; 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) _load_inits(E_Config_Dialog *cfd, Evas_Object *il)
{ {
Evas *evas; Evas *evas;
Evas_Object *im, *o, *init_obj; Evas_Object *im;
Evas_List *init_dirs, *init; Evas_List *init_dirs, *init;
Ecore_Evas *eebuf; Ecore_Evas *eebuf;
Evas *evasbuf; Evas *evasbuf;
int i = 0; int i = 0;
int selnum = -1; int selnum = -1;
const char *s;
char *homedir; char *homedir;
if (!il) return; 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 use_resist;
int maximize_policy; int maximize_policy;
/*- ADVANCED -*/ /*- ADVANCED -*/
int maximize_direction;
double auto_raise_delay; double auto_raise_delay;
int desk_resist; int desk_resist;
int window_resist; int window_resist;
@ -57,9 +58,12 @@ _fill_data(E_Config_Dialog_Data *cfdata)
cfdata->desk_resist = e_config->desk_resist; cfdata->desk_resist = e_config->desk_resist;
cfdata->window_resist = e_config->window_resist; cfdata->window_resist = e_config->window_resist;
cfdata->gadget_resist = e_config->gadget_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) if (cfdata->maximize_policy == E_MAXIMIZE_NONE)
cfdata->maximize_policy = E_MAXIMIZE_FULLSCREEN; 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; 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 */ /* Actually take our cfdata settings and apply them in real life */
e_config->use_auto_raise = cfdata->use_auto_raise; e_config->use_auto_raise = cfdata->use_auto_raise;
e_config->use_resist = cfdata->use_resist; 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(); e_config_save_queue();
return 1; /* Apply was OK */ 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->desk_resist = cfdata->desk_resist;
e_config->window_resist = cfdata->window_resist; e_config->window_resist = cfdata->window_resist;
e_config->gadget_resist = cfdata->gadget_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->allow_manip = cfdata->allow_manip;
e_config_save_queue(); e_config_save_queue();
return 1; /* Apply was OK */ 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); 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_framelist_object_append(of, ob);
e_widget_list_object_append(o, of, 1, 1, 0.5); e_widget_list_object_append(o, of, 1, 1, 0.5);
of = e_widget_framelist_add(evas, _("Maximize Policy"), 0); of = e_widget_framelist_add(evas, _("Maximize Policy"), 0);
rg = e_widget_radio_group_new(&(cfdata->maximize_policy)); rg = e_widget_radio_group_new(&(cfdata->maximize_policy));
ob = e_widget_radio_add(evas, _("Fullscreen"), E_MAXIMIZE_FULLSCREEN, rg); 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); e_widget_framelist_object_append(of, ob);
ob = e_widget_radio_add(evas, _("Fill available space"), E_MAXIMIZE_FILL, rg); ob = e_widget_radio_add(evas, _("Fill available space"), E_MAXIMIZE_FILL, rg);
e_widget_framelist_object_append(of, ob); 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)); ob = e_widget_check_add(evas, _("Allow window manipulation"), &(cfdata->allow_manip));
e_widget_framelist_object_append(of, ob); e_widget_framelist_object_append(of, ob);
e_widget_list_object_append(o, of, 1, 1, 0.5); e_widget_list_object_append(o, of, 1, 1, 0.5);
return o; 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 */ /* generate the core widget layout for a basic dialog */
Evas_Object *o, *of, *ob, *oi, *oj; Evas_Object *o, *of, *ob, *oi, *oj;
E_Radio_Group *rg;
Evas_Coord wmw, wmh; Evas_Coord wmw, wmh;
Evas_List *styles, *l; Evas_List *styles, *l;
int sel, n; int sel, n;