enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 24 Pull Requests 2 Projects Releases Wiki Activity

revert parts of patch that committed randr to e... don't want that 

right now until rest of patch is in.



SVN revision: 64629
This commit is contained in:
Carsten Haitzler 2011-11-02 01:36:10 +00:00
parent 0b4f2529f9
commit 52e23870a3
4 changed files with 343 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

309
src/bin/e_config.c
View File

@ -6,9 +6,23 @@
#define DEF_MENUCLICK 0.25
#endif
#define RANDR_SERIALIZED_SETUP_11 ((int)((1 << 16) | 1))
#define RANDR_SERIALIZED_SETUP_12 ((int)((1 << 16) | 2))
#define RANDR_SERIALIZED_SETUP_13 ((int)((1 << 16) | 3))
typedef enum _Eet_Union
{
EET_SCREEN_INFO_11 = (int)((1 << 16) | 1),
EET_SCREEN_INFO_12 = (int)((1 << 16) | 2),
EET_SCREEN_INFO_13 = (int)((1 << 16) | 3),
EET_UNKNOWN
} Eet_Union;
struct {
Eet_Union u;
const char *name;
} eet_mapping[] = {
{ EET_SCREEN_INFO_11, "E_Config_Screen_11" },
{ EET_SCREEN_INFO_12, "E_Config_Screen_12" },
{ EET_SCREEN_INFO_12, "E_Config_Screen_13" },
{ EET_UNKNOWN, NULL }
};
EAPI E_Config *e_config = NULL;
@ -20,6 +34,8 @@ static void _e_config_free(E_Config *cfg);
static Eina_Bool _e_config_cb_timer(void *data);
static int _e_config_eet_close_handle(Eet_File *ef, char *file);
static void _e_config_acpi_bindings_add(void);
static const char * _eet_union_type_get(const void *data, Eina_Bool *unknow);
static Eina_Bool _eet_union_type_set(const char *type, void *data, Eina_Bool unknow);
/* local subsystem globals */
static int _e_config_save_block = 0;
@ -49,16 +65,15 @@ static E_Config_DD *_e_config_shelf_desk_edd = NULL;
static E_Config_DD *_e_config_mime_icon_edd = NULL;
static E_Config_DD *_e_config_syscon_action_edd = NULL;
static E_Config_DD *_e_config_env_var_edd = NULL;
static E_Config_DD *_e_config_randr_size_edd = NULL;
static E_Config_DD *_e_config_randr_size_mm_edd = NULL;
static E_Config_DD *_e_config_randr_edid_hash_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_setup_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_setup_11_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_setup_12_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_output_policy_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_output_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_mode_info_edd = NULL;
static E_Config_DD *_e_config_randr_serialized_crtc_edd = NULL;
static E_Config_DD *_e_config_screen_size_edd = NULL;
static E_Config_DD *_e_config_screen_size_mm_edd = NULL;
static E_Config_DD *_e_config_eina_rectangle_edd = NULL;
static E_Config_DD *_e_config_screen_info_edd = NULL;
static E_Config_DD *_e_config_screen_restore_info_11_edd = NULL;
static E_Config_DD *_e_config_screen_restore_info_12_edd = NULL;
static E_Config_DD *_e_config_screen_output_edid_hash_edd = NULL;
static E_Config_DD *_e_config_screen_output_restore_info_edd = NULL;
static E_Config_DD *_e_config_screen_crtc_restore_info_edd = NULL;
EAPI int E_EVENT_CONFIG_ICON_THEME = 0;
@ -511,109 +526,107 @@ e_config_init(void)
E_CONFIG_VAL(D, T, val, STR);
E_CONFIG_VAL(D, T, unset, UCHAR);
_e_config_randr_size_edd = E_CONFIG_DD_NEW("Ecore_X_Randr_Screen_Size", Ecore_X_Randr_Screen_Size);
_e_config_screen_size_edd = E_CONFIG_DD_NEW("Ecore_X_Randr_Screen_Size", Ecore_X_Randr_Screen_Size);
#undef T
#undef D
#define T Ecore_X_Randr_Screen_Size
#define D _e_config_randr_size_edd
#define D _e_config_screen_size_edd
E_CONFIG_VAL(D, T, width, INT);
E_CONFIG_VAL(D, T, height, INT);
E_CONFIG_VAL(D, T, width, INT);
E_CONFIG_VAL(D, T, height, INT);
_e_config_randr_size_mm_edd = E_CONFIG_DD_NEW("Ecore_X_Randr_Screen_Size_MM", Ecore_X_Randr_Screen_Size_MM);
_e_config_screen_size_mm_edd = E_CONFIG_DD_NEW("Ecore_X_Randr_Screen_Size_MM", Ecore_X_Randr_Screen_Size_MM);
#undef T
#undef D
#define T Ecore_X_Randr_Screen_Size_MM
#define D _e_config_randr_size_mm_edd
#define D _e_config_screen_size_mm_edd
E_CONFIG_VAL(D, T, width, INT);
E_CONFIG_VAL(D, T, height, INT);
E_CONFIG_VAL(D, T, width_mm, INT);
E_CONFIG_VAL(D, T, height_mm, INT);
_e_config_randr_edid_hash_edd = E_CONFIG_DD_NEW("E_Randr_Edid_Hash", E_Randr_Edid_Hash);
_e_config_screen_restore_info_11_edd = E_CONFIG_DD_NEW("E_Randr_Screen_Restore_Info_11", E_Randr_Screen_Restore_Info_11);
#undef T
#undef D
#define T E_Randr_Edid_Hash
#define D _e_config_randr_edid_hash_edd
E_CONFIG_VAL(D, T, hash, INT);
_e_config_randr_serialized_setup_11_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Setup_11", E_Randr_Serialized_Setup_11);
#undef T
#undef D
#define T E_Randr_Serialized_Setup_11
#define D _e_config_randr_serialized_setup_11_edd
E_CONFIG_SUB(D, T, size, _e_config_randr_size_edd);
#define T E_Randr_Screen_Restore_Info_11
#define D _e_config_screen_restore_info_11_edd
E_CONFIG_SUB(D, T, size, _e_config_screen_size_edd);
E_CONFIG_VAL(D, T, orientation, INT);
E_CONFIG_VAL(D, T, refresh_rate, SHORT);
_e_config_randr_serialized_output_policy_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Output_Policy", E_Randr_Serialized_Output_Policy);
_e_config_eina_rectangle_edd = E_CONFIG_DD_NEW("Eina_Rectangle", Eina_Rectangle);
#undef T
#undef D
#define T E_Randr_Serialized_Output_Policy
#define D _e_config_randr_serialized_output_policy_edd
E_CONFIG_VAL(D, T, name, STR);
E_CONFIG_VAL(D, T, name_length, INT);
E_CONFIG_VAL(D, T, policy, INT);
#define T Eina_Rectangle
#define D _e_config_eina_rectangle_edd
E_CONFIG_VAL(D, T, x, INT);
E_CONFIG_VAL(D, T, y, INT);
E_CONFIG_VAL(D, T, w, INT);
E_CONFIG_VAL(D, T, h, INT);
_e_config_randr_serialized_output_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Output", E_Randr_Serialized_Output);
_e_config_screen_output_edid_hash_edd = E_CONFIG_DD_NEW("E_Randr_Output_Edid_Hash", E_Randr_Output_Edid_Hash);
#undef T
#undef D
#define T E_Randr_Serialized_Output
#define D _e_config_randr_serialized_output_edd
E_CONFIG_VAL(D, T, name, STR);
E_CONFIG_VAL(D, T, name_length, INT);
E_CONFIG_SUB(D, T, edid_hash, _e_config_randr_edid_hash_edd);
#define T E_Randr_Output_Edid_Hash
#define D _e_config_screen_output_edid_hash_edd
E_CONFIG_VAL(D, T, hash, INT);
// FIXME: need to totally re-do this randr config stuff - remove the
// union stuff. do this differently to not use unions really. not
// intended for how it is used here really.
_e_config_screen_output_restore_info_edd = E_CONFIG_DD_NEW("E_Randr_Output_Restore_Info", E_Randr_Output_Restore_Info);
#undef T
#undef D
#define T E_Randr_Output_Restore_Info
#define D _e_config_screen_output_restore_info_edd
E_CONFIG_SUB(D, T, edid_hash, _e_config_screen_output_edid_hash_edd);
E_CONFIG_VAL(D, T, backlight_level, DOUBLE);
_e_config_randr_serialized_mode_info_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Mode_Info", Ecore_X_Randr_Mode_Info);
_e_config_screen_crtc_restore_info_edd = E_CONFIG_DD_NEW("E_Randr_Crtc_Restore_Info", E_Randr_Crtc_Restore_Info);
#undef T
#undef D
#define T Ecore_X_Randr_Mode_Info
#define D _e_config_randr_serialized_mode_info_edd
E_CONFIG_VAL(D, T, width, INT);
E_CONFIG_VAL(D, T, height, INT);
E_CONFIG_VAL(D, T, dotClock, LL);
E_CONFIG_VAL(D, T, hSyncStart, INT);
E_CONFIG_VAL(D, T, hSyncEnd, INT);
E_CONFIG_VAL(D, T, hTotal, INT);
E_CONFIG_VAL(D, T, hSkew, INT);
E_CONFIG_VAL(D, T, vSyncStart, INT);
E_CONFIG_VAL(D, T, vSyncEnd, INT);
E_CONFIG_VAL(D, T, vTotal, INT);
E_CONFIG_VAL(D, T, name, STR);
E_CONFIG_VAL(D, T, nameLength, INT);
E_CONFIG_VAL(D, T, modeFlags, LL);
_e_config_randr_serialized_crtc_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Crtc", E_Randr_Serialized_Crtc);
#undef T
#undef D
#define T E_Randr_Serialized_Crtc
#define D _e_config_randr_serialized_crtc_edd
E_CONFIG_LIST(D, T, serialized_outputs, _e_config_randr_serialized_output_edd);
E_CONFIG_SUB(D, T, mode_info, _e_config_randr_serialized_mode_info_edd);
E_CONFIG_VAL(D, T, pos.x, INT);
E_CONFIG_VAL(D, T, pos.y, INT);
EET_DATA_DESCRIPTOR_ADD_LIST_STRING(D, T, "Crtc_Possible_Outputs_Names", possible_outputs_names);
#define T E_Randr_Crtc_Restore_Info
#define D _e_config_screen_crtc_restore_info_edd
E_CONFIG_SUB(D, T, geometry, _e_config_eina_rectangle_edd);
E_CONFIG_LIST(D, T, outputs, _e_config_screen_output_restore_info_edd);
E_CONFIG_VAL(D, T, orientation, INT);
_e_config_randr_serialized_setup_12_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Setup_12", E_Randr_Serialized_Setup_12);
_e_config_screen_restore_info_12_edd = E_CONFIG_DD_NEW("E_Randr_Screen_Restore_Info_12", E_Randr_Screen_Restore_Info_12);
#undef T
#undef D
#define T E_Randr_Serialized_Setup_12
#define D _e_config_randr_serialized_setup_12_edd
E_CONFIG_VAL(D, T, timestamp, DOUBLE);
E_CONFIG_LIST(D, T, serialized_crtcs, _e_config_randr_serialized_crtc_edd);
E_CONFIG_LIST(D, T, serialized_edid_hashes, _e_config_randr_edid_hash_edd);
#define T E_Randr_Screen_Restore_Info_12
#define D _e_config_screen_restore_info_12_edd
E_CONFIG_LIST(D, T, crtcs, _e_config_screen_crtc_restore_info_edd);
E_CONFIG_LIST(D, T, outputs_edid_hashes, _e_config_screen_output_edid_hash_edd);
E_CONFIG_VAL(D, T, noutputs, INT);
E_CONFIG_VAL(D, T, output_policy, INT);
E_CONFIG_VAL(D, T, alignment, INT);
_e_config_randr_serialized_setup_edd = E_CONFIG_DD_NEW("E_Randr_Serialized_Setup", E_Randr_Serialized_Setup);
#undef T
#undef D
#define T E_Randr_Serialized_Setup
#define D _e_config_randr_serialized_setup_edd
E_CONFIG_SUB(D, T, serialized_setup_11, _e_config_randr_serialized_setup_11_edd);
E_CONFIG_LIST(D, T, serialized_setups_12, _e_config_randr_serialized_setup_12_edd);
E_CONFIG_LIST(D, T, serialized_outputs_policies, _e_config_randr_serialized_output_policy_edd);
#define T E_Randr_Screen_Restore_Info
#define D _e_config_screen_info_edd
Eet_Data_Descriptor_Class eddc;
Eet_Data_Descriptor *unified, *edd_11_info, *edd_12_info;
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, T);
D = eet_data_descriptor_stream_new(&eddc);
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
eddc.func.type_get = _eet_union_type_get;
eddc.func.type_set = _eet_union_type_set;
//virtual types to work around EET's inability to differentiate when it
//comes to pointers (a->b) vs. values (a.b) in union mappings
edd_11_info = E_CONFIG_DD_NEW("E_Randr_Screen_Restore_Info_11_Struct", E_Randr_Screen_Restore_Info_11);
E_CONFIG_SUB(edd_11_info, E_Randr_Screen_Restore_Info_Union, restore_info_11, _e_config_screen_restore_info_11_edd);
edd_12_info = E_CONFIG_DD_NEW("E_Randr_Screen_Restore_Info_12_Struct", E_Randr_Screen_Restore_Info_12);
E_CONFIG_LIST(edd_12_info, E_Randr_Screen_Restore_Info_Union, restore_info_12, _e_config_screen_restore_info_12_edd);
unified = eet_data_descriptor_stream_new(&eddc);
EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "E_Config_Screen_11", edd_11_info);
EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "E_Config_Screen_12", edd_12_info);
EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "E_Config_Screen_13", edd_12_info);
// DISABLE! crashie crashie long time
// EET_DATA_DESCRIPTOR_ADD_UNION(D, T, "E_Randr_Screen_Restore_Info_Union", rrvd_restore_info, randr_version, unified);
E_CONFIG_VAL(D, T, randr_version, INT);
_e_config_edd = E_CONFIG_DD_NEW("E_Config", E_Config);
#undef T
@ -774,8 +787,7 @@ e_config_init(void)
E_CONFIG_VAL(D, T, desklock_ask_presentation, UCHAR);
E_CONFIG_VAL(D, T, desklock_ask_presentation_timeout, DOUBLE);
//randr specifics
E_CONFIG_SUB(D, T, randr_serialized_setup, _e_config_randr_serialized_setup_edd);
E_CONFIG_LIST(D, T, screen_info, _e_config_screen_info_edd);
E_CONFIG_VAL(D, T, screensaver_enable, INT);
E_CONFIG_VAL(D, T, screensaver_timeout, INT);
@ -947,7 +959,7 @@ e_config_shutdown(void)
E_CONFIG_DD_FREE(_e_config_mime_icon_edd);
E_CONFIG_DD_FREE(_e_config_syscon_action_edd);
E_CONFIG_DD_FREE(_e_config_env_var_edd);
E_CONFIG_DD_FREE(_e_config_randr_serialized_setup_edd);
E_CONFIG_DD_FREE(_e_config_screen_info_edd);
return 1;
}
@ -1903,13 +1915,10 @@ _e_config_free(E_Config *ecf)
E_Color_Class *cc;
E_Path_Dir *epd;
E_Remember *rem;
E_Randr_Serialized_Setup *serialized_setup;
E_Randr_Serialized_Setup_12 *serialized_setup_12;
E_Randr_Serialized_Crtc *serialized_crtc;
E_Randr_Serialized_Output_Policy *serialized_output_policy;
E_Randr_Serialized_Output *serialized_output;
E_Randr_Edid_Hash *edid_hash;
char *output_name;
E_Randr_Screen_Restore_Info *screen_info;
E_Randr_Crtc_Restore_Info *crtc_info;
E_Randr_Output_Info *output_info;
E_Randr_Screen_Restore_Info_12 *restore_info_12;
E_Config_Env_Var *evr;
@ -2060,50 +2069,37 @@ _e_config_free(E_Config *ecf)
if (sca->icon) eina_stringshare_del(sca->icon);
E_FREE(sca);
}
if(ecf->randr_serialized_setup)
if (ecf->screen_info)
{
if(ecf->randr_serialized_setup->serialized_setup_11)
free(serialized_setup->serialized_setup_11);
else if(ecf->randr_serialized_setup->serialized_setups_12)
{
EINA_LIST_FREE(ecf->randr_serialized_setup->serialized_setups_12, serialized_setup_12)
{
EINA_LIST_FREE(serialized_setup_12->serialized_crtcs, serialized_crtc)
{
if (!serialized_crtc) continue;
EINA_LIST_FREE(serialized_crtc->serialized_outputs, serialized_output)
{
if (serialized_output)
{
if (serialized_output->name) free(serialized_output);
free(serialized_output);
}
}
EINA_LIST_FREE(serialized_crtc->possible_outputs_names, output_name)
{
if (output_name) free(output_name);
}
if (serialized_crtc->mode_info.name)
free(serialized_crtc->mode_info.name);
free(serialized_crtc);
}
EINA_LIST_FREE(serialized_setup_12->serialized_edid_hashes, edid_hash)
{
if (edid_hash) free(edid_hash);
}
free(serialized_setup_12);
}
}
EINA_LIST_FREE(ecf->randr_serialized_setup->serialized_outputs_policies, serialized_output_policy)
{
if (!serialized_output) continue;
if (serialized_output_policy->name)
free(serialized_output_policy->name);
free(serialized_output_policy);
}
free(ecf->randr_serialized_setup);
EINA_LIST_FREE(ecf->screen_info, screen_info)
{
switch (screen_info->randr_version)
{
case EET_SCREEN_INFO_11:
free(screen_info->rrvd_restore_info.restore_info_11);
break;
case EET_SCREEN_INFO_12:
case EET_SCREEN_INFO_13:
EINA_LIST_FREE(screen_info->rrvd_restore_info.restore_info_12, restore_info_12)
{
EINA_LIST_FREE(restore_info_12->crtcs, crtc_info)
{
EINA_LIST_FREE(crtc_info->outputs, output_info)
{
free(output_info->name);
free(output_info->edid);
free (output_info);
}
free (crtc_info);
}
free(restore_info_12);
}
eina_list_free(screen_info->rrvd_restore_info.restore_info_12);
break;
}
free(screen_info);
}
}
EINA_LIST_FREE(ecf->env_vars, evr)
{
if (evr->var) eina_stringshare_del(evr->var);
@ -2120,14 +2116,14 @@ _e_config_free(E_Config *ecf)
E_FREE(ecf);
}
static Eina_Bool
static Eina_Bool
_e_config_cb_timer(void *data)
{
e_util_dialog_show(_("Settings Upgraded"), "%s", (char *)data);
return 0;
}
static int
static int
_e_config_eet_close_handle(Eet_File *ef, char *file)
{
Eet_Error err;
@ -2137,16 +2133,16 @@ _e_config_eet_close_handle(Eet_File *ef, char *file)
switch (err)
{
case EET_ERROR_NONE:
/* all good - no error */
break;
/* all good - no error */
break;
case EET_ERROR_BAD_OBJECT:
erstr = _("The EET file handle is bad.");
break;
erstr = _("The EET file handle is bad.");
break;
case EET_ERROR_EMPTY:
erstr = _("The file data is empty.");
break;
erstr = _("The file data is empty.");
break;
case EET_ERROR_NOT_WRITABLE:
erstr = _("The file is not writable. Perhaps the disk is read-only<br>or you lost permissions to your files.");
erstr = _("The file is not writable. Perhaps the disk is read-only<br>or you lost permissions to your files.");
break;
case EET_ERROR_OUT_OF_MEMORY:
erstr = _("Memory ran out while preparing the write.<br>Please free up memory.");
@ -2284,3 +2280,36 @@ _e_config_acpi_bindings_add(void)
bind->params = eina_stringshare_add("now");
e_config->acpi_bindings = eina_list_append(e_config->acpi_bindings, bind);
}
static const char *
_eet_union_type_get(const void *data, Eina_Bool *unknow)
{
const Eet_Union *u = data;
int i;
if (unknow) *unknow = EINA_FALSE;
for (i = 0; eet_mapping[i].name; ++i)
if (*u == eet_mapping[i].u)
return eet_mapping[i].name;
if (unknow) *unknow = EINA_TRUE;
return NULL;
}
static Eina_Bool
_eet_union_type_set(const char *type, void *data, Eina_Bool unknow)
{
Eet_Union *u = data;
int i;
if (unknow) return EINA_FALSE;
for (i = 0; eet_mapping[i].name; ++i)
if (strcmp(eet_mapping[i].name, type) == 0)
{
*u = eet_mapping[i].u;
return EINA_TRUE;
}
return EINA_FALSE;
}

4
src/bin/e_config.h
View File

@ -33,7 +33,7 @@ typedef struct _E_Event_Config_Icon_Theme E_Event_Config_Icon_Theme;
/* increment this whenever a new set of config values are added but the users
* config doesn't need to be wiped - simply new values need to be put in
*/
#define E_CONFIG_FILE_GENERATION 0x0146
#define E_CONFIG_FILE_GENERATION 0x0145
#define E_CONFIG_FILE_VERSION ((E_CONFIG_FILE_EPOCH << 16) | E_CONFIG_FILE_GENERATION)
#define E_EVAS_ENGINE_DEFAULT 0
@ -250,7 +250,7 @@ struct _E_Config
int mouse_accel_denominator; // GUI
int mouse_accel_threshold; // GUI
E_Randr_Serialized_Setup *randr_serialized_setup; // GUI
Eina_List *screen_info; // GUI
int border_raise_on_mouse_action; // GUI
int border_raise_on_focus; // GUI

739
src/bin/e_randr.c
View File

@ -11,13 +11,6 @@
#define Ecore_X_Randr_Unset -1
/*
* Save mechanism:
* Single monitor:
* - Save monitor using the resolution
*
* Multiple monitors:
* - Use the EDID information to make sure we restore the right monitor.
*
* TODO:
* -fix output policies above and left
*/
@ -64,11 +57,6 @@ static E_Randr_Crtc_Info *_e_randr_crtc_info_new(int nrequested);
static void _e_randr_crtc_info_free(E_Randr_Crtc_Info *crtc_info);
static Eina_Bool _e_randr_screen_outputs_init(void);
static Eina_Bool _e_randr_screen_crtcs_init(void);
static Eina_Bool _e_randr_try_restore_11(E_Randr_Screen_Info_11 *si_11);
static Eina_Bool _e_randr_try_restore_12(E_Randr_Screen_Info_12 *si_12);
EAPI void e_randr_store_configuration(E_Randr_Screen_Info *screen_info);
EAPI Eina_Bool e_randr_try_restore_configuration(E_Randr_Screen_Info *screen_info);
static Eina_Bool _e_randr_output_modes_add(E_Randr_Output_Info *output_info);
static void _e_randr_notify_crtc_mode_change(E_Randr_Crtc_Info *crtc_info);
static void _e_randr_notify_output_change(E_Randr_Output_Info *output_info);
@ -78,8 +66,12 @@ static E_Randr_Output_Info *_e_randr_output_info_get(Ecore_X_Randr_Output output
static void _e_randr_output_info_set(E_Randr_Output_Info *output_info);
static void _e_randr_crtc_info_set(E_Randr_Crtc_Info *crtc_info);
static const E_Randr_Crtc_Info *_e_randr_policy_crtc_get(E_Randr_Crtc_Info* but, E_Randr_Crtc_Info *hint, Ecore_X_Randr_Output_Policy policy);
//static Eina_Bool _e_randr_outputs_connected(Eina_List *outputs_info);
static Ecore_X_Randr_Output *_e_randr_outputs_to_array(Eina_List *outputs_info);
static E_Randr_Serialized_Setup_12 * _e_randr_config_find_suiting_config_12(void);
//static int _e_randr_config_find_suiting_config_11(E_Randr_Screen_Restore_Info_11** restore_info);
static E_Randr_Screen_Restore_Info_12 * _e_randr_config_find_suiting_config_12(void);
//static Eina_Bool _e_randr_config_enable_11(int size_index, Ecore_X_Randr_Refresh_Rate refresh_rate, Ecore_X_Randr_Orientation orientation);
//static Eina_Bool _e_randr_config_enable_12(const E_Randr_Screen_Restore_Info_12 *restore_info);
static Eina_Bool _e_randr_try_enable_output(E_Randr_Output_Info *output_info, Eina_Bool force);
static void _e_randr_crtcs_possible_output_update(E_Randr_Output_Info *output_info);
static void _e_randr_crtc_outputs_refs_update(E_Randr_Crtc_Info *crtc_info);
@ -98,7 +90,7 @@ static void _e_randr_output_info_hw_info_set(E_Randr_Output_Info *output_info);
static void _e_randr_output_hw_info_free(E_Randr_Output_Info *output_info);
static Eina_Bool _e_randr_outputs_are_clones(E_Randr_Output_Info *output_info, Eina_List *outputs);
EAPI E_Randr_Screen_Info *e_randr_screen_info = NULL;
E_Randr_Screen_Info *e_randr_screen_info = NULL;
static Eina_List *_e_randr_event_handlers = NULL;
EINTERN Eina_Bool
@ -278,6 +270,7 @@ _e_randr_screen_info_12_new(void)
.crtcs = NULL,
.outputs = NULL,
.primary_output = NULL,
.output_policy = ECORE_X_RANDR_OUTPUT_POLICY_NONE,
.alignment = ECORE_X_RANDR_RELATIVE_ALIGNMENT_NONE
};
@ -466,8 +459,7 @@ _e_randr_output_info_new(int nrequested)
.connector_type = Ecore_X_Randr_Unset,
.connection_status = ECORE_X_RANDR_CONNECTION_STATUS_DISCONNECTED,
.subpixel_order= Ecore_X_Randr_Unset,
.compatible_outputs = NULL,
.policy = ECORE_X_RANDR_OUTPUT_POLICY_NONE
.compatible_outputs = NULL
};
if (!(ret = malloc(sizeof(E_Randr_Output_Info) * nrequested))) return NULL;
@ -768,7 +760,7 @@ _e_randr_event_cb(void *data __UNUSED__, int type, void *ev)
else if (type == ECORE_X_EVENT_RANDR_OUTPUT_CHANGE)
{
Ecore_X_Event_Randr_Output_Change *event = ev;
const E_Randr_Serialized_Setup_12 *restore_info;
const E_Randr_Screen_Restore_Info_12 *restore_info;
E_Randr_Output_Info* output_info = NULL;
/* available information:
struct _Ecore_X_Event_Randr_Output_Change
@ -815,13 +807,11 @@ _e_randr_event_cb(void *data __UNUSED__, int type, void *ev)
_e_randr_output_info_hw_info_set(output_info);
//make the crtcs aware of their possibly new output
_e_randr_crtcs_possible_output_update(output_info);
/*
if ((restore_info = _e_randr_config_find_suiting_config_12()))
//maybe we have a suiting configuration
//_e_randr_config_enable_12(restore_info);
;
else
*/
enabled = _e_randr_try_enable_output(output_info, EINA_FALSE); //maybe give a success message?
}
_e_randr_notify_output_change(output_info);
@ -851,13 +841,11 @@ _e_randr_event_cb(void *data __UNUSED__, int type, void *ev)
_e_randr_screen_primary_output_assign(output_info);
//let's try to get a proper config for the new setup and crop the
//screen afterwards.
/*
if ((restore_info = _e_randr_config_find_suiting_config_12()))
{
//in case we didn't have, init it anyway...
//_e_randr_config_enable_12(restore_info);
}
*/
}
_e_randr_notify_output_change(output_info);
_e_randr_output_hw_info_free(output_info);
@ -877,7 +865,6 @@ _e_randr_event_cb(void *data __UNUSED__, int type, void *ev)
};
*/
}
e_randr_try_restore_configuration(e_randr_screen_info);
on_exit:
return ECORE_CALLBACK_RENEW;
}
@ -1012,602 +999,146 @@ _e_randr_policy_crtc_get(E_Randr_Crtc_Info *but, E_Randr_Crtc_Info *hint __UNUSE
return ret;
}
// Setup store functions
Eina_Bool
_e_randr_copy_mode_info(Ecore_X_Randr_Mode_Info *dest, Ecore_X_Randr_Mode_Info *src)
/*
static Eina_Bool
_e_randr_outputs_connected(Eina_List *outputs_info)
{
Eina_List *iter;
E_Randr_Output_Info *output_info;
if (!dest || !src) return EINA_FALSE;
EINA_LIST_FOREACH(outputs_info, iter, output_info)
if (output_info->connection_status == ECORE_X_RANDR_CONNECTION_STATUS_CONNECTED) return EINA_TRUE;
return EINA_FALSE;
}
dest->width = src->width;
dest->height = src->height;
dest->dotClock = src->dotClock;
dest->hSyncStart = src->hSyncStart;
dest->hSyncEnd = src->hSyncEnd;
dest->hTotal = src->hTotal;
dest->hSkew = src->hSkew;
dest->vSyncStart = src->vSyncStart;
dest->vSyncEnd = src->vSyncEnd;
dest->vTotal = src->vTotal;
if (src->nameLength > 0)
{
if (!(dest->name = malloc(src->nameLength + 1))) return EINA_FALSE;
if (!strncpy(dest->name, src->name, src->nameLength)) goto _e_randr_copy_mode_info_fail_free_name;
}
dest->nameLength = src->nameLength;
dest->modeFlags = src->modeFlags;
static Eina_Bool
_e_randr_config_enable_11(int size_index, Ecore_X_Randr_Refresh_Rate refresh_rate, Ecore_X_Randr_Orientation orientation)
{
E_Randr_Screen_Info_11 *current_info_11;
if (E_RANDR_NO_11 || (size_index < 0) || (refresh_rate < 0) ||
(orientation < 0)) return EINA_FALSE;
if (!ecore_x_randr_screen_primary_output_size_set(e_randr_screen_info->root, size_index)
|| !ecore_x_randr_screen_primary_output_orientation_set(e_randr_screen_info->root, orientation)
|| !ecore_x_randr_screen_primary_output_refresh_rate_set(e_randr_screen_info->root, size_index, refresh_rate)) return EINA_FALSE;
//TODO: move this to the screen event later.
current_info_11 = e_randr_screen_info->rrvd_info.randr_info_11;
current_info_11->csize_index = size_index;
current_info_11->corientation = orientation;
current_info_11->current_rate = refresh_rate;
return EINA_TRUE;
}
_e_randr_copy_mode_info_fail_free_name:
free(dest->name);
static Eina_Bool
_e_randr_config_enable_12(const E_Randr_Screen_Restore_Info_12 *restore_info __UNUSED__)
{
if (E_RANDR_NO_12 || !restore_info) return EINA_FALSE;
E_Randr_Screen_Info_12 *current_info_12;
E_Randr_Screen_Restore_Info_12 *restore_info_12 = NULL;
E_Randr_Crtc_Restore_Info *crtc_restore_info = NULL;
E_Randr_Crtc_Info *crtc_info;
E_Randr_Output_Info *output_info;
Eina_List *crtc_restore_iter;
current_info_12 = (e_randr_screen_info->rrvd_info).randr_info_12;
EINA_LIST_FOREACH(restore_info_12->crtcs, crtc_restore_iter, crtc_restore_info)
{
;
}
current_info_12->alignment = restore_info_12->alignment;
current_info_12->output_policy = restore_info_12->output_policy;
return EINA_TRUE;
return EINA_FALSE;
}
void
_e_randr_free_serialized_mode_info(Ecore_X_Randr_Mode_Info *mode_info)
static int
_e_randr_config_find_suiting_config_11(E_Randr_Screen_Restore_Info_11 **restore_info)
{
if (mode_info->name) free(mode_info->name);
}
E_RANDR_NO_11_RET(Ecore_X_Randr_None);
Eina_List *cfg_screen_restore_info_iter;
E_Randr_Screen_Restore_Info *screen_restore_info;
Eina_List
*_e_randr_create_outputs_policies_list(Eina_List *outputs)
{
Eina_List *iter, *list = NULL;
E_Randr_Output_Info *oi;
E_Randr_Serialized_Output_Policy *sop;
char *name;
E_Randr_Screen_Restore_Info_11 *restore_info_11;
Ecore_X_Randr_Screen_Size_MM *sizes;
Ecore_X_Randr_Refresh_Rate *rates = NULL;
int i = 0, j = 0, nsizes = 0, nrates = 0;
EINA_LIST_FOREACH(outputs, iter, oi)
EINA_LIST_FOREACH(e_config->screen_info, cfg_screen_restore_info_iter, screen_restore_info)
{
if (!oi->name || (oi->name_length <= 0)) continue;
if (!(sop = E_NEW(E_Randr_Serialized_Output_Policy, 1))
|| !(sop->name = malloc(oi->name_length + 1))
|| !(strncpy(sop->name, oi->name, oi->name_length)))
goto _e_randr_create_outputs_policies_list_fail_free_list;
sop->name_length = oi->name_length;
sop->policy = oi->policy;
if (!(list = eina_list_append(list, sop)))
goto _e_randr_create_outputs_policies_list_fail_free_list;
}
return list;
_e_randr_create_outputs_policies_list_fail_free_list:
EINA_LIST_FREE(list, sop)
{
if (sop->name) free(sop->name);
free(sop);
}
return NULL;
}
void
_e_randr_free_serialized_output_policy(E_Randr_Serialized_Output_Policy *sop)
{
if (!sop) return;
if (sop->name) free(sop->name);
free(sop);
}
Eina_List
*_e_randr_update_serialized_outputs_policies(E_Randr_Screen_Info_12 *si_12, Eina_List *sops)
{
E_Randr_Serialized_Output_Policy *sop;
EINA_LIST_FREE(sops, sop)
{
_e_randr_free_serialized_output_policy(sop);
}
return _e_randr_create_outputs_policies_list(si_12->outputs);
}
Eina_List
*_e_randr_create_possible_outputs_names_list(Eina_List *outputs)
{
Eina_List *iter, *list = NULL;
E_Randr_Output_Info *oi;
char *name;
if (!outputs) return NULL;
EINA_LIST_FOREACH(outputs, iter, oi)
{
if (!oi->name || (oi->name_length <= 0)) continue;
if (!(name = malloc(oi->name_length))
|| !strncpy(name, oi->name, oi->name_length)
|| !(list = eina_list_append(list, name))) goto _e_randr_create_possible_outputs_names_list_fail_free_list;
}
return list;
_e_randr_create_possible_outputs_names_list_fail_free_list:
EINA_LIST_FREE(list, name)
{
if(name) free(name);
}
return NULL;
}
E_Randr_Edid_Hash
*_e_randr_create_edid_hash(E_Randr_Output_Info *output_info)
{
E_Randr_Edid_Hash *edid_hash;
if (!output_info || (output_info->edid_hash.hash == 0) || !(edid_hash = malloc(sizeof(E_Randr_Edid_Hash)))) return NULL;
edid_hash->hash = output_info->edid_hash.hash;
return edid_hash;
}
E_Randr_Serialized_Output
*_e_randr_create_serialized_output(E_Randr_Output_Info *output_info)
{
E_Randr_Serialized_Output *so;
char *name;
if (!output_info || !output_info->name || (output_info->name_length <= 0) || !(so = malloc(sizeof(E_Randr_Serialized_Output)))) return NULL;
if (!(name = malloc(output_info->name_length))
|| !strncpy(so->name, output_info->name, output_info->name_length))
goto _e_randr_create_serialized_outputs_fail_free_so;
so->name_length = output_info->name_length;
so->edid_hash.hash = output_info->edid_hash.hash;
so->backlight_level = output_info->backlight_level;
return so;
_e_randr_create_serialized_outputs_fail_free_so:
free(so);
return NULL;
}
void
_e_randr_free_serialized_output(E_Randr_Serialized_Output *so)
{
if (so->name) free(so->name);
free(so);
}
E_Randr_Serialized_Crtc
*_e_randr_create_serialized_crtc(E_Randr_Crtc_Info *crtc_info)
{
E_Randr_Serialized_Crtc *sc;
E_Randr_Serialized_Output *so;
E_Randr_Output_Info *output_info;
Eina_List *iter;
char *output_name;
size_t len;
if (!(sc = E_NEW(E_Randr_Serialized_Crtc, 1))) return NULL;
if(!_e_randr_copy_mode_info(&sc->mode_info, crtc_info->current_mode)) goto _e_randr_create_serialized_crtc_free_sc;
if(!(sc->possible_outputs_names = _e_randr_create_possible_outputs_names_list(crtc_info->possible_outputs))) goto _e_randr_create_serialized_crtc_free_mode_sc;
//Create list of serialized outputs
EINA_LIST_FOREACH(crtc_info->outputs, iter, output_info)
{
if(!(so = _e_randr_create_serialized_output(output_info))
|| !(sc->serialized_outputs = eina_list_append(sc->serialized_outputs, so))) goto _e_randr_create_serialized_crtc_free_outputs_list_sc;
}
sc->pos.x = crtc_info->geometry.x;
sc->pos.y = crtc_info->geometry.y;
sc->orientation = crtc_info->current_orientation;
return sc;
_e_randr_create_serialized_crtc_free_outputs_list_sc:
EINA_LIST_FREE(sc->possible_outputs_names, output_name)
{
if (output_name) free(output_name);
}
EINA_LIST_FREE(sc->serialized_outputs, so)
{
if (so) _e_randr_free_serialized_output(so);
}
_e_randr_create_serialized_crtc_free_mode_sc:
_e_randr_free_serialized_mode_info(&sc->mode_info);
_e_randr_create_serialized_crtc_free_sc:
E_FREE(sc);
return NULL;
}
void
_e_randr_free_serialized_crtc(E_Randr_Serialized_Crtc *sc)
{
E_Randr_Serialized_Output *so;
char *name;
EINA_LIST_FREE(sc->serialized_outputs, so)
_e_randr_free_serialized_output(so);
_e_randr_free_serialized_mode_info(&sc->mode_info);
EINA_LIST_FREE(sc->possible_outputs_names, name)
free(name);
free(sc);
}
E_Randr_Serialized_Setup_11
*_e_randr_create_serialized_setup_11(E_Randr_Screen_Info_11 *screen_info_11)
{
E_Randr_Serialized_Setup_11 *ss;
Ecore_X_Randr_Screen_Size_MM* size;
if (!(ss = malloc(sizeof(*ss)))) return NULL;
if(!(size = (Ecore_X_Randr_Screen_Size_MM*)eina_list_data_get(eina_list_nth(screen_info_11->sizes, screen_info_11->csize_index)))) goto _e_randr_create_serialized_setup_11_failed_free_ss;
ss->size.width = size->width;
ss->size.height = size->height;
ss->refresh_rate = screen_info_11->current_rate;
ss->orientation = screen_info_11->corientation;
return ss;
_e_randr_create_serialized_setup_11_failed_free_ss:
free(ss);
}
E_Randr_Serialized_Setup_11
*_e_randr_update_serialized_setup_11(E_Randr_Serialized_Setup_11 *ss_11, E_Randr_Screen_Info_11 *si_11)
{
Ecore_X_Randr_Screen_Size_MM* size;
if (ss_11)
{
if(!(size = (Ecore_X_Randr_Screen_Size_MM*)eina_list_data_get(eina_list_nth(si_11->sizes, si_11->csize_index)))) return NULL;
if (!memcpy(&ss_11->size, size, sizeof(Ecore_X_Randr_Screen_Size_MM)))
goto _e_randr_update_serialized_setup_11_failed_free_ss;
ss_11->refresh_rate = si_11->current_rate;
ss_11->orientation = si_11->corientation;
}
else
ss_11 = _e_randr_create_serialized_setup_11(si_11);
return ss_11;
_e_randr_update_serialized_setup_11_failed_free_ss:
free(ss_11);
return NULL;
}
E_Randr_Serialized_Setup_12
*_e_randr_create_serialized_setup_12(E_Randr_Screen_Info_12 *screen_info_12)
{
E_Randr_Serialized_Setup_12 *ss;
Eina_List *iter;
E_Randr_Crtc_Info *ci;
E_Randr_Output_Info *oi;
E_Randr_Serialized_Crtc *sc;
E_Randr_Edid_Hash *edid_hash;
if (!(ss = E_NEW(E_Randr_Serialized_Setup_12, 1))) return NULL;
ss->timestamp = ecore_time_get();
//Add CRTCs and their configuration
EINA_LIST_FOREACH(screen_info_12->crtcs, iter, ci)
{
//ignore disabled crtcs for now
if (!ci->current_mode) continue;
if (!(sc = _e_randr_create_serialized_crtc(ci))
|| !(ss->serialized_crtcs = eina_list_append(ss->serialized_crtcs, sc)))
goto _e_randr_create_serialized_setup_12_failed_free_list_ss;
}
/*
* Add EDID hashes of connected and enabled
* outputs for easier comparison during
* setup restoration
*/
EINA_LIST_FOREACH(screen_info_12->outputs, iter, oi)
{
if ((oi->connection_status != ECORE_X_RANDR_CONNECTION_STATUS_CONNECTED) || !oi->crtc || !oi->crtc->current_mode)
continue;
if (!(edid_hash = _e_randr_create_edid_hash(oi)) || !(ss->serialized_edid_hashes = eina_list_append(ss->serialized_edid_hashes, edid_hash)))
goto _e_randr_create_serialized_setup_12_failed_free_output_list_crtc_list_ss;
}
return ss;
_e_randr_create_serialized_setup_12_failed_free_output_list_crtc_list_ss:
EINA_LIST_FREE(ss->serialized_edid_hashes, edid_hash)
{
if (edid_hash) free(edid_hash);
}
_e_randr_create_serialized_setup_12_failed_free_list_ss:
EINA_LIST_FREE(ss->serialized_crtcs, sc)
{
_e_randr_free_serialized_crtc(sc);
}
_e_randr_create_serialized_setup_12_failed_free_ss:
free(ss);
}
E_Randr_Serialized_Setup_12
*_e_randr_find_matching_serialized_setup(Eina_List *setups_12, E_Randr_Screen_Info_12 *si_12)
{
E_Randr_Serialized_Setup_12 *ss_12;
Eina_List *setups_iter, *r_iter, *s_iter;
Eina_Bool found = EINA_FALSE;
E_Randr_Edid_Hash *edid_hash;
E_Randr_Output_Info *oi;
if (!setups_12 || !si_12) return NULL;
EINA_LIST_FOREACH(setups_12, setups_iter, ss_12)
{
EINA_LIST_FOREACH(si_12->outputs, r_iter, oi)
// 'screen_restore_info' should _never_ be NULL, since this functions shouldn't be called due to randr init failing.
if (!screen_restore_info) continue;
if (screen_restore_info->randr_version != ECORE_X_RANDR_1_1) continue;
restore_info_11 = screen_restore_info->rrvd_restore_info.restore_info_11;
if((sizes = ecore_x_randr_screen_primary_output_sizes_get(e_randr_screen_info->root, &nsizes)))
{
//skip disconnected/-abled monitors
if ((oi->connection_status != ECORE_X_RANDR_CONNECTION_STATUS_CONNECTED) || !oi->crtc || !oi->crtc->current_mode)
continue;
found = EINA_FALSE;
EINA_LIST_FOREACH(ss_12->serialized_edid_hashes, s_iter, edid_hash)
for (i = 0; i < nsizes; i++)
{
if (oi->edid_hash.hash == edid_hash->hash)
if ((restore_info_11->size.width == sizes[i].width)
&& (restore_info_11->size.height == sizes[i].height))
{
found = EINA_TRUE;
break;
if ((rates = ecore_x_randr_screen_primary_output_refresh_rates_get(e_randr_screen_info->root, i, &nrates)))
{
for (j = 0; j < nrates; j++)
if (rates[j] == restore_info_11->refresh_rate)
{
if (restore_info) *restore_info = restore_info_11;
free(rates);
free(sizes);
return i;
}
free(rates);
}
}
}
if (!found)
break;
if (sizes) free(sizes);
}
if (found)
break;
}
if (found)
return ss_12;
return Ecore_X_Randr_Unset;
}
*/
/**
* @Brief find configuration with the most hardware currently available
*/
static E_Randr_Screen_Restore_Info_12 *
_e_randr_config_find_suiting_config_12(void)
{
//TODO: write geometry based loading
/*
Eina_List *cfg_screen_restore_info_iter;
E_Randr_Screen_Restore_Info *screen_restore_info;
E_Randr_Screen_Info_12 *current_info_12;
E_Randr_Screen_Restore_Info_12 *restore_info_12, *most_matches = NULL;
E_Randr_Output_Info *output_info;
E_Randr_Crtc_Restore_Info *crtc_restore_info;
Ecore_X_Randr_Output *outputs_xids;
Ecore_X_Randr_Crtc *crtcs_xids;
Eina_List *restore_info_12_iter, *output_iter, *restore_crtcs_iter;
if (e_randr_screen_info && e_config && e_config->screen_info)
{
EINA_LIST_FOREACH(e_config->screen_info, cfg_screen_restore_info_iter, screen_restore_info)
{
if (screen_restore_info->randr_version < ECORE_X_RANDR_1_2) continue;
//HINT: use eina_list_clone and a sort callback to find proper
//crtcs and outputs
//current_info_12 = e_randr_screen_info->rrvd_info.randr_info_12;
}
}
*/
return NULL;
}
void
_e_randr_free_serialized_setup_12(E_Randr_Serialized_Setup_12 *ss_12)
{
E_Randr_Serialized_Crtc *sc;
E_Randr_Edid_Hash *edid_hash;
if (!ss_12) return;
EINA_LIST_FREE(ss_12->serialized_crtcs, sc)
{
if (!sc) continue;
_e_randr_free_serialized_crtc(sc);
}
EINA_LIST_FREE(ss_12->serialized_edid_hashes, edid_hash)
if (edid_hash) free(edid_hash);
free(ss_12);
}
Eina_List
*_e_randr_update_serialized_setup_12(Eina_List *setups_12, E_Randr_Screen_Info_12 *si_12)
{
E_Randr_Serialized_Setup_12 *ss_12;
E_Randr_Serialized_Output *so;
E_Randr_Output_Info *oi;
E_Randr_Edid_Hash *edid_hash;
if (setups_12)
{
/*
* try to find the setup with the same monitors
* connected in order to replace it
*/
if((ss_12 = _e_randr_find_matching_serialized_setup(setups_12, si_12)))
_e_randr_free_serialized_setup_12(ss_12);
}
ss_12 = _e_randr_create_serialized_setup_12(si_12);
setups_12 = eina_list_append(setups_12, ss_12);
return setups_12;
}
E_Randr_Serialized_Setup
*_e_randr_create_serialized_setup(E_Randr_Screen_Info *screen_info)
{
E_Randr_Serialized_Setup *ss;
E_Randr_Serialized_Setup_12 *ss_12;
if (!(ss = E_NEW(E_Randr_Serialized_Setup, 1))) return NULL;
if ((screen_info->randr_version == ECORE_X_RANDR_1_1) && !(ss->serialized_setup_11 = _e_randr_create_serialized_setup_11(screen_info->rrvd_info.randr_info_11))) goto _e_randr_create_serialized_setup_failed_free_ss;
if ((screen_info->randr_version >= ECORE_X_RANDR_1_2))
{
if (!(ss_12 = _e_randr_create_serialized_setup_12(screen_info->rrvd_info.randr_info_12))
|| !(ss->serialized_setups_12 = eina_list_append(ss->serialized_setups_12, ss_12)))
goto _e_randr_create_serialized_setup_failed_free_ss;
}
return ss;
_e_randr_create_serialized_setup_failed_free_ss:
free(ss);
}
EAPI void
e_randr_store_configuration(E_Randr_Screen_Info *screen_info)
{
if (E_RANDR_NO_11) return;
if (!e_config->randr_serialized_setup)
{
e_config->randr_serialized_setup = _e_randr_create_serialized_setup(screen_info);
e_config_save_queue();
return;
}
if (screen_info->randr_version == ECORE_X_RANDR_1_1)
{
e_config->randr_serialized_setup->serialized_setup_11 = _e_randr_update_serialized_setup_11(e_config->randr_serialized_setup->serialized_setup_11, screen_info->rrvd_info.randr_info_11);
}
else if (screen_info->randr_version >= ECORE_X_RANDR_1_2)
{
e_config->randr_serialized_setup->serialized_setups_12 = _e_randr_update_serialized_setup_12(e_config->randr_serialized_setup->serialized_setups_12, screen_info->rrvd_info.randr_info_12);
//Also, update output policies
e_config->randr_serialized_setup->serialized_outputs_policies = _e_randr_update_serialized_outputs_policies(screen_info->rrvd_info.randr_info_12, e_config->randr_serialized_setup->serialized_outputs_policies);
}
e_config_save_queue();
}
//setup restore functions
EAPI Eina_Bool
e_randr_try_restore_configuration(E_Randr_Screen_Info *si)
{
if (!e_config || !e_config->randr_serialized_setup) return EINA_FALSE;
if (si->randr_version == ECORE_X_RANDR_1_1)
return _e_randr_try_restore_11(si->rrvd_info.randr_info_11);
else if (si->randr_version >= ECORE_X_RANDR_1_2)
return _e_randr_try_restore_12(si->rrvd_info.randr_info_12);
return EINA_FALSE;
}
Eina_Bool
_e_randr_try_restore_11(E_Randr_Screen_Info_11 *si_11)
{
E_Manager *man;
Eina_List *iter;
Ecore_X_Randr_Screen_Size_MM *stored_size, *size;
int i = 0;
if (!e_config->randr_serialized_setup->serialized_setup_11) return EINA_FALSE;
stored_size = &e_config->randr_serialized_setup->serialized_setup_11->size;
EINA_LIST_FOREACH(si_11->sizes, iter, size)
{
if ((stored_size->width == size->width)
&& (stored_size->height == size->height)
&& (stored_size->width_mm == size->width_mm)
&& (stored_size->height_mm == size->height_mm))
{
man = e_manager_current_get();
return ecore_x_randr_screen_primary_output_size_set(man->root, i);
}
i++;
}
return EINA_FALSE;
}
E_Randr_Crtc_Info
*_e_randr_find_matching_crtc(Eina_List *crtcs, E_Randr_Serialized_Crtc *sc)
{
Eina_List *iter, *s_name_iter, *p_output_iter;
E_Randr_Crtc_Info *ci;
E_Randr_Output_Info *oi;
char *s_output_name;
Eina_Bool name_found;
EINA_LIST_FOREACH(crtcs, iter, ci)
{
if (eina_list_count(ci->possible_outputs) != eina_list_count(sc->possible_outputs_names))
continue;
EINA_LIST_FOREACH(sc->possible_outputs_names, s_name_iter, s_output_name)
{
name_found = EINA_FALSE;
EINA_LIST_FOREACH(ci->possible_outputs, p_output_iter, oi)
{
if (!strncmp(s_output_name, oi->name, oi->name_length))
{
name_found = EINA_TRUE;
break;
}
}
if (!name_found)
break;
}
if (name_found)
break;
}
if (name_found)
return ci;
else
return NULL;
}
Eina_List
*_e_randr_find_matching_outputs(Eina_List *sois, Eina_List *ois)
{
Eina_List *r_output_iter, *s_output_iter, *list = NULL;
E_Randr_Output_Info *oi;
E_Randr_Serialized_Output *so;
EINA_LIST_FOREACH(sois, s_output_iter, so)
{
EINA_LIST_FOREACH(ois, r_output_iter, oi)
{
if (so->edid_hash.hash == oi->edid_hash.hash)
{
list = eina_list_append(list, oi);
break;
}
}
}
if (list && (eina_list_count(sois) != eina_list_count(list)))
{
eina_list_free(list);
list = NULL;
}
return list;
}
Ecore_X_Randr_Mode_Info
*_e_randr_find_matching_mode_info(Eina_List *modes, Ecore_X_Randr_Mode_Info *mode)
{
Eina_List *iter;
Ecore_X_Randr_Mode_Info *mi = NULL;
EINA_LIST_FOREACH(modes, iter, mi)
{
if ((mode->width == mi->width)
&& (mode->height == mi->height)
&& (mode->dotClock == mi->dotClock)
&& (mode->hSyncStart == mi->hSyncStart)
&& (mode->hSyncEnd == mi->hSyncEnd)
&& (mode->hTotal == mi->hTotal)
&& (mode->hSkew == mi->hSkew)
&& (mode->vSyncStart == mi->vSyncStart)
&& (mode->vSyncEnd == mi->vSyncEnd)
&& (mode->vTotal == mi->vTotal)
&& (mode->nameLength == mi->nameLength)
&& !strncpy(mode->name, mi->name, mode->nameLength)
&& (mode->modeFlags == mi->modeFlags))
return mi;
}
return NULL;
}
Eina_Bool
_e_randr_try_restore_12(E_Randr_Screen_Info_12 *si_12)
{
E_Randr_Serialized_Setup_12 *ss_12;
E_Randr_Serialized_Crtc *sc;
E_Randr_Crtc_Info *ci;
Ecore_X_Randr_Output *outputs_array;
Ecore_X_Randr_Mode_Info *mi;
Eina_List *iter, *outputs_list;
Eina_Bool ret = EINA_TRUE;
E_Manager *man;
if(!(ss_12 = _e_randr_find_matching_serialized_setup(e_config->randr_serialized_setup->serialized_setups_12, si_12))) return EINA_FALSE;
man = e_manager_current_get();
EINA_LIST_FOREACH(ss_12->serialized_crtcs, iter, sc)
{
ci = _e_randr_find_matching_crtc(si_12->crtcs, sc);
outputs_list = _e_randr_find_matching_outputs(si_12->outputs, sc->serialized_outputs);
outputs_array = _e_randr_outputs_to_array(outputs_list);
mi = _e_randr_find_matching_mode_info(si_12->modes, &sc->mode_info);
ret &= ecore_x_randr_crtc_mode_set(man->root, ci->xid, outputs_array, eina_list_count(outputs_list), mi->xid);
ret &= ecore_x_randr_crtc_pos_set(man->root, ci->xid, sc->pos.x, sc->pos.y);
}
return ret;
}
//Utility functions
static Ecore_X_Randr_Output *
static Ecore_X_Randr_Output *
_e_randr_outputs_to_array(Eina_List *outputs_info)
{
Ecore_X_Randr_Output *ret = NULL;
@ -1617,7 +1148,7 @@ _e_randr_outputs_to_array(Eina_List *outputs_info)
if (!outputs_info || !(ret = malloc(sizeof(Ecore_X_Randr_Output) * eina_list_count(outputs_info)))) return NULL;
EINA_LIST_FOREACH(outputs_info, output_iter, output_info)
/* output_info == NULL should _not_ be possible! */
/* output_info == NULL should _not_ be possible! */
ret[i++] = output_info ? output_info->xid : Ecore_X_Randr_None;
return ret;
}
@ -1660,7 +1191,7 @@ _e_randr_try_enable_output(E_Randr_Output_Info *output_info, Eina_Bool force)
if (!usable_crtc) return EINA_FALSE;
//get the CRTC we will refer to, dependend on policy
switch (output_info->policy)
switch (e_randr_screen_info->rrvd_info.randr_info_12->output_policy)
{
case ECORE_X_RANDR_OUTPUT_POLICY_NONE:
return EINA_TRUE;
@ -1855,19 +1386,15 @@ static Eina_Bool
_e_randr_crtc_move_policy(E_Randr_Crtc_Info *new_crtc)
{
const E_Randr_Crtc_Info *crtc_rel;
E_Randr_Output_Info *last_output = NULL;
int dx = Ecore_X_Randr_None, dy = Ecore_X_Randr_None;
Eina_Bool ret = EINA_TRUE;
//use the policy of the new crtc's last output
last_output = (E_Randr_Output_Info*)eina_list_data_get(eina_list_last(new_crtc->outputs));
if (!last_output) return EINA_FALSE;
//get the crtc we will place our's relative to. If it's NULL, this is the
//only output attached, work done.
if(!(crtc_rel = _e_randr_policy_crtc_get(new_crtc, NULL, last_output->policy))) return EINA_TRUE;
if(!(crtc_rel = _e_randr_policy_crtc_get(new_crtc, NULL, e_randr_screen_info->rrvd_info.randr_info_12->output_policy))) return EINA_TRUE;
//following is policy dependend.
switch (last_output->policy)
switch (e_randr_screen_info->rrvd_info.randr_info_12->output_policy)
{
case ECORE_X_RANDR_OUTPUT_POLICY_ABOVE:
dy = (crtc_rel->geometry.y - new_crtc->geometry.h);
@ -1898,7 +1425,7 @@ _e_randr_crtc_move_policy(E_Randr_Crtc_Info *new_crtc)
default:
break;
}
ret &= ecore_x_randr_crtc_pos_relative_set(e_randr_screen_info->root, new_crtc->xid, crtc_rel->xid, last_output->policy, e_randr_screen_info->rrvd_info.randr_info_12->alignment);
ret &= ecore_x_randr_crtc_pos_relative_set(e_randr_screen_info->root, new_crtc->xid, crtc_rel->xid, e_randr_screen_info->rrvd_info.randr_info_12->output_policy, e_randr_screen_info->rrvd_info.randr_info_12->alignment);
return ret;
}
@ -2159,8 +1686,6 @@ _e_randr_output_info_hw_info_set(E_Randr_Output_Info *output_info)
_e_randr_output_modes_add(output_info);
output_info->edid = ecore_x_randr_output_edid_get(e_randr_screen_info->root, output_info->xid, &output_info->edid_length);
if (output_info->edid_length > 0)
output_info->edid_hash.hash = eina_hash_superfast(output_info->edid, output_info->edid_length);
//get the outputs we can use on the same CRTC alongside this one.
if ((outputs = ecore_x_randr_output_clones_get(e_randr_screen_info->root, output_info->xid, &num)))
{
@ -2186,10 +1711,6 @@ _e_randr_output_info_hw_info_set(E_Randr_Output_Info *output_info)
}
free(crtcs);
}
else
{
fprintf(stderr, "E_RANDR: Output %x does not have a single possible CRTC.\n", output_info->xid);
}
}
/*

103
src/bin/e_randr.h
View File

@ -1,26 +1,24 @@
#ifdef E_TYPEDEFS
typedef struct _E_Randr_Crtc_Info E_Randr_Crtc_Info;
typedef struct _E_Randr_Edid_Hash E_Randr_Edid_Hash;
typedef struct _E_Randr_Output_Info E_Randr_Output_Info;
typedef struct _E_Randr_Screen_Info_11 E_Randr_Screen_Info_11;
typedef struct _E_Randr_Screen_Info_12 E_Randr_Screen_Info_12;
typedef union _E_Randr_Screen_RRVD_Info E_Randr_Screen_RRVD_Info;
typedef struct _E_Randr_Screen_Info E_Randr_Screen_Info;
typedef struct _E_Randr_Serialized_Output_Policy E_Randr_Serialized_Output_Policy;
typedef struct _E_Randr_Serialized_Output E_Randr_Serialized_Output;
typedef struct _E_Randr_Serialized_Crtc E_Randr_Serialized_Crtc;
typedef struct _E_Randr_Serialized_Setup_11 E_Randr_Serialized_Setup_11;
typedef struct _E_Randr_Serialized_Setup_12 E_Randr_Serialized_Setup_12;
typedef struct _E_Randr_Serialized_Setup E_Randr_Serialized_Setup;
EAPI void e_randr_store_configuration(E_Randr_Screen_Info *screen_info);
typedef struct _E_Randr_Output_Edid_Hash E_Randr_Output_Edid_Hash;
typedef struct _E_Randr_Output_Restore_Info E_Randr_Output_Restore_Info;
typedef struct _E_Randr_Crtc_Restore_Info E_Randr_Crtc_Restore_Info;
typedef struct _E_Randr_Screen_Restore_Info_11 E_Randr_Screen_Restore_Info_11;
typedef struct _E_Randr_Screen_Restore_Info_12 E_Randr_Screen_Restore_Info_12;
typedef union _E_Randr_Screen_Restore_Info_Union E_Randr_Screen_Restore_Info_Union;
typedef struct _E_Randr_Screen_Restore_Info E_Randr_Screen_Restore_Info;
#else
#ifndef E_RANDR_H
#define E_RANDR_H
struct _E_Randr_Crtc_Info
struct _E_Randr_Crtc_Info
{
Ecore_X_ID xid;
Eina_Rectangle geometry;
@ -37,12 +35,7 @@ struct _E_Randr_Crtc_Info
Ecore_X_Randr_Mode_Info *current_mode;
};
struct _E_Randr_Edid_Hash
{
int hash;
};
struct _E_Randr_Output_Info
struct _E_Randr_Output_Info
{
Ecore_X_ID xid;
char *name;
@ -54,7 +47,6 @@ struct _E_Randr_Output_Info
int connector_number;
Ecore_X_Randr_Connector_Type connector_type;
Ecore_X_Randr_Connection_Status connection_status;
Ecore_X_Randr_Output_Policy policy;
/*
* Attached Monitor specific:
*/
@ -65,7 +57,6 @@ struct _E_Randr_Output_Info
Ecore_X_Randr_Screen_Size size_mm;
unsigned char *edid;
unsigned long edid_length;
E_Randr_Edid_Hash edid_hash;
int max_backlight;
double backlight_level;
Ecore_X_Render_Subpixel_Order subpixel_order;
@ -84,7 +75,7 @@ struct _E_Randr_Screen_Info_11
Ecore_X_Randr_Refresh_Rate current_rate;
};
struct _E_Randr_Screen_Info_12
struct _E_Randr_Screen_Info_12
{
Ecore_X_Randr_Screen_Size min_size;
Ecore_X_Randr_Screen_Size max_size;
@ -93,17 +84,18 @@ struct _E_Randr_Screen_Info_12
Eina_List *crtcs;
Eina_List *outputs;
E_Randr_Output_Info *primary_output;
Ecore_X_Randr_Output_Policy output_policy;
Ecore_X_Randr_Relative_Alignment alignment;
};
//RRVD == RandR(R) Version Depended
union _E_Randr_Screen_RRVD_Info
union _E_Randr_Screen_RRVD_Info
{
E_Randr_Screen_Info_11 *randr_info_11;
E_Randr_Screen_Info_12 *randr_info_12;
};
struct _E_Randr_Screen_Info
struct _E_Randr_Screen_Info
{
Ecore_X_Window root;
int randr_version;
@ -111,67 +103,56 @@ struct _E_Randr_Screen_Info
};
//Following stuff is just for configuration purposes
struct _E_Randr_Serialized_Output_Policy
{
char *name;
int name_length;
Ecore_X_Randr_Output_Policy policy;
struct _E_Randr_Output_Edid_Hash {
int hash;
};
struct _E_Randr_Serialized_Output
struct _E_Randr_Output_Restore_Info
{
char *name;
int name_length;
E_Randr_Edid_Hash edid_hash;
E_Randr_Output_Edid_Hash edid_hash;
double backlight_level;
};
struct _E_Randr_Serialized_Crtc
struct _E_Randr_Crtc_Restore_Info
{
//List of E_Randr_Serialized_Output objects that were used on the same output
Eina_List *serialized_outputs;
//the serialized mode_info misses its xid value
Ecore_X_Randr_Mode_Info mode_info;
Evas_Coord_Point pos;
//List of all possible outputs' names
//e.g. "LVDS", "CRT-0", "VGA"
Eina_List *possible_outputs_names;
Eina_Rectangle geometry;
Ecore_X_Randr_Orientation orientation;
//list of the outputs;
Eina_List *outputs;
};
struct _E_Randr_Serialized_Setup_12
struct _E_Randr_Screen_Restore_Info_11
{
double timestamp;
//List of E_Randr_Serialized_Crtc objects
Eina_List *serialized_crtcs;
/*
* List of E_Randr_Edid_Hash elements of monitors,
* that were enabled, when the setup was stored
*/
Eina_List *serialized_edid_hashes;
};
struct _E_Randr_Serialized_Setup_11
{
Ecore_X_Randr_Screen_Size_MM size;
Ecore_X_Randr_Screen_Size size;
Ecore_X_Randr_Refresh_Rate refresh_rate;
Ecore_X_Randr_Orientation orientation;
};
struct _E_Randr_Serialized_Setup
struct _E_Randr_Screen_Restore_Info_12
{
E_Randr_Serialized_Setup_11 *serialized_setup_11;
//List of E_Randr_Serialized_Setup_12 objects
Eina_List *serialized_setups_12;
//List of E_Randr_Serialized_Output_Policy objects
Eina_List *serialized_outputs_policies;
Eina_List *outputs_edid_hashes;
int noutputs;
Eina_List *crtcs;
Ecore_X_Randr_Output_Policy output_policy;
Ecore_X_Randr_Relative_Alignment alignment;
};
union _E_Randr_Screen_Restore_Info_Union
{
E_Randr_Screen_Restore_Info_11 *restore_info_11;
Eina_List *restore_info_12;
};
struct _E_Randr_Screen_Restore_Info
{
int randr_version;
E_Randr_Screen_Restore_Info_Union rrvd_restore_info;
};
EINTERN Eina_Bool e_randr_init(void);
EINTERN int e_randr_shutdown(void);
EAPI extern E_Randr_Screen_Info *e_randr_screen_info;
extern E_Randr_Screen_Info *e_randr_screen_info;
#endif
#endif