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

randr - a nice module, isn't really needed anymroe now as almsot all the work 

is done by a config dialog (i added the safety box stuff from randr into it).
i just need to add the cde to restore on login now.


SVN revision: 20946
This commit is contained in:
Carsten Haitzler 2006-03-03 09:04:27 +00:00
parent 1426a69931
commit 7aa50d144d
9 changed files with 164 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure.in
View File

@ -298,7 +298,6 @@ src/modules/cpufreq/Makefile
src/modules/ibox/Makefile
src/modules/itray/Makefile
src/modules/start/Makefile
src/modules/randr/Makefile
src/preload/Makefile
data/Makefile
data/fonts/Makefile

19
src/bin/e_config.c
View File

@ -458,7 +458,6 @@ e_config_init(void)
E_CONFIG_LIST(D, T, gadcons, _e_config_gadcon_edd);
E_CONFIG_LIST(D, T, shelves, _e_config_shelf_edd);
E_CONFIG_VAL(D, T, font_hinting, INT);
E_CONFIG_VAL(D, T, desklock_personal_passwd, STR);
E_CONFIG_VAL(D, T, desklock_background, STR);
E_CONFIG_VAL(D, T, desklock_login_box_zone, INT);
@ -467,6 +466,11 @@ e_config_init(void)
E_CONFIG_VAL(D, T, desklock_timeout, DOUBLE);
E_CONFIG_VAL(D, T, desklock_disable_screensaver, INT);
E_CONFIG_VAL(D, T, display_res_restore, INT);
E_CONFIG_VAL(D, T, display_res_width, INT);
E_CONFIG_VAL(D, T, display_res_height, INT);
E_CONFIG_VAL(D, T, display_res_hz, INT);
e_config = e_config_domain_load("e", _e_config_edd);
if (e_config)
{
@ -627,6 +631,11 @@ e_config_init(void)
e_config->desklock_timeout = 300.0;
e_config->desklock_disable_screensaver = 0;
e_config->display_res_restore = 0;
e_config->display_res_width = 0;
e_config->display_res_height = 0;
e_config->display_res_hz = 0;
/* FIXME: fill up default gadcons! */
{
E_Config_Shelf *cf_es;
@ -725,10 +734,6 @@ e_config_init(void)
em->name = evas_stringshare_add("pager");
em->enabled = 1;
e_config->modules = evas_list_append(e_config->modules, em);
em = E_NEW(E_Config_Module, 1);
em->name = evas_stringshare_add("randr");
em->enabled = 1;
e_config->modules = evas_list_append(e_config->modules, em);
}
{
E_Font_Fallback* eff;
@ -1692,6 +1697,10 @@ e_config_init(void)
E_CONFIG_LIMIT(e_config->desklock_use_timeout, 0, 1);
E_CONFIG_LIMIT(e_config->desklock_timeout, 1.0, 600.0);
E_CONFIG_LIMIT(e_config->desklock_disable_screensaver, 0, 1);
E_CONFIG_LIMIT(e_config->display_res_restore, 0, 1);
E_CONFIG_LIMIT(e_config->display_res_width, 1, 8192);
E_CONFIG_LIMIT(e_config->display_res_height, 1, 8192);
E_CONFIG_LIMIT(e_config->display_res_hz, 0, 250);
return 1;
}

7
src/bin/e_config.h
View File

@ -49,7 +49,7 @@ typedef Eet_Data_Descriptor E_Config_DD;
* versioning feature. the value of this is really irrelevant - just as
* long as it increases every time we change something
*/
#define E_CONFIG_FILE_VERSION 140
#define E_CONFIG_FILE_VERSION 141
#define E_EVAS_ENGINE_DEFAULT 0
#define E_EVAS_ENGINE_SOFTWARE_X11 1
@ -219,6 +219,11 @@ struct _E_Config
int desklock_use_timeout; // GUI
double desklock_timeout; // GUI
int desklock_disable_screensaver;
int display_res_restore;
int display_res_width;
int display_res_height;
int display_res_hz;
};
struct _E_Config_Module

148
src/bin/e_int_config_display.c
View File

