e_comp_screen: rename the variable name

change the var name from e_comp_screen to comp_screen

Change-Id: Ie2aa7aee0c54789e14e97bde690ccbdd9305c70c

diff --git a/src/bin/compmgr/e_comp.c b/src/bin/compmgr/e_comp.c
index 53d9b3fb4d88f1f77b60049ca09580ef425db15d..ec1db40ccdc84ebfb5ef7291deb2c9f2343e5312 100644 (file)
--- a/src/bin/compmgr/e_comp.c
+++ b/src/bin/compmgr/e_comp.c
@@ -727,11 +727,11 @@ e_comp_gl_get(void)
 }
 
 EINTERN void
-e_comp_screen_set(E_Comp_Screen *screen)
+e_comp_screen_set(E_Comp_Screen *comp_screen)
 {
    EINA_SAFETY_ON_NULL_RETURN(e_comp);
 
-   e_comp->e_comp_screen = screen;
+   e_comp->comp_screen = comp_screen;
 }
 
 EINTERN void
@@ -992,7 +992,7 @@ e_comp_screen_get(void)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp, NULL);
 
-   return e_comp->e_comp_screen;
+   return e_comp->comp_screen;
 }
 
 E_API int

diff --git a/src/bin/compmgr/e_comp_canvas.c b/src/bin/compmgr/e_comp_canvas.c
index f4eeaba916dd5898a694de9d6387e2c6096f21c0..0791e1a1eb8548dfda7f5a5399fbab532df4031f 100644 (file)
--- a/src/bin/compmgr/e_comp_canvas.c
+++ b/src/bin/compmgr/e_comp_canvas.c
@@ -57,31 +57,31 @@ _e_comp_canvas_prerender(Ecore_Evas *ee EINA_UNUSED)
 static void
 _e_comp_canvas_tbm_surface_queue_free(void *data, void *tqueue)
 {
-   E_Comp_Screen *e_comp_screen = (E_Comp_Screen *)data;
+   E_Comp_Screen *comp_screen = (E_Comp_Screen *)data;
 
    ELOGF("Comp_Canvas", "The tbm_surface(%p) is destroyed.", NULL,
-         e_comp_screen->tqueue);
+         comp_screen->tqueue);
 
-   e_display_tbm_buffer_queue_destroy(e_comp_screen->tqueue);
+   e_display_tbm_buffer_queue_destroy(comp_screen->tqueue);
 }
 
 static void *
 _e_comp_canvas_tbm_surface_queue_alloc(void *data, int w, int h)
 {
-   E_Comp_Screen *e_comp_screen = (E_Comp_Screen *)data;
+   E_Comp_Screen *comp_screen = (E_Comp_Screen *)data;
 
-   e_comp_screen->tqueue =
-         e_display_tbm_buffer_queue_create(e_comp_screen->w, e_comp_screen->h);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen->tqueue, NULL);
+   comp_screen->tqueue =
+         e_display_tbm_buffer_queue_create(comp_screen->w, comp_screen->h);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen->tqueue, NULL);
 
    ELOGF("Comp_Canvas", "Assign tqueue(%p) to Ecore_Evas.", NULL,
-         e_comp_screen->tqueue);
+         comp_screen->tqueue);
 
-   return (void *)e_comp_screen->tqueue;
+   return (void *)comp_screen->tqueue;
 }
 
 static Ecore_Evas *
-_e_comp_canvas_ecore_evas_tbm_alloc(E_Comp_Screen *e_comp_screen, int src_w, int src_h)
+_e_comp_canvas_ecore_evas_tbm_alloc(E_Comp_Screen *comp_screen, int src_w, int src_h)
 {
    Ecore_Evas *ee;
    E_Comp *comp;
@@ -92,14 +92,14 @@ _e_comp_canvas_ecore_evas_tbm_alloc(E_Comp_Screen *e_comp_screen, int src_w, int
         ee = ecore_evas_tbm_allocfunc_new("gl_tbm_ES", src_w, src_h,
                                           _e_comp_canvas_tbm_surface_queue_alloc,
                                           _e_comp_canvas_tbm_surface_queue_free,
-                                          (void *)e_comp_screen);
+                                          (void *)comp_screen);
      }
    else
      {
         ee = ecore_evas_tbm_allocfunc_new("gl_tbm", src_w, src_h,
                                           _e_comp_canvas_tbm_surface_queue_alloc,
                                           _e_comp_canvas_tbm_surface_queue_free,
-                                          (void *)e_comp_screen);
+                                          (void *)comp_screen);
      }
 
    ELOGF("Comp Screen", "ecore_evas engine:gl_tbm ee:%p avoid_afill:%d", NULL,
@@ -111,31 +111,31 @@ _e_comp_canvas_ecore_evas_tbm_alloc(E_Comp_Screen *e_comp_screen, int src_w, int
 static void
 _e_comp_canvas_gbm_surface_free(void *data, void *gsurface)
 {
-   E_Comp_Screen *e_comp_screen = (E_Comp_Screen *)data;
+   E_Comp_Screen *comp_screen = (E_Comp_Screen *)data;
 
    ELOGF("Comp_Canvas", "The gbm_surface(%p) is destroyed.", NULL,
-         e_comp_screen->gsurface);
+         comp_screen->gsurface);
 
-   e_display_gbm_surface_destroy(e_comp_screen->gsurface);
+   e_display_gbm_surface_destroy(comp_screen->gsurface);
 }
 
 static void *
 _e_comp_canvas_gbm_surface_alloc(void *data, int w, int h)
 {
-   E_Comp_Screen *e_comp_screen = (E_Comp_Screen *)data;
+   E_Comp_Screen *comp_screen = (E_Comp_Screen *)data;
 
-   e_comp_screen->gsurface =
-         e_display_gbm_surface_create(w, h, e_comp_screen->gbm_format);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen->gsurface, NULL);
+   comp_screen->gsurface =
+         e_display_gbm_surface_create(w, h, comp_screen->gbm_format);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen->gsurface, NULL);
 
    ELOGF("Comp_Canvas", "Assign gbm_surface(%p) to Ecore_Evas.", NULL,
-         e_comp_screen->gsurface);
+         comp_screen->gsurface);
 
-   return (void *)e_comp_screen->gsurface;
+   return (void *)comp_screen->gsurface;
 }
 
 static Ecore_Evas *
-_e_comp_canvas_ecore_evas_gbm_alloc(E_Comp_Screen *e_comp_screen, int src_w, int src_h)
+_e_comp_canvas_ecore_evas_gbm_alloc(E_Comp_Screen *comp_screen, int src_w, int src_h)
 {
    Ecore_Evas *ee;
    E_Comp *comp;
@@ -150,21 +150,21 @@ _e_comp_canvas_ecore_evas_gbm_alloc(E_Comp_Screen *e_comp_screen, int src_w, int
    comp = e_comp_get();
    for (i = 0; i < format_count; i++)
      {
-        e_comp_screen->gbm_format = gbm_formats[i];
+        comp_screen->gbm_format = gbm_formats[i];
 
         if (comp->avoid_afill)
           {
              ee = ecore_evas_tbm_native_allocfunc_new("gl_tbm_ES",
                            gdevice, src_w, src_h,
                            _e_comp_canvas_gbm_surface_alloc, _e_comp_canvas_gbm_surface_free,
-                           (void *)e_comp_screen);
+                           (void *)comp_screen);
           }
         else
           {
              ee = ecore_evas_tbm_native_allocfunc_new("gl_tbm",
                            gdevice, src_w, src_h,
                            _e_comp_canvas_gbm_surface_alloc, _e_comp_canvas_gbm_surface_free,
-                           (void *)e_comp_screen);
+                           (void *)comp_screen);
           }
 
         if (ee) break;
@@ -185,7 +185,7 @@ _e_comp_canvas_ecore_evas_deinit(Ecore_Evas *ee)
 }
 
 static Ecore_Evas *
