e16
/
e16
3
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
e16/src/groups.c

1425 lines
35 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
* Copyright (C) 2004-2023 Kim Woelders
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of the Software, its documentation and marketing & publicity
* materials, and acknowledgment shall be given in the documentation, materials
* and software packages that this Software was used.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "E.h"
#include "borders.h"
#include "dialog.h"
#include "emodule.h"
#include "ewins.h"
#include "groups.h"
#include "list.h"
#include "settings.h"
#include "snaps.h"
#define DEBUG_GROUPS 0
#if DEBUG_GROUPS
#define Dprintf(fmt, ...) Eprintf("%s: " fmt, __func__, __VA_ARGS__)
#else
#define Dprintf(fmt...)
#endif
#define USE_GROUP_SHOWHIDE 1 /* Enable group borders */
#define GROUP_SELECT_ALL 0
#define GROUP_SELECT_EWIN_ONLY 1
#define GROUP_SELECT_ALL_EXCEPT_EWIN 2
#define SET_OFF 0
#define SET_ON 1
#define SET_TOGGLE 2
typedef struct _groupconfig {
char iconify;
char kill;
char move;
char raise;
char set_border;
char shade;
char stick;
} GroupConfig;
struct _group {
dlist_t list;
int index;
EWin **members;
int num_members;
GroupConfig cfg;
char keep; /* Don't destroy when empty */
char used; /* Don't discard when saving */
};
static LIST_HEAD(group_list);
static struct {
GroupConfig dflt;
} Conf_groups;
static struct {
Group *current;
} Mode_groups;
static void _GroupsSave(void);
static Group *
_GroupCreate(int gid, int cfg_update)
{
Group *g;
g = ECALLOC(Group, 1);
if (!g)
return NULL;
LIST_APPEND(Group, &group_list, g);
if (gid == -1)
{
/* Create new group id */
/* ... using us time. Should really be checked for uniqueness. */
g->index = (int)GetTimeUs();
}
else
{
/* Use given group id */
g->index = gid;
}
g->cfg.iconify = Conf_groups.dflt.iconify;
g->cfg.kill = Conf_groups.dflt.kill;
g->cfg.move = Conf_groups.dflt.move;
g->cfg.raise = Conf_groups.dflt.raise;
g->cfg.set_border = Conf_groups.dflt.set_border;
g->cfg.stick = Conf_groups.dflt.stick;
g->cfg.shade = Conf_groups.dflt.shade;
Dprintf("%s: grp=%p gid=%d\n", __func__, g, g->index);
if (cfg_update)
_GroupsSave();
return g;
}
static void
_GroupDestroy(Group *g, int cfg_update)
{
if (!g)
return;
Dprintf("%s: grp=%p gid=%d\n", __func__, g, g->index);
LIST_REMOVE(Group, &group_list, g);
if (g == Mode_groups.current)
Mode_groups.current = NULL;
Efree(g->members);
Efree(g);
if (cfg_update)
_GroupsSave();
}
static int
_GroupMatchId(const void *data, const void *match)
{
return ((const Group *)data)->index != PTR2INT(match);
}
static Group *
_GroupFind(int gid)
{
return LIST_FIND(Group, &group_list, _GroupMatchId, INT2PTR(gid));
}
EWin *const *
GroupGetMembers(const Group *g, int *num)
{
*num = g->num_members;
return g->members;
}
int
GroupGetIndex(const Group *g)
{
return g->index;
}
void
GroupSetUsed(int gid)
{
Group *g;
g = _GroupFind(gid);
if (!g)
return;
g->used = 1;
}
int
GroupMatchAction(const Group *g, int action)
{
int match;
switch (action)
{
default:
match = 0;
break;
case GROUP_ACTION_ANY:
match = 1;
break;
case GROUP_ACTION_SET_WINDOW_BORDER:
match = g->cfg.set_border;
break;
case GROUP_ACTION_ICONIFY:
match = g->cfg.iconify;
break;
case GROUP_ACTION_MOVE:
match = g->cfg.move;
break;
case GROUP_ACTION_STACKING:
match = g->cfg.raise;
break;
case GROUP_ACTION_STICK:
match = g->cfg.stick;
break;
case GROUP_ACTION_SHADE:
match = g->cfg.shade;
break;
case GROUP_ACTION_KILL:
match = g->cfg.kill;
break;
}
return match;
}
static Group *
_GroupFind2(const char *groupid)
{
int gid;
if (groupid[0] == '*' || groupid[0] == '\0')
return Mode_groups.current;
#if ENABLE_DIALOGS
#define GROUP_CHOOSE ((Group*)1)
if (groupid[0] == '=')
return GROUP_CHOOSE;
#endif
gid = 0;
sscanf(groupid, "%d", &gid);
if (gid == 0)
return NULL;
return _GroupFind(gid);
}
static int
_EwinGroupIndex(const EWin *ewin, const Group *g)
{
int i;
for (i = 0; i < ewin->num_groups; i++)
if (ewin->groups[i] == g)
return i;
return -1;
}
static int
_GroupEwinIndex(const Group *g, const EWin *ewin)
{
int i;
for (i = 0; i < g->num_members; i++)
if (g->members[i] == ewin)
return i;
return -1;
}
static void
_GroupEwinAdd(Group *g, EWin *ewin, int snap_update)
{
if (!ewin || !g)
return;
if (_EwinGroupIndex(ewin, g) >= 0)
return; /* Already there */
Dprintf("%s: gid=%8d: %s\n", __func__, g->index, EoGetName(ewin));
ewin->num_groups++;
ewin->groups = EREALLOC(Group *, ewin->groups, ewin->num_groups);
ewin->groups[ewin->num_groups - 1] = g;
g->num_members++;
g->members = EREALLOC(EWin *, g->members, g->num_members);
g->members[g->num_members - 1] = ewin;
if (snap_update)
SnapshotEwinUpdate(ewin, SNAP_USE_GROUPS);
}
static void
_GroupEwinRemove(Group *g, EWin *ewin, int snap_update)
{
int i, ie, ig;
if (!ewin || !g)
return;
Dprintf("%s: gid=%8d: %s\n", __func__, g->index, EoGetName(ewin));
ie = _EwinGroupIndex(ewin, g);
if (ie < 0)
{
/* Should not happen */
Dprintf("%s: g=%p gid=%8d: %s: Group not found?!?\n", __func__,
g, g->index, EoGetName(ewin));
return;
}
ig = _GroupEwinIndex(g, ewin);
if (ig < 0)
{
/* Should not happen */
Dprintf("%s: g=%p gid=%8d: %s: Ewin not found?!?\n", __func__,
g, g->index, EoGetName(ewin));
return;
}
Dprintf("%s: gid=%8d index=%d/%d: %s\n", __func__,
g->index, ie, ig, EoGetName(ewin));
/* remove it from the group */
g->num_members--;
for (i = ig; i < g->num_members; i++)
g->members[i] = g->members[i + 1];
if (g->num_members > 0)
g->members = EREALLOC(EWin *, g->members, g->num_members);
else if (g->keep)
EFREE_NULL(g->members);
else
_GroupDestroy(g, snap_update);
/* and remove the group from the groups that the window is in */
ewin->num_groups--;
for (i = ie; i < ewin->num_groups; i++)
ewin->groups[i] = ewin->groups[i + 1];
if (ewin->num_groups > 0)
ewin->groups = EREALLOC(Group *, ewin->groups, ewin->num_groups);
else
EFREE_NULL(ewin->groups);
if (snap_update)
SnapshotEwinUpdate(ewin, SNAP_USE_GROUPS);
}
static void
_GroupDelete(Group *g)
{
if (!g)
return;
Dprintf("%s: gid=%d\n", __func__, g->index);
g->keep = 1;
while (g->num_members > 0)
_GroupEwinRemove(g, g->members[0], 1);
_GroupDestroy(g, 1);
}
Group **
GroupsGetList(int *pnum)
{
return LIST_GET_ITEMS(Group, &group_list, pnum);
}
#if ENABLE_DIALOGS
static Group **
_EwinListGroups(const EWin *ewin, char group_select, int *num)
{
Group **groups;
Group **groups2;
int i, j, n, killed;
groups = NULL;
*num = 0;
switch (group_select)
{
case GROUP_SELECT_EWIN_ONLY:
*num = n = ewin->num_groups;
if (n <= 0)
break;
groups = EMALLOC(Group *, n);
if (!groups)
break;
memcpy(groups, ewin->groups, n * sizeof(Group *));
break;
case GROUP_SELECT_ALL_EXCEPT_EWIN:
groups2 = GroupsGetList(num);
if (!groups2)
break;
n = *num;
for (i = killed = 0; i < n; i++)
{
for (j = 0; j < ewin->num_groups; j++)
{
if (ewin->groups[j] == groups2[i])
{
groups2[i] = NULL;
killed++;
}
}
}
if (n - killed > 0)
{
groups = EMALLOC(Group *, n - killed);
if (groups)
{
for (i = j = 0; i < n; i++)
if (groups2[i])
groups[j++] = groups2[i];
*num = n - killed;
}
}
Efree(groups2);
break;
case GROUP_SELECT_ALL:
default:
groups = GroupsGetList(num);
break;
}
return groups;
}
#endif /* ENABLE_DIALOGS */
/* Update groups on snapped window appearance */
void
GroupsEwinAdd(EWin *ewin, const int *pgid, int ngid)
{
Group *g;
int i, gid;
for (i = 0; i < ngid; i++)
{
gid = pgid[i];
g = _GroupFind(gid);
Dprintf("ewin=%p gid=%d grp=%p\n", ewin, gid, g);
if (!g)
{
/* This should not happen, but may if group/snap configs are corrupted */
g = _GroupCreate(gid, 1);
}
_GroupEwinAdd(g, ewin, 0);
}
}
/* Update groups on snapped window disappearance */
void
GroupsEwinRemove(EWin *ewin)
{
while (ewin->num_groups > 0)
_GroupEwinRemove(ewin->groups[0], ewin, 0);
}
Group *
EwinsInGroup(const EWin *ewin1, const EWin *ewin2)
{
int i;
if (ewin1 && ewin2)
{
for (i = 0; i < ewin1->num_groups; i++)
{
if (_GroupEwinIndex(ewin1->groups[i], ewin2) >= 0)
return ewin1->groups[i];
}
}
return NULL;
}
#if ENABLE_DIALOGS
static char **
_GrouplistMemberNames(Group **groups, int num)
{
int i, j, len;
char **group_member_strings;
const char *name;
group_member_strings = ECALLOC(char *, num);
if (!group_member_strings)
return NULL;
for (i = 0; i < num; i++)
{
group_member_strings[i] = EMALLOC(char, 1024);
if (!group_member_strings[i])
break;
len = 0;
for (j = 0; j < groups[i]->num_members; j++)
{
name = EwinGetTitle(groups[i]->members[j]);
if (!name) /* Should never happen */
continue;
len += Esnprintf(group_member_strings[i] + len, 1024 - len,
"%s\n", name);
if (len >= 1024)
break;
}
if (len == 0)
snprintf(group_member_strings[i], 1024, "(empty)");
}
return group_member_strings;
}
#endif /* ENABLE_DIALOGS */
#if USE_GROUP_SHOWHIDE
static void
_EwinGroupsShowHide(EWin *ewin, int group_index, char onoff)
{
EWin **gwins;
int i, num;
const Border *b = NULL;
if (!ewin || group_index >= ewin->num_groups)
return;
if (group_index < 0)
{
gwins = ListWinGroupMembersForEwin(ewin, GROUP_ACTION_ANY, 0, &num);
}
else
{
gwins = ewin->groups[group_index]->members;
num = ewin->groups[group_index]->num_members;
}
if (onoff == SET_TOGGLE)
onoff = (ewin->border == ewin->normal_border) ? SET_ON : SET_OFF;
for (i = 0; i < num; i++)
{
if (onoff == SET_ON)
b = EwinBorderGetGroupBorder(gwins[i]);
else
b = gwins[i]->normal_border;
EwinBorderChange(gwins[i], b, 0);
}
if (group_index < 0)
Efree(gwins);
}
#else
#define _EwinGroupsShowHide(ewin, group_index, onoff)
#endif /* USE_GROUP_SHOWHIDE */
static void
_GroupsSave(void)
{
Group *g;
FILE *f;
char s[1024];
Dprintf("%s\n", __func__);
Esnprintf(s, sizeof(s), "%s.groups", EGetSavePrefix());
f = fopen(s, "w");
if (!f)
return;
LIST_FOR_EACH(Group, &group_list, g)
{
fprintf(f, "NEW: %i\n", g->index);
fprintf(f, "ICONIFY: %i\n", g->cfg.iconify);
fprintf(f, "KILL: %i\n", g->cfg.kill);
fprintf(f, "MOVE: %i\n", g->cfg.move);
fprintf(f, "RAISE: %i\n", g->cfg.raise);
fprintf(f, "SET_BORDER: %i\n", g->cfg.set_border);
fprintf(f, "STICK: %i\n", g->cfg.stick);
fprintf(f, "SHADE: %i\n", g->cfg.shade);
}
fclose(f);
}
void
GroupsPrune(void)
{
Group *g, *tmp;
int pruned;
pruned = 0;
LIST_FOR_EACH_SAFE(Group, &group_list, g, tmp)
{
if (g->used)
continue;
if (g->members)
continue;
_GroupDestroy(g, 0);
pruned += 1;
}
Dprintf("%s: Pruned=%d\n", __func__, pruned);
if (pruned)
_GroupsSave();
}
static int
_GroupsLoad(FILE *fs)
{
char s[1024];
Group *g = NULL;
while (fgets(s, sizeof(s), fs))
{
char ss[128];
int ii;
if (strlen(s) > 0)
s[strlen(s) - 1] = 0;
ii = 0;
sscanf(s, "%100s %d", ss, &ii);
if (!strcmp(ss, "NEW:"))
{
g = _GroupCreate(ii, 0);
continue;
}
if (!g)
continue;
if (!strcmp(ss, "ICONIFY:"))
{
g->cfg.iconify = ii;
}
else if (!strcmp(ss, "KILL:"))
{
g->cfg.kill = ii;
}
else if (!strcmp(ss, "MOVE:"))
{
g->cfg.move = ii;
}
else if (!strcmp(ss, "RAISE:"))
{
g->cfg.raise = ii;
}
else if (!strcmp(ss, "SET_BORDER:"))
{
g->cfg.set_border = ii;
}
else if (!strcmp(ss, "STICK:"))
{
g->cfg.stick = ii;
}
else if (!strcmp(ss, "SHADE:"))
{
g->cfg.shade = ii;
}
}
return 0;
}
void
GroupsLoad(void)
{
char s[4096];
Dprintf("%s\n", __func__);
Esnprintf(s, sizeof(s), "%s.groups", EGetSavePrefix());
ConfigFileLoad(s, NULL, _GroupsLoad, 0);
}
#if ENABLE_DIALOGS
#define GROUP_OP_ADD 1
#define GROUP_OP_DEL 2
#define GROUP_OP_BREAK 3
typedef struct {
EWin *ewin;
int action;
const char *message;
Group **groups;
int group_num;
int cur_grp; /* Current group */
int prv_grp; /* Previous group */
} GroupSelDlgData;
static void
_DlgApplyGroupChoose(Dialog *d, int val __UNUSED__, void *data __UNUSED__)
{
GroupSelDlgData *dd = DLG_DATA_GET(d, GroupSelDlgData);
if (!dd->groups)
return;
switch (dd->action)
{
case GROUP_OP_ADD:
_GroupEwinAdd(dd->groups[dd->cur_grp], dd->ewin, 1);
break;
case GROUP_OP_DEL:
_GroupEwinRemove(dd->groups[dd->cur_grp], dd->ewin, 1);
break;
case GROUP_OP_BREAK:
_GroupDelete(dd->groups[dd->cur_grp]);
break;
default:
break;
}
}
static void
_DlgExitGroupChoose(Dialog *d)
{
GroupSelDlgData *dd = DLG_DATA_GET(d, GroupSelDlgData);
if (!dd->groups)
return;
_EwinGroupsShowHide(dd->ewin, dd->cur_grp, SET_OFF);
Efree(dd->groups);
}
static void
_DlgSelectCbGroupChoose(Dialog *d, int val, void *data __UNUSED__)
{
GroupSelDlgData *dd = DLG_DATA_GET(d, GroupSelDlgData);
/* val is equal to dd->cur_grp */
_EwinGroupsShowHide(dd->ewin, dd->prv_grp, SET_OFF);
_EwinGroupsShowHide(dd->ewin, val, SET_ON);
dd->prv_grp = val;
}
static void
_DlgFillGroupChoose(Dialog *d, DItem *table, void *data)
{
GroupSelDlgData *dd = DLG_DATA_GET(d, GroupSelDlgData);
DItem *di, *radio;
int i, num_groups;
char **group_member_strings;
*dd = *(GroupSelDlgData *) data;
DialogItemTableSetOptions(table, 1, 0, 0, 0);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, dd->message);
num_groups = dd->group_num;
group_member_strings = _GrouplistMemberNames(dd->groups, num_groups);
if (!group_member_strings)
return; /* Silence clang - It should not be possible to go here */
radio = NULL; /* Avoid warning */
for (i = 0; i < num_groups; i++)
{
di = DialogAddItem(table, DITEM_RADIOBUTTON);
if (i == 0)
radio = di;
DialogItemSetCallback(di, _DlgSelectCbGroupChoose, i, NULL);
DialogItemSetText(di, group_member_strings[i]);
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, i);
}
DialogItemRadioButtonGroupSetValPtr(radio, &dd->cur_grp);
StrlistFree(group_member_strings, num_groups);
}
static const DialogDef DlgGroupChoose = {
"GROUP_SELECTION",
NULL, N_("Window Group Selection"),
sizeof(GroupSelDlgData),
SOUND_SETTINGS_GROUP,
"pix/group.png",
N_("Enlightenment Window Group\n" "Selection Dialog"),
_DlgFillGroupChoose,
DLG_OC, _DlgApplyGroupChoose, _DlgExitGroupChoose
};
static void
_EwinGroupChooseDialog(EWin *ewin, int action)
{
int group_sel;
GroupSelDlgData gsdd, *dd = &gsdd;
if (!ewin)
return;
dd->ewin = ewin;
dd->action = action;
dd->cur_grp = dd->prv_grp = 0;
switch (action)
{
default:
return;
case GROUP_OP_ADD:
dd->message = _("Pick the group the window will belong to:");
group_sel = GROUP_SELECT_ALL_EXCEPT_EWIN;
break;
case GROUP_OP_DEL:
dd->message = _("Select the group to remove the window from:");
group_sel = GROUP_SELECT_EWIN_ONLY;
break;
case GROUP_OP_BREAK:
dd->message = _("Select the group to break:");
group_sel = GROUP_SELECT_EWIN_ONLY;
break;
}
dd->groups = _EwinListGroups(dd->ewin, group_sel, &dd->group_num);
if (!dd->groups)
{
if (action == GROUP_OP_BREAK || action == GROUP_OP_DEL)
{
DialogOK(_("Window Group Error"),
_
("This window currently does not belong to any groups.\n"
"You can only destroy groups or remove windows from groups\n"
"through a window that actually belongs to at least one group."));
return;
}
if (group_sel == GROUP_SELECT_ALL_EXCEPT_EWIN)
{
DialogOK(_("Window Group Error"),
_("Currently, no groups exist or this window\n"
"already belongs to all existing groups.\n"
"You have to start other groups first."));
return;
}
DialogOK(_("Window Group Error"),
_
("Currently, no groups exist. You have to start a group first."));
return;
}
_EwinGroupsShowHide(dd->ewin, 0, SET_ON);
DialogShowSimple(&DlgGroupChoose, dd);
}
typedef struct {
EWin *ewin;
GroupConfig cfg; /* Dialog data for current group */
GroupConfig *cfgs; /* Work copy of ewin group cfgs */
int ngrp;
int cur_grp; /* Current group */
int prv_grp; /* Previous group */
} EwinGroupDlgData;
static void
_DlgApplyGroups(Dialog *d, int val __UNUSED__, void *data __UNUSED__)
{
EwinGroupDlgData *dd = DLG_DATA_GET(d, EwinGroupDlgData);
EWin *ewin;
int i;
/* Check ewin */
ewin = EwinFindByPtr(dd->ewin);
if (ewin && ewin->num_groups != dd->ngrp)
ewin = NULL;
if (ewin)
{
dd->cfgs[dd->cur_grp] = dd->cfg;
for (i = 0; i < ewin->num_groups; i++)
ewin->groups[i]->cfg = dd->cfgs[i];
}
_GroupsSave();
}
static void
_DlgExitGroups(Dialog *d)
{
EwinGroupDlgData *dd = DLG_DATA_GET(d, EwinGroupDlgData);
EWin *ewin;
ewin = EwinFindByPtr(dd->ewin);
_EwinGroupsShowHide(ewin, dd->cur_grp, SET_OFF);
Efree(dd->cfgs);
}
static void
_DlgSelectCbGroups(Dialog *d, int val, void *data __UNUSED__)
{
EwinGroupDlgData *dd = DLG_DATA_GET(d, EwinGroupDlgData);
/* val is equal to dd->cur_grp */
dd->cfgs[dd->prv_grp] = dd->cfg;
dd->cfg = dd->cfgs[val];
DialogRedraw(d);
_EwinGroupsShowHide(dd->ewin, dd->prv_grp, SET_OFF);
_EwinGroupsShowHide(dd->ewin, val, SET_ON);
dd->prv_grp = val;
}
static void
_DlgFillGroups(Dialog *d, DItem *table, void *data)
{
EwinGroupDlgData *dd = DLG_DATA_GET(d, EwinGroupDlgData);
EWin *ewin = (EWin *) data;
DItem *radio, *di;
int i;
char **group_member_strings;
dd->ewin = ewin;
dd->cfgs = EMALLOC(GroupConfig, ewin->num_groups);
dd->ngrp = ewin->num_groups;
dd->cur_grp = dd->prv_grp = 0;
for (i = 0; i < ewin->num_groups; i++)
dd->cfgs[i] = ewin->groups[i]->cfg;
if (ewin->num_groups > 0) /* Avoid compiler warning */
dd->cfg = dd->cfgs[0];
_EwinGroupsShowHide(ewin, 0, SET_ON);
DialogItemTableSetOptions(table, 2, 0, 0, 0);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Pick the group to configure:"));
group_member_strings =
_GrouplistMemberNames(ewin->groups, ewin->num_groups);
if (!group_member_strings)
return; /* Silence clang - It should not be possible to go here */
radio = NULL; /* Avoid warning */
for (i = 0; i < ewin->num_groups; i++)
{
di = DialogAddItem(table, DITEM_RADIOBUTTON);
if (i == 0)
radio = di;
DialogItemSetColSpan(di, 2);
DialogItemSetCallback(di, _DlgSelectCbGroups, i, d);
DialogItemSetText(di, group_member_strings[i]);
DialogItemRadioButtonSetFirst(di, radio);
DialogItemRadioButtonGroupSetVal(di, i);
}
DialogItemRadioButtonGroupSetValPtr(radio, &dd->cur_grp);
StrlistFree(group_member_strings, ewin->num_groups);
di = DialogAddItem(table, DITEM_SEPARATOR);
DialogItemSetColSpan(di, 2);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("The following actions are\n"
"applied to all group members:"));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Changing border style"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.set_border));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Iconifying"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.iconify));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Killing"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.kill));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Moving"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.move));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Raising/lowering"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.raise));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Sticking"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.stick));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Shading"));
DialogItemCheckButtonSetPtr(di, &(dd->cfg.shade));
}
static const DialogDef DlgGroups = {
"CONFIGURE_GROUP",
NULL, N_("Window Group Settings"),
sizeof(EwinGroupDlgData),
SOUND_SETTINGS_GROUP,
"pix/group.png",
N_("Enlightenment Window Group\n" "Settings Dialog"),
_DlgFillGroups,
DLG_OAC, _DlgApplyGroups, _DlgExitGroups
};
static void
_EwinGroupsConfig(EWin *ewin)
{
if (!ewin)
return;
if (ewin->num_groups == 0)
{
DialogOK(_("Window Group Error"),
_("This window currently does not belong to any groups."));
return;
}
DialogShowSimple(&DlgGroups, ewin);
}
typedef struct {
GroupConfig group_cfg;
} GroupCfgDlgData;
static void
_DlgApplyGroupDefaults(Dialog *d, int val __UNUSED__, void *data __UNUSED__)
{
GroupCfgDlgData *dd = DLG_DATA_GET(d, GroupCfgDlgData);
Conf_groups.dflt = dd->group_cfg;
autosave();
}
static void
_DlgFillGroupDefaults(Dialog *d, DItem *table, void *data __UNUSED__)
{
GroupCfgDlgData *dd = DLG_DATA_GET(d, GroupCfgDlgData);
DItem *di;
dd->group_cfg = Conf_groups.dflt;
DialogItemTableSetOptions(table, 2, 0, 0, 0);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Per-group settings:"));
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Changing border style"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.set_border);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Iconifying"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.iconify);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Killing"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.kill);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Moving"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.move);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Raising/lowering"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.raise);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Sticking"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.stick);
di = DialogAddItem(table, DITEM_CHECKBUTTON);
DialogItemSetColSpan(di, 2);
DialogItemSetText(di, _("Shading"));
DialogItemCheckButtonSetPtr(di, &dd->group_cfg.shade);
}
const DialogDef DlgGroupDefaults = {
"CONFIGURE_DEFAULT_GROUP_CONTROL",
N_("Groups"), N_("Default Group Control Settings"),
sizeof(GroupCfgDlgData),
SOUND_SETTINGS_GROUP,
"pix/group.png",
N_("Enlightenment Default\n" "Group Control Settings Dialog"),
_DlgFillGroupDefaults,
DLG_OAC, _DlgApplyGroupDefaults, NULL
};
#endif /* ENABLE_DIALOGS */
/*
* Groups module
*/
static void
_GroupShowEwins(Group *g)
{
int i;
IpcPrintf(" gid=%8d: ", g->index);
for (i = 0; i < g->num_members; i++)
IpcPrintf(" %s", EoGetName(g->members[i]));
IpcPrintf("\n");
}
static void
_GroupsShowGroups(void)
{
Group *g;
IpcPrintf("%s:\n", __func__);
LIST_FOR_EACH(Group, &group_list, g)
{
_GroupShowEwins(g);
}
}
static void
_GroupsShow(void)
{
_GroupsShowGroups();
}
static void
_GroupShow(Group *g)
{
int j;
for (j = 0; j < g->num_members; j++)
IpcPrintf("%d: %s\n", g->index, EwinGetIcccmName(g->members[j]));
IpcPrintf(" index: %d\n" " num_members: %d\n"
" iconify: %d\n" " kill: %d\n"
" move: %d\n" " raise: %d\n"
" set_border: %d\n" " stick: %d\n"
" shade: %d\n",
g->index, g->num_members,
g->cfg.iconify, g->cfg.kill,
g->cfg.move, g->cfg.raise,
g->cfg.set_border, g->cfg.stick, g->cfg.shade);
}
static void
IPC_GroupOps(const char *params)
{
Group *group;
char windowid[128];
char operation[128];
char groupid[128];
unsigned int win;
EWin *ewin;
if (!params)
{
IpcPrintf("Error: no window specified\n");
return;
}
windowid[0] = operation[0] = groupid[0] = '\0';
sscanf(params, "%100s %100s %100s", windowid, operation, groupid);
win = 0;
sscanf(windowid, "%x", &win);
if (!operation[0])
{
IpcPrintf("Error: no operation specified\n");
return;
}
ewin = EwinFindByExpr(windowid);
if (!ewin)
{
IpcPrintf("Error: no such window: %s\n", windowid);
return;
}
#if ENABLE_DIALOGS
if (!strcmp(operation, "cfg"))
{
_EwinGroupsConfig(ewin);
}
else
#endif
if (!strcmp(operation, "start"))
{
group = _GroupCreate(-1, 1);
Mode_groups.current = group;
_GroupEwinAdd(group, ewin, 1);
}
else if (!strcmp(operation, "add"))
{
group = _GroupFind2(groupid);
#if ENABLE_DIALOGS
if (group == GROUP_CHOOSE)
_EwinGroupChooseDialog(ewin, GROUP_OP_ADD);
else
_GroupEwinAdd(group, ewin, 1);
#endif
}
else if (!strcmp(operation, "del"))
{
group = _GroupFind2(groupid);
#if ENABLE_DIALOGS
if (group == GROUP_CHOOSE)
_EwinGroupChooseDialog(ewin, GROUP_OP_DEL);
else
#endif
_GroupEwinRemove(group, ewin, 1);
}
else if (!strcmp(operation, "break"))
{
group = _GroupFind2(groupid);
#if ENABLE_DIALOGS
if (group == GROUP_CHOOSE)
_EwinGroupChooseDialog(ewin, GROUP_OP_BREAK);
else
#endif
_GroupDelete(group);
}
else if (!strcmp(operation, "showhide"))
{
_EwinGroupsShowHide(ewin, -1, SET_TOGGLE);
}
else
{
IpcPrintf("Error: no such operation: %s\n", operation);
return;
}
}
static void
IPC_Group(const char *params)
{
char groupid[128];
char operation[128];
char param1[128];
Group *group;
int onoff;
if (!params)
{
IpcPrintf("Error: no operation specified\n");
return;
}
groupid[0] = operation[0] = param1[0] = '\0';
sscanf(params, "%100s %100s %100s", groupid, operation, param1);
if (!strcmp(groupid, "info"))
{
IpcPrintf("Number of groups: %d\n", LIST_GET_COUNT(&group_list));
LIST_FOR_EACH(Group, &group_list, group) _GroupShow(group);
return;
}
else if (!strcmp(groupid, "list"))
{
_GroupsShow();
return;
}
if (!operation[0])
{
IpcPrintf("Error: no operation specified\n");
return;
}
group = _GroupFind2(groupid);
if (!group)
{
IpcPrintf("Error: no such group: %s\n", groupid);
return;
}
if (!strcmp(operation, "info"))
{
_GroupShow(group);
return;
}
else if (!strcmp(operation, "del"))
{
_GroupDelete(group);
return;
}
if (!param1[0])
{
IpcPrintf("Error: no mode specified\n");
return;
}
onoff = -1;
if (!strcmp(param1, "on"))
onoff = 1;
else if (!strcmp(param1, "off"))
onoff = 0;
if (onoff == -1 && strcmp(param1, "?"))
{
IpcPrintf("Error: unknown mode specified\n");
}
else if (!strcmp(operation, "iconify"))
{
if (onoff >= 0)
group->cfg.iconify = onoff;
else
onoff = group->cfg.iconify;
}
else if (!strcmp(operation, "kill"))
{
if (onoff >= 0)
group->cfg.kill = onoff;
else
onoff = group->cfg.kill;
}
else if (!strcmp(operation, "move"))
{
if (onoff >= 0)
group->cfg.move = onoff;
else
onoff = group->cfg.move;
}
else if (!strcmp(operation, "raise"))
{
if (onoff >= 0)
group->cfg.raise = onoff;
else
onoff = group->cfg.raise;
}
else if (!strcmp(operation, "set_border"))
{
if (onoff >= 0)
group->cfg.set_border = onoff;
else
onoff = group->cfg.set_border;
}
else if (!strcmp(operation, "stick"))
{
if (onoff >= 0)
group->cfg.stick = onoff;
else
onoff = group->cfg.stick;
}
else if (!strcmp(operation, "shade"))
{
if (onoff >= 0)
group->cfg.shade = onoff;
else
onoff = group->cfg.shade;
}
else
{
IpcPrintf("Error: no such operation: %s\n", operation);
onoff = -1;
}
if (onoff == 1)
IpcPrintf("%s: on\n", operation);
else if (onoff == 0)
IpcPrintf("%s: off\n", operation);
if (onoff >= 0)
_GroupsSave();
}
static const IpcItem GroupsIpcArray[] = {
{
IPC_GroupOps,
"group_op", "gop",
"Group operations",
"use \"group_op <windowid> <property> [<value>]\" to perform "
"group operations on a window.\n"
"Available group_op commands are:\n"
" group_op <windowid> cfg\n"
" group_op <windowid> start\n"
" group_op <windowid> add [<groupid>]\n"
" group_op <windowid> del [<groupid>]\n"
" group_op <windowid> break [<groupid>]\n"
" group_op <windowid> showhide\n" }
,
{
IPC_Group,
"group", "grp",
"Group commands",
"use \"group <groupid> <property> <value>\" to set group properties.\n"
"Available group commands are:\n"
" group info\n"
" group <groupid> info\n"
" group <groupid> del\n"
" group <groupid> iconify <on/off/?>\n"
" group <groupid> kill <on/off/?>\n"
" group <groupid> move <on/off/?>\n"
" group <groupid> raise <on/off/?>\n"
" group <groupid> set_border <on/off/?>\n"
" group <groupid> stick <on/off/?>\n"
" group <groupid> shade <on/off/?>\n" }
,
};
/*
* Configuration items
*/
static const CfgItem GroupsCfgItems[] = {
CFG_ITEM_BOOL(Conf_groups, dflt.iconify, 1),
CFG_ITEM_BOOL(Conf_groups, dflt.kill, 0),
CFG_ITEM_BOOL(Conf_groups, dflt.move, 1),
CFG_ITEM_BOOL(Conf_groups, dflt.raise, 0),
CFG_ITEM_BOOL(Conf_groups, dflt.set_border, 1),
CFG_ITEM_BOOL(Conf_groups, dflt.stick, 1),
CFG_ITEM_BOOL(Conf_groups, dflt.shade, 1),
};
extern const EModule ModGroups;
const EModule ModGroups = {
"groups", "grp",
NULL,
MOD_ITEMS(GroupsIpcArray),
MOD_ITEMS(GroupsCfgItems)
};
Reference in New Issue View Git Blame Copy Permalink