@ -17,6 +17,8 @@ Evas_Object *rate_list = NULL;
Evas_Object *res_list = NULL;
typedef struct _Resolution Resolution;
typedef struct _SureBox SureBox;
struct _Resolution
{
int size_id;
@ -24,14 +26,134 @@ struct _Resolution
Ecore_X_Screen_Refresh_Rate *rates;
};
struct _SureBox
{
E_Dialog *dia;
Ecore_Timer *timer;
int iterations;
Ecore_X_Screen_Size orig_size;
Ecore_X_Screen_Refresh_Rate orig_rate;
E_Config_Dialog *cfd;
E_Config_Dialog_Data *cfdata;
};
struct _E_Config_Dialog_Data
{
E_Config_Dialog *cfd;
Resolution *res;
Ecore_X_Screen_Size orig_size;
Ecore_X_Screen_Refresh_Rate orig_rate;
int restore;
SureBox *surebox;
};
static void
_surebox_dialog_cb_delete(E_Win *win)
{
E_Dialog *dia;
SureBox *sb;
dia = win->data;
sb = dia->data;
sb->cfdata->surebox = NULL;
if (sb->timer) ecore_timer_del(sb->timer);
sb->timer = NULL;
free(sb);
e_object_del(E_OBJECT(dia));
}
static void
_surebox_dialog_cb_yes(void *data, E_Dialog *dia)
{
_surebox_dialog_cb_delete(dia->win);
}
static void
_surebox_dialog_cb_no(void *data, E_Dialog *dia)
{
SureBox *sb;
sb = data;
ecore_x_randr_screen_refresh_rate_set(sb->dia->win->container->manager->root,
sb->orig_size, sb->orig_rate);
e_config->display_res_width = sb->orig_size.width;
e_config->display_res_height = sb->orig_size.height;
e_config->display_res_hz = sb->orig_rate.rate;
sb->cfdata->orig_size = sb->orig_size;
sb->cfdata->orig_rate = sb->orig_rate;
e_config_save_queue();
_surebox_dialog_cb_delete(dia->win);
}
static void
_surebox_text_fill(SureBox *sb)
{
char buf[4096];
snprintf(buf, sizeof(buf),
_("Does this look OK? Press <hilight>Yes</hilight> if it does, or No if not.<br>"
"If you do not press a button the old resolution of<br>"
"%dx%d at %d Hz will be restored in %d seconds."),
sb->orig_size.width, sb->orig_size.height,
sb->orig_rate.rate, sb->iterations);
e_dialog_text_set(sb->dia, buf);
}
static int
_surebox_timer_cb(void *data)
{
SureBox *sb;
sb = data;
sb->iterations--;
_surebox_text_fill(sb);
if (sb->iterations == 0)
{
ecore_x_randr_screen_refresh_rate_set(sb->dia->win->container->manager->root,
sb->orig_size, sb->orig_rate);
e_config->display_res_width = sb->orig_size.width;
e_config->display_res_height = sb->orig_size.height;
e_config->display_res_hz = sb->orig_rate.rate;
sb->cfdata->orig_size = sb->orig_size;
sb->cfdata->orig_rate = sb->orig_rate;
e_config_save_queue();
sb->timer = NULL;
e_object_del(E_OBJECT(sb->dia));
return 0;
}
return 1;
}
static SureBox *
_surebox_new(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
{
SureBox *sb;
sb = E_NEW(SureBox, 1);
sb->dia = e_dialog_new(cfd->con);
sb->timer = ecore_timer_add(1.0, _surebox_timer_cb, sb);
sb->iterations = 15;
sb->orig_size = cfdata->orig_size;
sb->orig_rate = cfdata->orig_rate;
sb->cfd = cfd;
sb->cfdata = cfdata;
cfdata->surebox = sb;
sb->dia->data = sb;
e_dialog_title_set(sb->dia, _("Resolution change"));
_surebox_text_fill(sb);
e_win_delete_callback_set(sb->dia->win, _surebox_dialog_cb_delete);
e_dialog_button_add(sb->dia, _("Yes"), NULL, _surebox_dialog_cb_yes, sb);
e_dialog_button_add(sb->dia, _("No"), NULL, _surebox_dialog_cb_no, sb);
e_dialog_button_focus_num(sb->dia, 1);
e_win_borderless_set(sb->dia->win, 1);
e_win_layer_set(sb->dia->win, 6);
e_win_centered_set(sb->dia->win, 1);
e_win_sticky_set(sb->dia->win, 1);
e_dialog_show(sb->dia);
}
EAPI E_Config_Dialog *
e_int_config_display(E_Container *con)
{
@ -58,6 +180,7 @@ _fill_data(E_Config_Dialog_Data *cfdata)
man = e_manager_current_get();
cfdata->orig_size = ecore_x_randr_current_screen_size_get(man->root);
cfdata->orig_rate = ecore_x_randr_current_screen_refresh_rate_get(man->root);
cfdata->restore = e_config->display_res_restore;
}
static void *
@ -73,6 +196,8 @@ _create_data(E_Config_Dialog *cfd)
static void
_free_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
{
if (cfdata->surebox)
e_object_del(E_OBJECT(cfdata->surebox->dia));
free(cfdata);
}
@ -92,10 +217,14 @@ _basic_apply_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
sscanf(sel_res, "%dx%d", &w, &h);
sscanf(sel_rate, "%d Hz", &r);
e_config->display_res_width = cfdata->orig_size.width;
e_config->display_res_height = cfdata->orig_size.height;
e_config->display_res_hz = cfdata->orig_rate.rate;
if ((cfdata->orig_size.width == w) &&
(cfdata->orig_size.height == h) &&
(cfdata->orig_rate.rate == r))
return 1;
goto saveonly;
man = e_manager_current_get();
sizes = ecore_x_randr_screen_sizes_get(man->root, &n);
@ -119,18 +248,26 @@ _basic_apply_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata)
}
}
int ret;
ret = ecore_x_randr_screen_refresh_rate_set(man->root, size, rate);
e_config->display_res_width = size.width;
e_config->display_res_height = size.height;
e_config->display_res_hz = rate.rate;
ecore_x_randr_screen_refresh_rate_set(man->root, size, rate);
_surebox_new(cfd, cfdata);
cfdata->orig_size = size;
cfdata->orig_rate = rate;
saveonly:
e_config->display_res_restore = cfdata->restore;
e_config_save_queue();
return 1;
}
static Evas_Object *
_basic_create_widgets(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata)
{
Evas_Object *o, *of, *ol, *rl;
Evas_Object *o, *of, *ol, *rl, *ob;
E_Manager *man;
Ecore_X_Screen_Size *sizes;
Ecore_X_Screen_Size size;
@ -186,6 +323,9 @@ _basic_create_widgets(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cf
}
}
ob = e_widget_check_add(evas, _("Restore this resolution on login"), &(cfdata->restore));
e_widget_list_object_append(o, ob, 1, 1, 0.5);
e_widget_ilist_go(ol);
e_widget_ilist_go(rl);
return o;