-_e_comp_canvas_ecore_evas_init(E_Comp_Screen *e_comp_screen, int w, int y)
+_e_comp_canvas_ecore_evas_init(E_Comp_Screen *comp_screen, int w, int y)
 {
    Ecore_Evas *ee;
    int scr_w = 1, scr_h = 1;
@@ -202,7 +202,7 @@ _e_comp_canvas_ecore_evas_init(E_Comp_Screen *e_comp_screen, int w, int y)
        ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_OPENGL_TBM))
      e_comp_gl_set(EINA_TRUE);
 
-   e_comp_screen_size_get(e_comp_screen, &scr_w, &scr_h);
+   e_comp_screen_size_get(comp_screen, &scr_w, &scr_h);
 
    ELOGF("COMP_SCREEN", "GL available:%d config engine:%d screen size:%dx%d", NULL,
        e_comp_gl_get(), e_comp_config_get()->engine, scr_w, scr_h);
@@ -213,15 +213,15 @@ _e_comp_canvas_ecore_evas_init(E_Comp_Screen *e_comp_screen, int w, int y)
         e_main_ts_begin("\tEE_GL_TBM New");
         if (e_comp_screen_prefer_gbm_check())
           {
-             ee = _e_comp_canvas_ecore_evas_gbm_alloc(e_comp_screen, scr_w, scr_h);
+             ee = _e_comp_canvas_ecore_evas_gbm_alloc(comp_screen, scr_w, scr_h);
              if (!ee)
-               ee = _e_comp_canvas_ecore_evas_tbm_alloc(e_comp_screen, scr_w, scr_h);
+               ee = _e_comp_canvas_ecore_evas_tbm_alloc(comp_screen, scr_w, scr_h);
           }
         else
           {
-             ee = _e_comp_canvas_ecore_evas_tbm_alloc(e_comp_screen, scr_w, scr_h);
+             ee = _e_comp_canvas_ecore_evas_tbm_alloc(comp_screen, scr_w, scr_h);
              if (!ee)
-               ee = _e_comp_canvas_ecore_evas_gbm_alloc(e_comp_screen, scr_w, scr_h);
+               ee = _e_comp_canvas_ecore_evas_gbm_alloc(comp_screen, scr_w, scr_h);
           }
 
         snprintf(buf, sizeof(buf), "\tEE_GL_TBM New Done %p %dx%d", ee, scr_w, scr_h);
@@ -236,7 +236,7 @@ _e_comp_canvas_ecore_evas_init(E_Comp_Screen *e_comp_screen, int w, int y)
         ee = ecore_evas_tbm_allocfunc_new("software_tbm",
                      scr_w, scr_h,
                      _e_comp_canvas_tbm_surface_queue_alloc, _e_comp_canvas_tbm_surface_queue_free,
-                     (void *)e_comp_screen);
+                     (void *)comp_screen);
         ELOGF("Comp_Canvas", "ecore_evas engine:software_tbm fallback to software engine.", NULL);
         snprintf(buf, sizeof(buf), "\tEE_DRM New Done %p %dx%d", ee, scr_w, scr_h);
         e_main_ts_end(buf);
@@ -260,7 +260,7 @@ _e_comp_canvas_ecore_evas_init(E_Comp_Screen *e_comp_screen, int w, int y)
 
 
 EINTERN Eina_Bool
-e_comp_canvas_init(E_Comp_Screen *e_comp_screen)
+e_comp_canvas_init(E_Comp_Screen *comp_screen)
 {
    E_View_Rect *rect;
    E_View *view;
@@ -278,15 +278,15 @@ e_comp_canvas_init(E_Comp_Screen *e_comp_screen)
    primary_output = e_display_primary_output_get();
    EINA_SAFETY_ON_NULL_RETURN_VAL(primary_output, EINA_FALSE);
 
-   screen_rotation = e_comp_screen->rotation;
+   screen_rotation = comp_screen->rotation;
 
-   e_comp_screen_size_get(e_comp_screen, &w, &h);
+   e_comp_screen_size_get(comp_screen, &w, &h);
 
-   ee = _e_comp_canvas_ecore_evas_init(e_comp_screen, w, h);
+   ee = _e_comp_canvas_ecore_evas_init(comp_screen, w, h);
    EINA_SAFETY_ON_NULL_RETURN_VAL(ee, EINA_FALSE);
 
    ELOGF("Comp_Canvas", "ee(%p) with the tqueue(%p) is created.", NULL,
-         ee, e_comp_screen->tqueue);
+         ee, comp_screen->tqueue);
 
    comp = e_comp_get();
    comp->ee = ee;

diff --git a/src/bin/compmgr/e_comp_canvas_intern.h b/src/bin/compmgr/e_comp_canvas_intern.h
index a384da973a6e9186527ea60130ce4c3ea5c77b9e..ee664c2f15f04f8bffade0ea42caf08054e1fbbf 100644 (file)
--- a/src/bin/compmgr/e_comp_canvas_intern.h
+++ b/src/bin/compmgr/e_comp_canvas_intern.h
@@ -4,7 +4,7 @@
 #include "e_intern.h"
 #include "e_comp_canvas.h"
 
-EINTERN Eina_Bool  e_comp_canvas_init(E_Comp_Screen *e_comp_screen);
+EINTERN Eina_Bool  e_comp_canvas_init(E_Comp_Screen *comp_screen);
 EINTERN void       e_comp_canvas_clear(void);
 EINTERN void       e_comp_all_freeze(void);
 EINTERN void       e_comp_all_thaw(void);

diff --git a/src/bin/compmgr/e_comp_intern.h b/src/bin/compmgr/e_comp_intern.h
index f4baa2ec2fbdcd662b97dab600356221da25b907..112823f44f3d483093de622fe516f38e4b1d3f3a 100644 (file)
--- a/src/bin/compmgr/e_comp_intern.h
+++ b/src/bin/compmgr/e_comp_intern.h
@@ -20,7 +20,7 @@ EINTERN E_Comp       *e_comp_find_by_window(Ecore_Window win);
 EINTERN void          e_comp_override_timed_pop(void);
 EINTERN void          e_comp_gl_set(Eina_Bool set);
 EINTERN Eina_Bool     e_comp_gl_get(void);
-EINTERN void          e_comp_screen_set(E_Comp_Screen *screen);
+EINTERN void          e_comp_screen_set(E_Comp_Screen *comp_screen);
 
 EINTERN void          e_comp_button_bindings_grab_all(void);
 EINTERN void          e_comp_button_bindings_ungrab_all(void);

