src/e_mod_comp_screen.c

   1 #include "e.h"
   2 #include "e_mod_comp_shared_types.h"
   3 #include "e_mod_comp_atoms.h"
   4 #include "e_mod_comp_debug.h"
   5 #include "e_mod_comp.h"
   6 #include "e_mod_comp_screen.h"
   7
   8 /* local subsystem functions */
   9 static int       _screen_angle_get(Ecore_X_Window root);
  10 static void      _screen_lock(E_Comp *c);
  11 static void      _screen_unlock(E_Comp *c);
  12 static Eina_Bool _screen_lock_timeout(void *data);
  13
  14 /* externally accessible functions */
  15 EAPI Eina_Bool
  16 e_mod_comp_screen_rotation_init(E_Comp_Screen_Rotation *r,
  17                                 Ecore_X_Window root,
  18                                 int w, int h)
  19 {
  20    E_CHECK_RETURN(r, 0);
  21    E_CHECK_RETURN(root, 0);
  22    E_CHECK_RETURN((w > 0), 0);
  23    E_CHECK_RETURN((h > 0), 0);
  24
  25    r->enabled = EINA_FALSE;
  26    r->scr_w = w;
  27    r->scr_h = h;
  28    r->angle = _screen_angle_get(root);
  29
  30    if (0 != r->angle)
  31      {
  32         r->enabled = EINA_TRUE;
  33         if (0 != (r->angle % 180))
  34           {
  35              r->scr_w = h;
  36              r->scr_h = w;
  37           }
  38      }
  39    return EINA_TRUE;
  40 }
  41
  42 EAPI Eina_Bool
  43 e_mod_comp_screen_lock_init(E_Comp_Screen_Lock *l)
  44 {
  45    E_CHECK_RETURN(l, 0);
  46    l->locked = EINA_FALSE;
  47    l->timeout = NULL;
  48    return EINA_FALSE;
  49 }
  50
  51 EAPI Eina_Bool
  52 e_mod_comp_screen_lock_handler_message(Ecore_X_Event_Client_Message *ev)
  53 {
  54    E_Comp *c;
  55    E_CHECK_RETURN(ev, 0);
  56    E_CHECK_RETURN(_comp_mod->conf->use_lock_screen, 0);
  57
  58    c = e_mod_comp_find(ev->win);
  59    E_CHECK_RETURN(c, 0);
  60
  61    if (ev->data.l[0] == 0) _screen_unlock(c);
  62    else if (ev->data.l[0] == 1) _screen_lock(c);
  63
  64    return EINA_TRUE;
  65 }
  66
  67 EAPI void
  68 e_mod_comp_screen_lock_func(void *data,
  69                             E_Manager *man __UNUSED__)
  70 {
  71    E_Comp *c = (E_Comp *)data;
  72    E_CHECK(c);
  73    _screen_lock(c);
  74 }
  75
  76 EAPI void
  77 e_mod_comp_screen_unlock_func(void *data,
  78                               E_Manager *man __UNUSED__)
  79 {
  80    E_Comp *c = (E_Comp *)data;
  81    E_CHECK(c);
  82    _screen_unlock(c);
  83 }
  84
  85 /* local subsystem functions */
  86 static int
  87 _screen_angle_get(Ecore_X_Window root)
  88 {
  89    int ret = -1, ang = 0;
  90    unsigned int val = 0;
  91    Ecore_X_Display* dpy = ecore_x_display_get();
  92    E_CHECK_RETURN(dpy, 0);
  93    E_CHECK_RETURN(ATOM_X_SCREEN_ROTATION, 0);
  94
  95    ret = ecore_x_window_prop_card32_get
  96            (root, ATOM_X_SCREEN_ROTATION, &val, 1);
  97    E_CHECK_RETURN((ret > 0), 0);
  98
  99    switch (val)
 100      {
 101       case  1: ang =   0; break;
 102       case  2: ang =  90; break;
 103       case  4: ang = 180; break;
 104       case  8: ang = 270; break;
 105       default: ang =   0; break;
 106      }
 107
 108    return ang;
 109 }
 110
 111 static void
 112 _screen_lock(E_Comp *c)
 113 {
 114    Eina_List *l;
 115    E_Comp_Canvas *canvas;
 116
 117    E_CHECK(_comp_mod);
 118    E_CHECK(_comp_mod->conf->use_lock_screen);
 119    E_CHECK(c->lock.locked != 1);
 120    E_CHECK(!c->lock.timeout);
 121
 122    if (!_comp_mod->conf->lock_fps)
 123      {
 124         EINA_LIST_FOREACH(c->canvases, l, canvas)
 125           {
 126              if (!canvas) continue;
 127              if (_comp_mod->conf->use_hwc)
 128                {
 129                   if (c->hwcomp_funcs.set_full_composite)
 130                      c->hwcomp_funcs.set_full_composite(canvas->hwcomp);
 131 #if HWC_ROTATION_PATCH
 132 #else
 133                   if (c->hwcomp_funcs.update_null_set_drawables)
 134                      c->hwcomp_funcs.update_null_set_drawables(canvas->hwcomp);
 135 #endif
 136                }
 137
 138              ecore_evas_manual_render_set(canvas->ee, 1);
 139           }
 140      }
 141
 142    c->lock.timeout = ecore_timer_add
 143                        (_comp_mod->conf->max_lock_screen_time,
 144                        _screen_lock_timeout, c);
 145
 146    c->lock.locked = EINA_TRUE;
 147 }
 148
 149 static void
 150 _screen_unlock(E_Comp *c)
 151 {
 152    Eina_List *l;
 153    E_Comp_Canvas *canvas;
 154    E_Comp_Win *cw;
 155
 156    E_CHECK(_comp_mod);
 157    E_CHECK(_comp_mod->conf->use_lock_screen);
 158    E_CHECK(c->lock.locked);
 159    if (c->lock.timeout)
 160      {
 161         ecore_timer_del(c->lock.timeout);
 162         c->lock.timeout = NULL;
 163      }
 164
 165    // remove all cw->update_timeout
 166    EINA_INLIST_REVERSE_FOREACH(c->wins, cw)
 167      {
 168         if ((!cw->visible) || (cw->input_only) || (cw->invalid))
 169            continue;
 170         if (cw->counter && cw->update_timeout)
 171           {
 172              cw->update = 0;
 173              e_mod_comp_win_damage_timeout((void*)cw);
 174           }
 175      }
 176
 177    // clear c->update_job
 178    if (c->update_job)
 179      {
 180         ecore_job_del(c->update_job);
 181         c->update_job = NULL;
 182         c->render_overflow = 0;
 183      }
 184
 185    // clear c->updates
 186    if (c->updates) e_mod_comp_cb_update(c);
 187
 188    EINA_LIST_FOREACH(c->canvases, l, canvas)
 189      {
 190         if (!canvas) continue;
 191
 192         if ((canvas->nocomp.mode == E_NOCOMP_MODE_NONE)
 193             || (canvas->nocomp.mode == E_NOCOMP_MODE_PREPARE))
 194           {
 195              ecore_evas_manual_render(canvas->ee);
 196
 197              if (!_comp_mod->conf->lock_fps)
 198                ecore_evas_manual_render_set(canvas->ee, 0);
 199           }
 200      }
 201
 202    c->lock.locked = 0;
 203 }
 204
 205 static Eina_Bool
 206 _screen_lock_timeout(void *data)
 207 {
 208    E_Comp *c = (E_Comp*)data;
 209    E_CHECK_RETURN(c, 0);
 210    _screen_unlock(c);
 211    return EINA_TRUE;
 212 }