1
src/modules/Makefile.am
View File

@ -11,5 +11,4 @@ cpufreq \
ibox \
itray \
start \
randr \
gadget_test

7
src/modules/randr/.cvsignore
View File

@ -1,7 +0,0 @@
.deps
.libs
Makefile
Makefile.in
*.lo
module.la
e_mod_main.loT

25
src/modules/randr/Makefile.am
View File

@ -1,25 +0,0 @@
MAINTAINERCLEANFILES = Makefile.in
MODULE = randr
# data files for the module
#filesdir = $(libdir)/enlightenment/modules/$(MODULE)
#files_DATA = \
#module_icon.png
#EXTRA_DIST = $(files_DATA)
# the module .so file
INCLUDES = -I. \
-I$(top_srcdir) \
-I$(top_srcdir)/$(MODULE) \
-I$(top_srcdir)/src/bin \
-I$(top_srcdir)/src/lib \
-I$(top_srcdir)/src/modules \
@e_cflags@
pkgdir = $(libdir)/enlightenment/modules/$(MODULE)/$(MODULE_ARCH)
pkg_LTLIBRARIES = module.la
module_la_SOURCES = e_mod_main.c \
e_mod_main.h
module_la_LIBADD = @e_libs@ @dlopen_libs@
module_la_LDFLAGS = -module -avoid-version
module_la_DEPENDENCIES = $(top_builddir)/config.h

444
src/modules/randr/e_mod_main.c
View File