diff --git a/src/bin/compmgr/e_egl_sync.c b/src/bin/compmgr/e_egl_sync.c
index 53baa6b29bdd271ccb63d34f3cef486e9c81fdf1..1d5bbf733e7e5190c837089a93476d6d8228888f 100644 (file)
--- a/src/bin/compmgr/e_egl_sync.c
+++ b/src/bin/compmgr/e_egl_sync.c
@@ -199,7 +199,7 @@ e_egl_sync_init(void)
    EINA_SAFETY_ON_NULL_RETURN_VAL(comp_wl, EINA_FALSE);
    EINA_SAFETY_ON_NULL_RETURN_VAL(comp_wl->wl.disp, EINA_FALSE);
    EINA_SAFETY_ON_NULL_RETURN_VAL(comp, EINA_FALSE);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(comp->e_comp_screen, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp->comp_screen, EINA_FALSE);
 
    if (_egl_sync_mgr) return EINA_TRUE;
    if (!e_comp_gl_get()) return EINA_TRUE;

diff --git a/src/bin/debug/e_info_server.c b/src/bin/debug/e_info_server.c
index 3da041284e62f75e4bdc8ab858f625090e0ba551..b6b66b22bd5bcd6c69ee62157cc787fc9402a2fe 100644 (file)
--- a/src/bin/debug/e_info_server.c
+++ b/src/bin/debug/e_info_server.c
@@ -4334,14 +4334,14 @@ _e_info_server_cb_screen_dump(const Eldbus_Service_Interface *iface EINA_UNUSED,
 }
 
 static void
-_output_mode_set(E_Comp_Screen *e_comp_screen, int output_idx, int mode_count)
+_output_mode_set(E_Comp_Screen *comp_screen, int output_idx, int mode_count)
 {
    E_Output *output;
    E_Output_Mode *emode = NULL;
    Eina_List *mode_list = NULL;
    int num;
 
-   EINA_SAFETY_ON_TRUE_RETURN(output_idx > e_comp_screen->num_outputs);
+   EINA_SAFETY_ON_TRUE_RETURN(output_idx > comp_screen->num_outputs);
 
    output = eina_list_nth(e_display_outputs_get(), output_idx);
    EINA_SAFETY_ON_NULL_RETURN(output);
@@ -4360,7 +4360,7 @@ _output_mode_set(E_Comp_Screen *e_comp_screen, int output_idx, int mode_count)
 }
 
 static void
-_output_mode_msg_clients_append(Eldbus_Message_Iter *iter, E_Comp_Screen *e_comp_screen, int gl, int mode, int output_idx, int mode_count)
+_output_mode_msg_clients_append(Eldbus_Message_Iter *iter, E_Comp_Screen *comp_screen, int gl, int mode, int output_idx, int mode_count)
 {
    Eldbus_Message_Iter *array_of_mode;
    Eldbus_Message_Iter *struct_of_mode;
@@ -4384,9 +4384,9 @@ _output_mode_msg_clients_append(Eldbus_Message_Iter *iter, E_Comp_Screen *e_comp
      }
 
    if (mode == E_INFO_CMD_OUTPUT_MODE_SET)
-     _output_mode_set(e_comp_screen, output_idx, mode_count);
+     _output_mode_set(comp_screen, output_idx, mode_count);
 
-   count = e_comp_screen->num_outputs;
+   count = comp_screen->num_outputs;
 
    for (i = 0; i < count; i++)
      {
@@ -4461,18 +4461,18 @@ _e_info_server_cb_output_mode(const Eldbus_Service_Interface *iface EINA_UNUSED,
    if ((mode == E_INFO_CMD_OUTPUT_MODE_GET) ||
        (mode == E_INFO_CMD_OUTPUT_MODE_SET))
      {
-        E_Comp_Screen *e_comp_screen = e_comp_screen_get();
-        if (!e_comp_screen)
+        E_Comp_Screen *comp_screen = e_comp_screen_get();
+        if (!comp_screen)
           {
              ERR("Error no screen.");
              return reply;
           }
-        tdpy = e_comp_screen->tdisplay;
+        tdpy = comp_screen->tdisplay;
 
         if (tdpy != NULL)
-          _output_mode_msg_clients_append(eldbus_message_iter_get(reply), e_comp_screen, 1, mode, output_idx, count);
+          _output_mode_msg_clients_append(eldbus_message_iter_get(reply), comp_screen, 1, mode, output_idx, count);
         else
-          _output_mode_msg_clients_append(eldbus_message_iter_get(reply), e_comp_screen, 0, 0, 0, 0);
+          _output_mode_msg_clients_append(eldbus_message_iter_get(reply), comp_screen, 0, 0, 0, 0);
      }
 
    return reply;
@@ -5124,7 +5124,7 @@ static Eldbus_Message *
 _e_info_server_cb_screen_rotation_pre(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
 {
    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
    int rotation_pre;
 
    if (!eldbus_message_arguments_get(msg, "i", &rotation_pre))
@@ -5133,13 +5133,13 @@ _e_info_server_cb_screen_rotation_pre(const Eldbus_Service_Interface *iface EINA
         return reply;
      }
 
-   if (!e_comp_screen)
+   if (!comp_screen)
      {
         ERR("Error no screen.");
         return reply;
      }
 
-   e_comp_screen_rotation_pre_set(e_comp_screen, rotation_pre);
+   e_comp_screen_rotation_pre_set(comp_screen, rotation_pre);
 
    if (e_config->screen_rotation_pre != rotation_pre)
      {
@@ -5162,7 +5162,7 @@ static Eldbus_Message *
 _e_info_server_cb_screen_rotation(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
 {
    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
    int rotation;
 
    if (!eldbus_message_arguments_get(msg, "i", &rotation))
@@ -5171,13 +5171,13 @@ _e_info_server_cb_screen_rotation(const Eldbus_Service_Interface *iface EINA_UNU
         return reply;
      }
 
-   if (!e_comp_screen)
+   if (!comp_screen)
      {
         ERR("Error no screen.");
         return reply;
      }
 
-   e_comp_screen_rotation_setting_set(e_comp_screen, rotation);
+   e_comp_screen_rotation_setting_set(comp_screen, rotation);
 
    return reply;
 }

diff --git a/src/bin/displaymgr/e_display.c b/src/bin/displaymgr/e_display.c
index 4ca15ed552491062b3fe2d151ee5659a6d287252..52291313dd4a12f6792fb146b878887a33bee81e 100644 (file)
--- a/src/bin/displaymgr/e_display.c
+++ b/src/bin/displaymgr/e_display.c
@@ -417,7 +417,7 @@ EINTERN Eina_Bool
 e_display_init(void)
 {
    E_Display *display;
-   E_Comp_Screen *e_comp_screen;
+   E_Comp_Screen *comp_screen;
    tdm_display_capability capabilities;
    const tbm_format *pp_formats;
    tdm_error error = TDM_ERROR_NONE;
@@ -426,8 +426,8 @@ e_display_init(void)
 
    if (g_display) return EINA_TRUE;
 
-   e_comp_screen = e_comp_screen_get();
-   if (!e_comp_screen) return EINA_FALSE;
+   comp_screen = e_comp_screen_get();
+   if (!comp_screen) return EINA_FALSE;
 
    display = E_NEW(E_Display, 1);
    EINA_SAFETY_ON_NULL_RETURN_VAL(display, EINA_FALSE);
@@ -491,7 +491,7 @@ e_display_init(void)
         goto fail;
      }
 
-   e_comp_screen->tdisplay = display->tdisplay;
+   comp_screen->tdisplay = display->tdisplay;
 
    return EINA_TRUE;
 

diff --git a/src/bin/displaymgr/e_output.c b/src/bin/displaymgr/e_output.c
index 6df485e61d7a502737c3e0cda5fc2683fc139597..9e4a758bb12563a467ce3a6c7a6a686bd634dda8 100644 (file)
--- a/src/bin/displaymgr/e_output.c
+++ b/src/bin/displaymgr/e_output.c
@@ -2096,9 +2096,9 @@ e_output_update(E_Output *output)
              error = tdm_output_get_pipe(output->toutput, &pipe);
              if (error == TDM_ERROR_NONE && pipe == 0)
                {
-                  E_Comp_Screen *e_comp_screen = e_comp_screen_get();
-                  if (e_comp_screen)
-                    output->config.rotation = e_comp_screen->rotation;
+                  E_Comp_Screen *comp_screen = e_comp_screen_get();
+                  if (comp_screen)
+                    output->config.rotation = comp_screen->rotation;
                }
 
              if (maker)

diff --git a/src/bin/displaymgr/video/e_video_hwc.c b/src/bin/displaymgr/video/e_video_hwc.c
index c3b37276e4172b8b3db53fcca4adc9ddb229cc83..dc21a6f553211b718652ce5e09aa8012785f01c0 100644 (file)
--- a/src/bin/displaymgr/video/e_video_hwc.c
+++ b/src/bin/displaymgr/video/e_video_hwc.c
@@ -840,9 +840,9 @@ _e_video_hwc_pp_render(E_Video_Hwc *evh, E_Comp_Wl_Buffer *comp_buffer)
 
    if (!evh->pp)
      {
-        E_Comp_Screen *e_comp_screen = e_comp_screen_get();
-        if (e_comp_screen)
-          evh->pp = _e_video_hwc_pp_create(e_comp_screen->tdisplay, evh);
+        E_Comp_Screen *comp_screen = e_comp_screen_get();
+        if (comp_screen)
+          evh->pp = _e_video_hwc_pp_create(comp_screen->tdisplay, evh);
         if (!evh->pp)
           return EINA_FALSE;
      }
@@ -1770,7 +1770,7 @@ _e_video_hwc_client_parent_viewable_get(E_Client *ec)
 static Eina_Bool
 _e_video_hwc_check_if_pp_needed(E_Video_Hwc *evh)
 {
-   E_Comp_Screen *e_comp_screen;
+   E_Comp_Screen *comp_screen;
    int i, count = 0;
    const tbm_format *formats;
    Eina_Bool found = EINA_FALSE;
@@ -1813,8 +1813,8 @@ _e_video_hwc_check_if_pp_needed(E_Video_Hwc *evh)
        goto need_pp;
 
    /* check rotate */
-   e_comp_screen = e_comp_screen_get();
-   if (evh->geo.transform || (e_comp_screen && e_comp_screen->rotation > 0))
+   comp_screen = e_comp_screen_get();
+   if (evh->geo.transform || (comp_screen && comp_screen->rotation > 0))
      if (!hwc->tdm_hwc_video_transform)
        goto need_pp;
 

diff --git a/src/bin/e_comp_screen.c b/src/bin/e_comp_screen.c
index 846eee5ca9839f74a57be9f28bc69a0159ac5971..1ed6210af0b64ed30f29357e3a4635bdced4b799 100644 (file)
--- a/src/bin/e_comp_screen.c
+++ b/src/bin/e_comp_screen.c
@@ -79,27 +79,27 @@ enum
    E_COMP_SCREEN_SIGNAL_ROTATION_CHANGED = 0
 };
 
-static void _e_comp_screen_e_screens_setup(E_Comp_Screen *e_comp_screen, int rw, int rh);
+static void _e_comp_screen_e_screens_setup(E_Comp_Screen *comp_screen, int rw, int rh);
 static void _e_comp_screen_screen_policy_update(void);
 
 static void
-_e_comp_screen_gl_shutdown(E_Comp_Screen *e_comp_screen)
+_e_comp_screen_gl_shutdown(E_Comp_Screen *comp_screen)
 {
-   if (!e_comp_screen->evas_gl) return;
+   if (!comp_screen->evas_gl) return;
 
-   if (e_comp_screen->evas_gl->glapi->evasglUnbindWaylandDisplay)
-     e_comp_screen->evas_gl->glapi->evasglUnbindWaylandDisplay(e_comp_screen->evas_gl->gl, e_comp_screen->wl_display);
+   if (comp_screen->evas_gl->glapi->evasglUnbindWaylandDisplay)
+     comp_screen->evas_gl->glapi->evasglUnbindWaylandDisplay(comp_screen->evas_gl->gl, comp_screen->wl_display);
 
-   evas_gl_make_current(e_comp_screen->evas_gl->gl, NULL, NULL);
-   evas_gl_context_destroy(e_comp_screen->evas_gl->gl, e_comp_screen->evas_gl->glctx);
-   evas_gl_surface_destroy(e_comp_screen->evas_gl->gl, e_comp_screen->evas_gl->glsfc);
-   evas_gl_free(e_comp_screen->evas_gl->gl);
+   evas_gl_make_current(comp_screen->evas_gl->gl, NULL, NULL);
+   evas_gl_context_destroy(comp_screen->evas_gl->gl, comp_screen->evas_gl->glctx);
+   evas_gl_surface_destroy(comp_screen->evas_gl->gl, comp_screen->evas_gl->glsfc);
+   evas_gl_free(comp_screen->evas_gl->gl);
 
-   E_FREE(e_comp_screen->evas_gl);
+   E_FREE(comp_screen->evas_gl);
 }
 
 static void
-_e_comp_screen_gl_init(E_Comp_Screen *e_comp_screen)
+_e_comp_screen_gl_init(E_Comp_Screen *comp_screen)
 {
    Evas *evas = NULL;
    Evas_GL *evasgl = NULL;
@@ -153,7 +153,7 @@ _e_comp_screen_gl_init(E_Comp_Screen *e_comp_screen)
    res = evas_gl_make_current(evasgl, sfc, ctx);
    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 
-   res = glapi->evasglBindWaylandDisplay(evasgl, e_comp_screen->wl_display);
+   res = glapi->evasglBindWaylandDisplay(evasgl, comp_screen->wl_display);
    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 
    evas_gl_config_free(cfg);
@@ -163,7 +163,7 @@ _e_comp_screen_gl_init(E_Comp_Screen *e_comp_screen)
    evas_gl->glsfc = sfc;
    evas_gl->glctx = ctx;
 
-   e_comp_screen->evas_gl = evas_gl;
+   comp_screen->evas_gl = evas_gl;
 
    /* for native surface */
    comp->gl = 1;
@@ -185,11 +185,11 @@ static Eldbus_Message *
 _e_comp_screen_dbus_get_cb(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 {
    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
    int rotation = 0;
 
-   if (e_comp_screen)
-     rotation = e_comp_screen->rotation;
+   if (comp_screen)
+     rotation = comp_screen->rotation;
 
    ELOGF("COMP_SCREEN","got screen-rotation 'get' request: %d", NULL, rotation);
 
@@ -216,18 +216,18 @@ static const Eldbus_Service_Interface_Desc iface_desc = {
 static void
 _e_comp_screen_dbus_init()
 {
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
-   EINA_SAFETY_ON_NULL_GOTO(e_comp_screen, err);
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
+   EINA_SAFETY_ON_NULL_GOTO(comp_screen, err);
 
    e_comp_screen_iface = eldbus_service_interface_register(edbus_conn,
                                                            PATH,
                                                            &iface_desc);
    EINA_SAFETY_ON_NULL_GOTO(e_comp_screen_iface, err);
 
-   if (e_comp_screen->rotation)
+   if (comp_screen->rotation)
      {
-        eldbus_service_signal_emit(e_comp_screen_iface, E_COMP_SCREEN_SIGNAL_ROTATION_CHANGED, e_comp_screen->rotation);
-        ELOGF("TRANSFORM", "screen-rotation sends signal: %d", NULL, e_comp_screen->rotation);
+        eldbus_service_signal_emit(e_comp_screen_iface, E_COMP_SCREEN_SIGNAL_ROTATION_CHANGED, comp_screen->rotation);
+        ELOGF("TRANSFORM", "screen-rotation sends signal: %d", NULL, comp_screen->rotation);
      }
 
    return;
@@ -326,10 +326,10 @@ _e_comp_screen_cb_input_device_add(void *data, int type, void *event)
      }
    else if (e->clas == ECORE_DEVICE_CLASS_TOUCH)
      {
-        E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+        E_Comp_Screen *comp_screen = e_comp_screen_get();
         e_comp_wl_input_touch_enabled_set(EINA_TRUE);
-        if (e_comp_screen)
-          _e_comp_screen_input_rotation_set(e_comp_screen->rotation);
+        if (comp_screen)
+          _e_comp_screen_input_rotation_set(comp_screen->rotation);
         comp_wl->touch.num_devices++;
      }
 
@@ -409,14 +409,14 @@ end:
 }
 
 EINTERN Eina_Bool
-e_comp_screen_size_update(E_Comp_Screen *e_comp_screen)
+e_comp_screen_size_update(E_Comp_Screen *comp_screen)
 {
    E_Output *output;
    int sum_w = 0, max_h = 0, output_w, output_h;
    Eina_List *l;
    E_Comp *comp;
 
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, EINA_FALSE);
 
    EINA_LIST_FOREACH(e_display_outputs_get(), l, output)
      {
@@ -429,8 +429,8 @@ e_comp_screen_size_update(E_Comp_Screen *e_comp_screen)
           max_h = output_h;
      }
 
-   e_comp_screen->w = sum_w;
-   e_comp_screen->h = max_h;
+   comp_screen->w = sum_w;
+   comp_screen->h = max_h;
 
    comp = e_comp_get();
    if (comp->ee)
@@ -439,13 +439,13 @@ e_comp_screen_size_update(E_Comp_Screen *e_comp_screen)
          * ecore_evas is created without rotation
          * and rotation of ecore_evas is reset after it is resized
          */
-        if (e_comp_screen->rotation)
+        if (comp_screen->rotation)
           ecore_evas_rotation_with_resize_set(comp->ee, 0);
 
-        ecore_evas_resize(comp->ee, e_comp_screen->w, e_comp_screen->h);
+        ecore_evas_resize(comp->ee, comp_screen->w, comp_screen->h);
 
-        if (e_comp_screen->rotation)
-          ecore_evas_rotation_with_resize_set(comp->ee, e_comp_screen->rotation);
+        if (comp_screen->rotation)
+          ecore_evas_rotation_with_resize_set(comp->ee, comp_screen->rotation);
      }
 
    return EINA_TRUE;
@@ -454,22 +454,22 @@ e_comp_screen_size_update(E_Comp_Screen *e_comp_screen)
 static E_Comp_Screen *
 _e_comp_screen_new(void)
 {
-   E_Comp_Screen *e_comp_screen = NULL;
+   E_Comp_Screen *comp_screen = NULL;
 
-   e_comp_screen = E_NEW(E_Comp_Screen, 1);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, EINA_FALSE);
+   comp_screen = E_NEW(E_Comp_Screen, 1);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, EINA_FALSE);
 
-   e_comp_screen_set(e_comp_screen);
+   e_comp_screen_set(comp_screen);
 
-   return e_comp_screen;
+   return comp_screen;
 }
 
 static void
-_e_comp_screen_del(E_Comp_Screen *e_comp_screen)
+_e_comp_screen_del(E_Comp_Screen *comp_screen)
 {
-   if (!e_comp_screen) return;
+   if (!comp_screen) return;
 
-   free(e_comp_screen);
+   free(comp_screen);
 }
 
 static void
@@ -483,10 +483,10 @@ _e_comp_screen_e_screen_free(E_Screen *scr)
 }
 
 static void
-_e_comp_screen_e_screens_set(E_Comp_Screen *e_comp_screen, Eina_List *screens)
+_e_comp_screen_e_screens_set(E_Comp_Screen *comp_screen, Eina_List *screens)
 {
-   E_FREE_LIST(e_comp_screen->e_screens, _e_comp_screen_e_screen_free);
-   e_comp_screen->e_screens = screens;
+   E_FREE_LIST(comp_screen->e_screens, _e_comp_screen_e_screen_free);
+   comp_screen->e_screens = screens;
 }
 
 static Eina_Bool
@@ -519,11 +519,11 @@ _e_comp_canvas_cb_zone_sort(const void *data1, const void *data2)
 #endif
 
 static const Eina_List *
-_e_comp_screen_e_screens_get(E_Comp_Screen *e_comp_screen)
+_e_comp_screen_e_screens_get(E_Comp_Screen *comp_screen)
 {
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, NULL);
 
-   return e_comp_screen->e_screens;
+   return comp_screen->e_screens;
 }
 
 static void
@@ -730,7 +730,7 @@ _e_comp_screen_screen_policy_setup(void)
 }
 
 static void
-_e_comp_screen_e_screens_setup(E_Comp_Screen *e_comp_screen, int rw, int rh)
+_e_comp_screen_e_screens_setup(E_Comp_Screen *comp_screen, int rw, int rh)
 {
    E_Screen *screen;
    E_Output *primary_output, *output;
@@ -784,11 +784,11 @@ _e_comp_screen_e_screens_setup(E_Comp_Screen *e_comp_screen, int rw, int rh)
         i++;
      }
 
-   _e_comp_screen_e_screens_set(e_comp_screen, e_screens);
+   _e_comp_screen_e_screens_set(comp_screen, e_screens);
 
    ecore_event_add(E_EVENT_SCREEN_CHANGE, NULL, NULL, NULL);
 
-   ELOGF("COMP_SCREEN","_e_comp_screen_e_screens_setup............... %i %p\n", NULL, i, e_comp_screen->e_screens);
+   ELOGF("COMP_SCREEN","_e_comp_screen_e_screens_setup............... %i %p\n", NULL, i, comp_screen->e_screens);
 
    return;
 out:
@@ -801,7 +801,7 @@ out:
      screen->w = rw, screen->h = rh;
    else
      {
-        if (e_comp_screen->rotation % 180)
+        if (comp_screen->rotation % 180)
           ecore_evas_geometry_get(e_comp_ee_get(), NULL, NULL, &screen->h, &screen->w);
         else
           ecore_evas_geometry_get(e_comp_ee_get(), NULL, NULL, &screen->w, &screen->h);
@@ -811,7 +811,7 @@ out:
    ELOGF("COMP_SCREEN","E INIT: SCREEN: No Physical Screen : [%i][%i], %ix%i+%i+%i",
          NULL, i, i, screen->w, screen->h, screen->x, screen->y);
 
-   _e_comp_screen_e_screens_set(e_comp_screen, e_screens);
+   _e_comp_screen_e_screens_set(comp_screen, e_screens);
 }
 
 static void
@@ -827,8 +827,8 @@ _e_comp_screen_cb_output_mode_change(void *data, E_Output *output)
 }
 
 static Eina_Bool
-_e_comp_screen_rotation_set(E_Comp_Screen *e_comp_screen, int screen_rotation,
-  void (*setter)(E_Comp_Screen *e_comp_screen, int data), int data)
+_e_comp_screen_rotation_set(E_Comp_Screen *comp_screen, int screen_rotation,
+  void (*setter)(E_Comp_Screen *comp_screen, int data), int data)
 {
    E_Output *primary_output = NULL;
    E_Input_Device *dev;
@@ -843,12 +843,12 @@ _e_comp_screen_rotation_set(E_Comp_Screen *e_comp_screen, int screen_rotation,
    if (!e_output_rotate(primary_output, screen_rotation))
      return EINA_FALSE;
 
-   e_comp_screen->rotation = screen_rotation;
+   comp_screen->rotation = screen_rotation;
    if (setter)
-      setter(e_comp_screen, data);
+      setter(comp_screen, data);
 
    comp = e_comp_get();
-   ecore_evas_rotation_with_resize_set(comp->ee, e_comp_screen->rotation);
+   ecore_evas_rotation_with_resize_set(comp->ee, comp_screen->rotation);
    ecore_evas_geometry_get(comp->ee, NULL, NULL, &w, &h);
 
    /* rendering forcely to prepare HWC */
@@ -857,34 +857,34 @@ _e_comp_screen_rotation_set(E_Comp_Screen *e_comp_screen, int screen_rotation,
 
    EINA_LIST_FOREACH(e_input_devices_get(), l, dev)
      {
-         e_input_device_touch_rotation_set(dev, e_comp_screen->rotation);
-         e_input_device_rotation_set(dev, e_comp_screen->rotation);
+         e_input_device_touch_rotation_set(dev, comp_screen->rotation);
+         e_input_device_rotation_set(dev, comp_screen->rotation);
 
-         ELOGF("COMP_SCREEN","EE Input Device Rotate: %d", NULL, e_comp_screen->rotation);
+         ELOGF("COMP_SCREEN","EE Input Device Rotate: %d", NULL, comp_screen->rotation);
      }
 
    if (e_comp_screen_iface)
      {
-        eldbus_service_signal_emit(e_comp_screen_iface, E_COMP_SCREEN_SIGNAL_ROTATION_CHANGED, e_comp_screen->rotation);
-        ELOGF("COMP_SCREEN", "screen-rotation sends signal: %d", NULL, e_comp_screen->rotation);
+        eldbus_service_signal_emit(e_comp_screen_iface, E_COMP_SCREEN_SIGNAL_ROTATION_CHANGED, comp_screen->rotation);
+        ELOGF("COMP_SCREEN", "screen-rotation sends signal: %d", NULL, comp_screen->rotation);
      }
 
-   ELOGF("COMP_SCREEN","EE Rotated and Resized: %d, %dx%d", NULL, e_comp_screen->rotation, w, h);
+   ELOGF("COMP_SCREEN","EE Rotated and Resized: %d, %dx%d", NULL, comp_screen->rotation, w, h);
 
    return EINA_TRUE;
 }
 
 static void
-_e_comp_screen_rotation_pre_setter(E_Comp_Screen *e_comp_screen, int rotation_pre)
+_e_comp_screen_rotation_pre_setter(E_Comp_Screen *comp_screen, int rotation_pre)
 {
-   e_comp_screen->rotation_pre = rotation_pre;
+   comp_screen->rotation_pre = rotation_pre;
    ELOGF("COMP_SCREEN","EE RotationPre: %d", NULL, rotation_pre);
 }
 
 static void
-_e_comp_screen_rotation_setting_setter(E_Comp_Screen *e_comp_screen, int rotation)
+_e_comp_screen_rotation_setting_setter(E_Comp_Screen *comp_screen, int rotation)
 {
-   e_comp_screen->rotation_setting = rotation;
+   comp_screen->rotation_setting = rotation;
    ELOGF("COMP_SCREEN","EE RotationSetting: %d", NULL, rotation);
 }
 
@@ -893,7 +893,7 @@ e_comp_screen_init()
 {
    E_Comp *comp;
    E_Comp_Wl_Data *comp_wl;
-   E_Comp_Screen *e_comp_screen;
+   E_Comp_Screen *comp_screen;
    int ptr_x = 0, ptr_y = 0;
    int screen_rotation;
 
@@ -902,13 +902,13 @@ e_comp_screen_init()
    comp = e_comp_get();
    EINA_SAFETY_ON_NULL_RETURN_VAL(comp, EINA_FALSE);
 
-   /* e_comp_screen new */
+   /* comp_screen new */
    e_main_ts_begin("\tE_Comp_Screen New");
-   e_comp_screen = _e_comp_screen_new();
-   if (!e_comp_screen)
+   comp_screen = _e_comp_screen_new();
+   if (!comp_screen)
      {
         e_main_ts_end("\tE_Comp_Screen New Failed");
-        e_error_message_show(_("Enlightenment cannot create e_comp_screen!\n"));
+        e_error_message_show(_("Enlightenment cannot create comp_screen!\n"));
         return EINA_FALSE;
      }
    e_main_ts_end("\tE_Comp_Screen New Done");
@@ -919,9 +919,9 @@ e_comp_screen_init()
    ELOGF("COMP_SCREEN","screen_rotation_pre %d and screen_rotation_setting %d",
          NULL, e_config->screen_rotation_pre, e_config->screen_rotation_setting);
 
-   e_comp_screen->rotation_pre = e_config->screen_rotation_pre;
-   e_comp_screen->rotation_setting = e_config->screen_rotation_setting;
-   e_comp_screen->rotation = screen_rotation;
+   comp_screen->rotation_pre = e_config->screen_rotation_pre;
+   comp_screen->rotation_setting = e_config->screen_rotation_setting;
+   comp_screen->rotation = screen_rotation;
 
    e_main_ts_begin("\te_display_init");
    if (!e_display_init())
@@ -935,16 +935,16 @@ e_comp_screen_init()
    // Decide the size of Comp Screen and Get the Memory from E_Display
    e_comp_screen_size_update(e_comp_screen_get());
 
-   e_comp_screen->num_outputs = e_display_num_outputs_get();
-   e_comp_screen->outputs = e_display_outputs_get();
+   comp_screen->num_outputs = e_display_num_outputs_get();
+   comp_screen->outputs = e_display_outputs_get();
 
    if (e_comp_hwc_is_configured() && e_comp_conf_hwc_deactive_get())
      e_comp_hwc_deactive_set(EINA_TRUE);
 
    /* tbm bufmgr init */
    e_main_ts_begin("\tTBM Bufmgr Server Init");
-   e_comp_screen->bufmgr = tbm_bufmgr_server_init();
-   if (!e_comp_screen->bufmgr)
+   comp_screen->bufmgr = tbm_bufmgr_server_init();
+   if (!comp_screen->bufmgr)
      {
         e_main_ts_end("\tTBM Bufmgr Server Init Failed");
         ERR("tbm_bufmgr_init failed\n");
@@ -956,7 +956,7 @@ e_comp_screen_init()
 
    /* canvas */
    e_main_ts_begin("\tE_Comp_Canvas Init");
-   if (!e_comp_canvas_init(e_comp_screen))
+   if (!e_comp_canvas_init(comp_screen))
      {
         e_main_ts_end("\tE_Comp_Canvas Init Failed");
         e_error_message_show(_("Enlightenment cannot initialize outputs!\n"));
@@ -964,7 +964,7 @@ e_comp_screen_init()
      }
    e_main_ts_end("\tE_Comp_Canvas Init Done");
 
-   _e_comp_screen_e_screens_setup(e_comp_screen, -1, -1);
+   _e_comp_screen_e_screens_setup(comp_screen, -1, -1);
 
    /* update the screen, outputs and planes at the idle enterer of the ecore_loop */
    ecore_idle_enterer_add(_e_comp_screen_commit_idle_cb, comp);
@@ -987,10 +987,10 @@ e_comp_screen_init()
    e_main_ts_end("\tE_Server Init Done");
 
    comp_wl = e_comp_wl_get();
-   e_comp_screen->wl_display = comp_wl->wl.disp;
+   comp_screen->wl_display = comp_wl->wl.disp;
 
    if (e_comp_gl_get())
-     _e_comp_screen_gl_init(e_comp_screen);
+     _e_comp_screen_gl_init(comp_screen);
 
    /* e_comp_screen_setup */
    if (!_e_comp_screen_screen_policy_setup())
@@ -1032,9 +1032,9 @@ e_comp_screen_init()
    E_OUTPUT_HOOK_APPEND(output_hooks, E_OUTPUT_HOOK_CONNECT_STATUS_CHANGE, _e_comp_screen_cb_output_connect_status_change, comp);
    E_OUTPUT_HOOK_APPEND(output_hooks, E_OUTPUT_HOOK_MODE_CHANGE, _e_comp_screen_cb_output_mode_change, comp);
 
-   e_comp_screen = e_comp_screen_get();
-   if (e_comp_screen)
-     _e_comp_screen_input_rotation_set(e_comp_screen->rotation);
+   comp_screen = e_comp_screen_get();
+   if (comp_screen)
+     _e_comp_screen_input_rotation_set(comp_screen->rotation);
 
    ecore_evas_callback_resize_set(comp->ee, _e_comp_screen_canvas_resize);
 
@@ -1042,19 +1042,19 @@ e_comp_screen_init()
 
 failed_policy_setup:
    //TODO:FIXME: deal with removing the resource during policy_setup
-   _e_comp_screen_gl_shutdown(e_comp_screen);
+   _e_comp_screen_gl_shutdown(comp_screen);
    e_server_shutdown();
 failed_server:
    e_input_shutdown();
 failed_input:
    e_comp_canvas_clear();
 failed_comp_canvas:
-   if (e_comp_screen->bufmgr)
-     tbm_bufmgr_deinit(e_comp_screen->bufmgr);
+   if (comp_screen->bufmgr)
+     tbm_bufmgr_deinit(comp_screen->bufmgr);
 failed_tbm_bufmgr:
    e_display_shutdown();
 failed_display:
-   _e_comp_screen_del(e_comp_screen);
+   _e_comp_screen_del(comp_screen);
 
    return EINA_FALSE;
 }
@@ -1062,10 +1062,10 @@ failed_display:
 EINTERN void
 e_comp_screen_shutdown()
 {
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
-   if (!e_comp_screen) return;
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
+   if (!comp_screen) return;
 
-   _e_comp_screen_gl_shutdown(e_comp_screen);
+   _e_comp_screen_gl_shutdown(comp_screen);
 
    if (e_comp_screen_iface)
      {
@@ -1087,49 +1087,49 @@ e_comp_screen_shutdown()
 
    e_comp_canvas_clear();
 
-   if (e_comp_screen->bufmgr) tbm_bufmgr_deinit(e_comp_screen->bufmgr);
+   if (comp_screen->bufmgr) tbm_bufmgr_deinit(comp_screen->bufmgr);
 
    e_server_shutdown();
    e_input_shutdown();
 
    /* delete e_comp_sreen */
-   _e_comp_screen_del(e_comp_screen);
+   _e_comp_screen_del(comp_screen);
    e_comp_screen_set(NULL);
 }
 
 EINTERN Eina_Bool
-e_comp_screen_rotation_pre_set(E_Comp_Screen *e_comp_screen, int rotation_pre)
+e_comp_screen_rotation_pre_set(E_Comp_Screen *comp_screen, int rotation_pre)
 {
    int screen_rotation;
 
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation_pre % 90, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation_pre < 0, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation_pre > 270, EINA_FALSE);
 
-   if (e_comp_screen->rotation_pre == rotation_pre) return EINA_TRUE;
+   if (comp_screen->rotation_pre == rotation_pre) return EINA_TRUE;
 
-   screen_rotation = (rotation_pre + e_comp_screen->rotation_setting) % 360;
+   screen_rotation = (rotation_pre + comp_screen->rotation_setting) % 360;
 
-   return _e_comp_screen_rotation_set(e_comp_screen, screen_rotation,
+   return _e_comp_screen_rotation_set(comp_screen, screen_rotation,
      _e_comp_screen_rotation_pre_setter, rotation_pre);
 }
 
 E_API Eina_Bool
-e_comp_screen_rotation_setting_set(E_Comp_Screen *e_comp_screen, int rotation)
+e_comp_screen_rotation_setting_set(E_Comp_Screen *comp_screen, int rotation)
 {
    int screen_rotation;
 
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation % 90, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation < 0, EINA_FALSE);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(rotation > 270, EINA_FALSE);
 
-   if (e_comp_screen->rotation_setting == rotation) return EINA_TRUE;
+   if (comp_screen->rotation_setting == rotation) return EINA_TRUE;
 
-   screen_rotation = (e_comp_screen->rotation_pre + rotation) % 360;
+   screen_rotation = (comp_screen->rotation_pre + rotation) % 360;
 
-   return _e_comp_screen_rotation_set(e_comp_screen, screen_rotation,
+   return _e_comp_screen_rotation_set(comp_screen, screen_rotation,
      _e_comp_screen_rotation_setting_setter, rotation);
 }
 
@@ -1163,20 +1163,20 @@ e_comp_screen_available_video_formats_get(const tbm_format **formats, int *count
 }
 
 EINTERN Eina_Bool
-e_comp_screen_size_get(E_Comp_Screen *e_comp_screen, int *w, int *h)
+e_comp_screen_size_get(E_Comp_Screen *comp_screen, int *w, int *h)
 {
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, EINA_FALSE);
 
-   if (w) *w = e_comp_screen->w;
-   if (h) *h = e_comp_screen->h;
+   if (w) *w = comp_screen->w;
+   if (h) *h = comp_screen->h;
 
    return EINA_TRUE;
 }
 
 E_API Eina_List *
-e_comp_screen_outputs_get(E_Comp_Screen *e_comp_screen)
+e_comp_screen_outputs_get(E_Comp_Screen *comp_screen)
 {
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, NULL);
 
    return e_display_outputs_get();
 }

diff --git a/src/bin/inputmgr/e_input_evdev.c b/src/bin/inputmgr/e_input_evdev.c
index c0ab83e442b7b82712789d74dacf01afcee57bd0..b8b80ecf45fa418ba3bf9769002b4cde5c482367 100644 (file)
--- a/src/bin/inputmgr/e_input_evdev.c
+++ b/src/bin/inputmgr/e_input_evdev.c
@@ -67,9 +67,9 @@ e_input_evdev_device_calibration_set(E_Input_Evdev *evdev)
    int w = 0, h = 0;
    int temp;
    E_Comp_Config *comp_conf;
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
 
-   if (e_comp_screen && e_comp_screen->num_outputs > 1) //multiple outputs
+   if (comp_screen && comp_screen->num_outputs > 1) //multiple outputs
      {
         comp_conf = e_comp_config_get();
         if (comp_conf && (comp_conf->input_output_assign_policy == 1)) //use output-assignment policy
@@ -156,13 +156,13 @@ _device_output_assign(E_Input_Evdev *evdev, E_Input_Seat_Capabilities cap)
    Eina_Bool need_assign_output = EINA_FALSE;
    const char *output_name;
    E_Output *output;
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
 
    if (!(evdev->caps & cap)) return;
    if (evdev->output_name) return; //already assigned
-   if (!e_comp_screen || e_comp_screen->num_outputs <= 1) return;
+   if (!comp_screen || comp_screen->num_outputs <= 1) return;
 
-   last_output_idx = e_comp_screen->num_outputs - 1;
+   last_output_idx = comp_screen->num_outputs - 1;
    EINA_LIST_FOREACH(evdev->seat->devices, l, ed)
      {
         if (!(ed->caps & cap)) continue;

diff --git a/src/bin/server/e_linux_dmabuf.c b/src/bin/server/e_linux_dmabuf.c
index 13c2753569ba4c80099dcf4d1f2005c5a62b558f..5de33c557f27291fd650cf4875554f787b971bef 100644 (file)
--- a/src/bin/server/e_linux_dmabuf.c
+++ b/src/bin/server/e_linux_dmabuf.c
@@ -114,7 +114,7 @@ _e_linux_dmabuf_egl_format_get(E_Linux_Dmabuf *dmabuf, size_t *num_formats)
 
    formats = E_NEW(int, num);
    EINA_SAFETY_ON_NULL_RETURN_VAL(formats, NULL);
-   
+
    if (!dmabuf->query_dmabuf_formats(dmabuf->egl_display, num, formats, &num))
      {
         ERR("fail to eglQueryDmaBufFormatsEXT");
@@ -285,12 +285,12 @@ e_linux_dmabuf_tbm_surface_get_from_buffer(struct ds_buffer *ds_buffer)
    tbm_surface_info_s info = {0, };
    tbm_bo bos[LINUX_DMABUF_MAX_PLANES] = {0, };
    off_t bos_size[LINUX_DMABUF_MAX_PLANES] = {0, };
-   E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+   E_Comp_Screen *comp_screen = e_comp_screen_get();
    int i = 0;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_get(), NULL);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen, NULL);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp_screen->bufmgr, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(comp_screen->bufmgr, NULL);
 
    if (!_dmabuf) return NULL;
 
@@ -312,12 +312,12 @@ e_linux_dmabuf_tbm_surface_get_from_buffer(struct ds_buffer *ds_buffer)
 
    for (i = 0; i < info.num_planes; i++)
      {
-        E_Comp_Screen *e_comp_screen = e_comp_screen_get();
+        E_Comp_Screen *comp_screen = e_comp_screen_get();
         info.planes[i].stride = ds_attributes->stride[i];
         info.planes[i].offset = ds_attributes->offset[i];
 
-        if (e_comp_screen)
-          bos[i] = tbm_bo_import_fd(e_comp_screen->bufmgr, ds_attributes->fd[i]);
+        if (comp_screen)
+          bos[i] = tbm_bo_import_fd(comp_screen->bufmgr, ds_attributes->fd[i]);
         EINA_SAFETY_ON_NULL_GOTO(bos[i], failed);
 
         bos_size[i] = lseek(ds_attributes->fd[i], 0, SEEK_END);
@@ -325,7 +325,7 @@ e_linux_dmabuf_tbm_surface_get_from_buffer(struct ds_buffer *ds_buffer)
      }
 
    for (i = 0; i < info.num_planes; i++)
-     { 
+     {
         if ((i + 1 ==  info.num_planes) || (bos[i] != bos[i + 1]))
           info.planes[i].size = bos_size[i] - info.planes[i].offset;
         else

diff --git a/src/include/e_comp.h b/src/include/e_comp.h
index b6db24b67fbcd7e4f1d9ef75d387c6c42b0be56f..0ff03226a90e9a6324801173c680038682eaf5c7 100644 (file)
--- a/src/include/e_comp.h
+++ b/src/include/e_comp.h
@@ -103,7 +103,7 @@ struct _E_Comp
       void *data;
    } autoclose;
 
-   E_Comp_Screen *e_comp_screen;
+   E_Comp_Screen *comp_screen;
 
    Eina_List      *updates;
    Eina_List      *post_updates;

diff --git a/src/include/e_comp_screen.h b/src/include/e_comp_screen.h
index 76a0995e876457a6bc922a6fc7c27c10396eea7c..a9da00bfb4082586e8e7f8ed09b233746a9a3bce 100644 (file)
--- a/src/include/e_comp_screen.h
+++ b/src/include/e_comp_screen.h
@@ -9,11 +9,11 @@
 
 typedef struct _E_Comp_Screen   E_Comp_Screen;
 
-E_API Eina_Bool  e_comp_screen_rotation_setting_set(E_Comp_Screen *e_comp_screen, int rotation);
+E_API Eina_Bool  e_comp_screen_rotation_setting_set(E_Comp_Screen *comp_screen, int rotation);
 E_API void       e_comp_screen_rotation_ignore_output_transform_send(E_Client *ec, Eina_Bool ignore);
 E_API Eina_Bool  e_comp_screen_available_video_formats_get(const tbm_format **formats, int *count);
 E_API void       e_comp_screen_keymap_set(struct xkb_context **ctx, struct xkb_keymap **map);
-E_API Eina_List *e_comp_screen_outputs_get(E_Comp_Screen *e_comp_screen);
+E_API Eina_List *e_comp_screen_outputs_get(E_Comp_Screen *comp_screen);
 
 EINTERN Eina_Bool e_comp_screen_prefer_gbm_check(void);
 

diff --git a/src/include/e_zone.h b/src/include/e_zone.h
index fd0c97b03244e0c21b6fb063babba1aadf7b6064..35d7ea8922b7b0dd6d39474fe4c39ada05ef678f 100644 (file)
--- a/src/include/e_zone.h
+++ b/src/include/e_zone.h
@@ -114,7 +114,7 @@ struct _E_Zone
    } orientation;
 
    E_Zone_Display_State display_state;
-   char                 *output_id; // same id we get from e_comp_screen so look it up there
+   char                 *output_id; // same id we get from comp_screen so look it up there
 
    Eina_List *obstacles;