@ -1,444 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "e.h"
#include "e_mod_main.h"
/*
* TODO:
* * Check if randr is available. It might be disabled in
* ecore_x, or not available on screen
* * Add destroy callback for dialog
*/
static Randr *_randr_new(void);
static void _randr_free(Randr *e);
static void _randr_config_menu_new(Randr *e);
static void _randr_menu_resolution_add(void *data, E_Menu *m);
static void _randr_menu_resolution_del(void *data, E_Menu *m);
static void _randr_menu_cb_store(void *data, E_Menu *m, E_Menu_Item *mi);
static void _randr_menu_cb_resolution_change(void *data, E_Menu *m, E_Menu_Item *mi);
static void _randr_dialog_cb_ok(void *data, E_Dialog *dia);
static void _randr_dialog_cb_cancel(void *data, E_Dialog *dia);
static int _randr_timer_cb(void *data);
static void _randr_save_res(Randr_Resolution *res);
static E_Config_DD *conf_edd;
static E_Config_DD *conf_manager_edd;
EAPI E_Module_Api e_modapi =
{
E_MODULE_API_VERSION,
"RandR"
};
EAPI void *
e_modapi_init(E_Module *m)
{
Randr *e;
/* Create the button */
e = _randr_new();
m->config_menu = e->config_menu;
return e;
}
EAPI int
e_modapi_shutdown(E_Module *m)
{
Randr *e;
if (m->config_menu) m->config_menu = NULL;
e = m->data;
if (e) _randr_free(e);
return 1;
}
EAPI int
e_modapi_save(E_Module *m)
{
Randr *e;
e = m->data;
e_config_domain_save("module.randr", conf_edd, e->conf);
return 1;
}
EAPI int
e_modapi_info(E_Module *m)
{
/*
char buf[4096];
snprintf(buf, sizeof(buf), "%s/module_icon.png", e_module_dir_get(m));
m->icon_file = strdup(buf);
*/
return 1;
}
EAPI int
e_modapi_about(E_Module *m)
{
e_module_dialog_show(_("Enlightenment Randr Module"),
_("Module to change screen resolution for E17"));
return 1;
}
static Randr *
_randr_new(void)
{
Randr *e;
e = E_NEW(Randr, 1);
if (!e) return NULL;
conf_manager_edd = E_CONFIG_DD_NEW("Randr_Config_Manager", Config_Manager);
#undef T
#undef D
#define T Config_Manager
#define D conf_manager_edd
E_CONFIG_VAL(D, T, manager, INT);
E_CONFIG_VAL(D, T, width, INT);
E_CONFIG_VAL(D, T, height, INT);
conf_edd = E_CONFIG_DD_NEW("Randr_Config", Config);
#undef T
#undef D
#define T Config
#define D conf_edd
E_CONFIG_VAL(D, T, store, INT);
E_CONFIG_LIST(D, T, managers, conf_manager_edd);
e->conf = e_config_domain_load("module.randr", conf_edd);
if (!e->conf)
{
e->conf = E_NEW(Config, 1);
e->conf->store = 1;
}
else if ((e->conf->store) && (e->conf->managers))
{
/* Restore resoultion */
Evas_List *l;
Ecore_X_Screen_Size size;
for (l = e->conf->managers; l; l = l->next)
{
E_Manager *man;
Config_Manager *cm;
cm = l->data;
man = e_manager_number_get(cm->manager);
size = ecore_x_randr_current_screen_size_get(man->root);
if ((man) && ((cm->width != size.width) || (cm->height != size.height)))
{
size.width = cm->width;
size.height = cm->height;
ecore_x_randr_screen_size_set(man->root, size);
}
}
}
_randr_config_menu_new(e);
e->augmentation = e_int_menus_menu_augmentation_add("config",
_randr_menu_resolution_add, e,
_randr_menu_resolution_del, e);
return e;
}
static void
_randr_free(Randr *e)
{
Evas_List *l;
E_CONFIG_DD_FREE(conf_edd);
E_CONFIG_DD_FREE(conf_manager_edd);
if (e->timer)
ecore_timer_del(e->timer);
if (e->dialog)
e_object_del(E_OBJECT(e->dialog));
e_object_del(E_OBJECT(e->config_menu));
if (e->resolution_menu)
e_object_del(E_OBJECT(e->resolution_menu));
e_int_menus_menu_augmentation_del("config", e->augmentation);
for (l = e->conf->managers; l; l = l->next)
free(l->data);
evas_list_free(e->conf->managers);
free(e->conf);
free(e);
}
static void
_randr_config_menu_new(Randr *e)
{
E_Menu *m;
E_Menu_Item *mi;
m = e_menu_new();
e->config_menu = m;
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Restore Resolution on Startup"));
e_menu_item_check_set(mi, 1);
e_menu_item_toggle_set(mi, e->conf->store);
e_menu_item_callback_set(mi, _randr_menu_cb_store, e);
}
static void
_randr_menu_resolution_add(void *data, E_Menu *m)
{
E_Manager *man;
Randr *e;
E_Menu *subm, *root;
E_Menu_Item *mi;
Ecore_X_Screen_Size *sizes;
Ecore_X_Screen_Size size;
int i, n;
e = data;
subm = e_menu_new();
e->resolution_menu = subm;
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Resolution"));
e_menu_item_submenu_set(mi, subm);
root = e_menu_root_get(m);
if (!root->zone)
man = e_manager_current_get();
else
man = root->zone->container->manager;
/* Get the size and possible sizes for the manager */
sizes = ecore_x_randr_screen_sizes_get(man->root, &n);
size = ecore_x_randr_current_screen_size_get(man->root);
if (sizes)
{
Randr_Resolution *res;
char buf[16];
for (i = 0; i < n; i++)
{
res = E_NEW(Randr_Resolution, 1);
if (!res) continue;
res->prev = size;
res->next = sizes[i];
e_object_ref(E_OBJECT(man));
res->manager = man;
res->randr = e;
snprintf(buf, sizeof(buf), "%dx%d", sizes[i].width, sizes[i].height);
mi = e_menu_item_new(subm);
e_menu_item_radio_set(mi, 1);
e_menu_item_radio_group_set(mi, 1);
if ((sizes[i].width == size.width) && (sizes[i].height == size.height))
e_menu_item_toggle_set(mi, 1);
e_menu_item_label_set(mi, buf);
e_menu_item_callback_set(mi, _randr_menu_cb_resolution_change, e);
e_object_data_set(E_OBJECT(mi), res);
}
free(sizes);
}
}
static void
_randr_menu_resolution_del(void *data, E_Menu *m)
{
Randr *e;
e = data;
if (e->resolution_menu)
{
Evas_List *l;
for (l = e->resolution_menu->items; l; l = l->next)
{
E_Object *obj;
void *data;
obj = l->data;
data = e_object_data_get(obj);
if (data)
free(data);
}
e_object_del(E_OBJECT(e->resolution_menu));
e->resolution_menu = NULL;
}
}
static void
_randr_menu_cb_store(void *data, E_Menu *m, E_Menu_Item *mi)
{
Randr *e;
e = data;
e->conf->store = e_menu_item_toggle_get(mi);
}
static void
_randr_menu_cb_resolution_change(void *data, E_Menu *m, E_Menu_Item *mi)
{
Randr *e;
Randr_Resolution *res;
char buf[PATH_MAX];
e = data;
res = e_object_data_get(E_OBJECT(mi));
e_object_data_set(E_OBJECT(mi), NULL);
if (!res) return;
ecore_x_randr_screen_size_set(res->manager->root, res->next);
if (e->dialog) e_object_del(E_OBJECT(e->dialog));
if (e->timer) ecore_timer_del(e->timer);
e->timer_iterations = 15;
e->dialog = e_dialog_new(m->zone->container);
e_dialog_title_set(e->dialog, _("Resolution change"));
snprintf(buf, sizeof(buf),
_("Keep new resolution <hilight>%dx%d</hilight>?<br><br>"
"Restoring old resolution %dx%d in %d seconds."),
res->next.width, res->next.height,
res->prev.width, res->prev.height,
e->timer_iterations);
e_dialog_text_set(e->dialog, buf);
e_dialog_button_add(e->dialog, _("Yes"), NULL, _randr_dialog_cb_ok, res);
e_dialog_button_add(e->dialog, _("No"), NULL, _randr_dialog_cb_cancel, res);
e_dialog_button_focus_num(e->dialog, 1);
e_win_borderless_set(e->dialog->win, 1);
e_win_layer_set(e->dialog->win, 6);
e_win_centered_set(e->dialog->win, 1);
e_win_sticky_set(e->dialog->win, 1);
e_dialog_show(e->dialog);
e->timer = ecore_timer_add(1.0, _randr_timer_cb, res);
}
static void
_randr_dialog_cb_ok(void *data, E_Dialog *dia)
{
Randr_Resolution *res;
/* Do nothing */
res = data;
_randr_save_res(res);
e_object_unref(E_OBJECT(res->manager));
e_object_del(E_OBJECT(res->randr->dialog));
res->randr->dialog = NULL;
if (res->randr->timer)
{
ecore_timer_del(res->randr->timer);
res->randr->timer = NULL;
}
free(res);
}
static void
_randr_dialog_cb_cancel(void *data, E_Dialog *dia)
{
Randr_Resolution *res;
/* Restore old resolution */
res = data;
ecore_x_randr_screen_size_set(res->manager->root, res->prev);
e_object_unref(E_OBJECT(res->manager));
e_object_del(E_OBJECT(res->randr->dialog));
res->randr->dialog = NULL;
if (res->randr->timer)
{
ecore_timer_del(res->randr->timer);
res->randr->timer = NULL;
}
free(res);
}
static int
_randr_timer_cb(void *data)
{
Randr_Resolution *res;
res = data;
if (res->randr->timer_iterations > 0)
{
char buf[PATH_MAX];
if (--res->randr->timer_iterations > 0)
{
snprintf(buf, sizeof(buf),
_("Keep new resolution <hilight>%dx%d</hilight>?<br><br>"
"Restoring old resolution %dx%d in %d seconds."),
res->next.width, res->next.height,
res->prev.width, res->prev.height,
res->randr->timer_iterations);
}
else
{
snprintf(buf, sizeof(buf),
_("Keep new resolution <hilight>%dx%d</hilight>?<br><br>"
"Restoring old resolution %dx%d NOW!"),
res->next.width, res->next.height,
res->prev.width, res->prev.height);
}
e_dialog_text_set(res->randr->dialog, buf);
return 1;
}
else
{
/* Restore old resolution */
ecore_x_randr_screen_size_set(res->manager->root, res->prev);
e_object_unref(E_OBJECT(res->manager));
e_object_del(E_OBJECT(res->randr->dialog));
res->randr->dialog = NULL;
res->randr->timer = NULL;
free(res);
return 0;
}
}
static void
_randr_save_res(Randr_Resolution *res)
{
Config_Manager *cm = NULL;
Evas_List *l;
/* Find this manager config */
for (l = res->randr->conf->managers; l; l = l->next)
{
Config_Manager *current;
current = l->data;
if (current->manager == res->manager->num)
{
cm = current;
break;
}
}
/* If not found, create new config */
if (!cm)
{
cm = E_NEW(Config_Manager, 1);
if (cm)
res->randr->conf->managers = evas_list_append(res->randr->conf->managers, cm);
}
/* Save config */
if (cm)
{
cm->manager = res->manager->num;
cm->width = res->next.width;
cm->height = res->next.height;
}
e_config_save_queue();
}

55
src/modules/randr/e_mod_main.h
View File

@ -1,55 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#ifndef E_MOD_MAIN_H
#define E_MOD_MAIN_H
typedef struct _Config Config;
typedef struct _Config_Manager Config_Manager;
typedef struct _Randr Randr;
typedef struct _Randr_Resolution Randr_Resolution;
struct _Config
{
int store;
Evas_List *managers;
};
struct _Config_Manager
{
int manager;
int width;
int height;
};
struct _Randr
{
E_Menu *config_menu;
E_Menu *resolution_menu;
E_Int_Menu_Augmentation *augmentation;
Ecore_Timer *timer;
int timer_iterations;
E_Dialog *dialog;
Config *conf;
};
struct _Randr_Resolution
{
E_Manager *manager;
Randr *randr;
Ecore_X_Screen_Size prev, next;
};
EAPI extern E_Module_Api e_modapi;
EAPI void *e_modapi_init (E_Module *m);
EAPI int e_modapi_shutdown (E_Module *m);
EAPI int e_modapi_save (E_Module *m);
EAPI int e_modapi_info (E_Module *m);
EAPI int e_modapi_about (E_Module *m);
/* EAPI int e_modapi_config (E_Module *module); */
#endif