diff --git a/e_effects.c b/e_effects.c index e63fb6b..af11451 100644 --- a/e_effects.c +++ b/e_effects.c @@ -10,12 +10,13 @@ static Ecore_X_Window input_window = 0; static Eina_List *effects_windows = NULL; static Eina_List *handlers = NULL; static Ecore_Animator *anim = NULL; -static double anim_time = 0.f; +static double anim_time = 0.0f; static double anim_length = 0.33f; static int revert = 0; static Ecore_Evas *canvas = NULL; static E_Zone *ref_zone = NULL; static Evas *zone_evas = NULL; +static Evas_Object *bg = NULL; static void _place_windows(); static int _e_effects_cb_key_down(void *data, int type, void *event); @@ -34,7 +35,7 @@ EAPI int e_effects_shutdown(void) { if (effects_windows) - _e_revert_done(); + _e_revert_done(); return 1; } @@ -42,18 +43,16 @@ EAPI void e_effects_apply(E_Zone * zone) { E_Desk *desk; - E_Border_List *bl; - E_Border *border; if (!ecore_x_composite_query()) - return; + return; if (effects_windows) - return; + return; if (canvas) - return; - + return; + E_OBJECT_CHECK(zone); desk = e_desk_current_get(zone); bl = e_container_border_list_first(desk->zone->container); @@ -63,13 +62,65 @@ e_effects_apply(E_Zone * zone) e_object_ref(E_OBJECT(zone)); canvas = e_canvas_new(E_EVAS_ENGINE_SOFTWARE_X11, zone->container->win, zone->x, zone->y, zone->w, zone->h, 1, 1, NULL); - + /* RR: set title, name+class here, not per object */ + ecore_evas_name_class_set(canvas, "E", "e_effects_object"); + ecore_evas_title_set(canvas, "E Effects"); + /* Yank the background from the zone and put it in our app instead * of a costly copy :-D. */ - if (zone_evas) + /* RR: oh so bad. so so so bad. sooooooooooooo bad. SOOOOOOOOOOOOOOOOO bad. + * i don't know where to begin. 1. where are evas_object_release() and + * evas_object_inject() defined in any evas public header? they are not. + * they are not and never were public api calls. you should NEVER call + * non-exported calls. in fact if evas is compiled with visibility hidden + * (internal symbols removed from the symbol table) this code wont even + * work. you'll get symbol lookup errors on loading of the module. so + * first it's just bad to use internal symbols of a library. NEVER do it. + * 2. there isn't a costly copy - u simply load the same edje file as + * wallpaper is configured for that desktop... if that's what you want. + * look at wallpaper config dialog code. create edje object, then set + * the file+group. it already has loaded and cached these objects and + * files. there isn't an expensive copy. a new instantiation of runtime + * data for the ejde object structure will be created from the already + * in-ram dat loaded from disk. the images are laready loaded and in ram + * for the wallpaper. they will simply be re-used from ram "as-is". a quick + * hash lookup and bingo. if, in the event, data cannot be copied (different + * formats, has been thrown away and different size cached) you would need + * to re-load anywa to get the original data back, so in the end the + * most efficent AND correct way is to re-create. not to mention objects + * are per canvas. if the engin3es vary each object can hold enigne private + * data. this will crash evas and the engines if you go moving an object + * from one canvas to another. even if they have the same engine, they may + * cache canvas specific data etc. this is all wrong is many ways. + * if (zone_evas) + * { + * evas_object_release(zone->bg_object, 0); + * evas_object_inject(zone->bg_object, ecore_evas_get(canvas)); + * } + */ + /* RR: correct code here short enough to give and an example */ { - evas_object_release(zone->bg_object, 0); - evas_object_inject(zone->bg_object, ecore_evas_get(canvas)); + const char *bgfile, *f; + Evas_Object *o; + + bgfile = e_bg_file_get(zone->container->num, zone->num, + e_desk_current_get(zone)->x, + e_desk_current_get(zone)->y); + o = edje_object_add(ecore_evas_get(canvas)); + evas_object_move(o, 0, 0); + evas_object_resize(o, zone->w, zone->h); + if (bgfile) + { + edje_object_file_set(o, bgfile, "e/desktop/background"); + } + else + { + f = e_theme_edje_file_get("base/theme/backgrounds", + "e/desktop/background"); + edje_object_file_set(o, f, "e/desktop/background"); + } + evas_object_show(o); + bg = o; } /* Build the list of affected windows */ @@ -79,23 +130,17 @@ e_effects_apply(E_Zone * zone) if ((border->desk == desk) && (!border->iconic)) { Eina_List *ll; - E_Effects_Object *fx; - - int x, y; - - int w, h; + int x, y, w, h; fx = e_effects_object_new(canvas, border, border->x, border->y, border->w, border->h); - effects_windows = eina_list_append(effects_windows, fx); } } - _place_windows(zone->w, zone->h); - + /* Animations */ revert = 0; if (!anim) @@ -114,44 +159,43 @@ e_effects_apply(E_Zone * zone) e_effects_revert(); return; } - + handlers = eina_list_append - (handlers, ecore_event_handler_add - (ECORE_EVENT_KEY_DOWN, _e_effects_cb_key_down, NULL)); + (handlers, ecore_event_handler_add + (ECORE_EVENT_KEY_DOWN, _e_effects_cb_key_down, NULL)); handlers = eina_list_append - (handlers, ecore_event_handler_add - (ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_effects_cb_mouse_down, NULL)); + (handlers, ecore_event_handler_add + (ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_effects_cb_mouse_down, NULL)); handlers = eina_list_append - (handlers, ecore_event_handler_add - (ECORE_EVENT_MOUSE_WHEEL, _e_effects_cb_mouse_wheel, NULL)); + (handlers, ecore_event_handler_add + (ECORE_EVENT_MOUSE_WHEEL, _e_effects_cb_mouse_wheel, NULL)); } EAPI void e_effects_revert() { Eina_List *l; - E_Effects_Object *data; - + if (!effects_windows) - return; + return; /* Animations */ EINA_LIST_FOREACH(effects_windows, l, data) - { - data->src_x = data->x; - data->dst_x = data->border->x; - data->delta_x = (float)(data->dst_x - data->x) / anim_length; - data->src_y = data->y; - data->dst_y = data->border->y; - data->delta_y = (float)(data->dst_y - data->y) / anim_length; - data->src_w = data->w; - data->dst_w = data->border->w; - data->delta_w = (float)(data->dst_w - data->w) / anim_length; - data->src_h = data->h; - data->dst_h = data->border->h; - data->delta_h = (float)(data->dst_h - data->h) / anim_length; - } + { + data->src_x = data->x; + data->dst_x = data->border->x - data->border->zone->x; + data->delta_x = (float)(data->dst_x - data->x) / anim_length; + data->src_y = data->y; + data->dst_y = data->border->y - data->border->zone->y; + data->delta_y = (float)(data->dst_y - data->y) / anim_length; + data->src_w = data->w; + data->dst_w = data->border->w; + data->delta_w = (float)(data->dst_w - data->w) / anim_length; + data->src_h = data->h; + data->dst_h = data->border->h; + data->delta_h = (float)(data->dst_h - data->h) / anim_length; + } revert = 1; if (!anim) { @@ -164,35 +208,26 @@ static void _place_windows(int zone_width, int zone_height) { E_Effects_Object *data, *data2; - Eina_List *l, *l2; - int desk_x = 0; - int desk_y = 0; - int desk_w = zone_width; - int desk_h = zone_height; - int done = 0; - float scale = 1.f; - float scale_x, scale_y; - int collision = 1; /* Initialize the windows */ EINA_LIST_FOREACH(effects_windows, l, data) - { - e_effects_object_show(data); - data->dst_x = data->src_x = data->border->x; - data->dst_y = data->src_y = data->border->y; - data->dst_w = data->src_w = data->border->w; - data->dst_h = data->src_h = data->border->h; - } - + { + e_effects_object_show(data); + data->dst_x = data->src_x = data->border->x - data->border->zone->x; + data->dst_y = data->src_y = data->border->y - data->border->zone->y; + data->dst_w = data->src_w = data->border->w; + data->dst_h = data->src_h = data->border->h; + } + while (!done) { /* TODO @@ -200,120 +235,116 @@ _place_windows(int zone_width, int zone_height) */ done = 1; EINA_LIST_FOREACH(effects_windows, l, data) - { - EINA_LIST_FOREACH(effects_windows, l2, data2) - { - collision = 1; - - /* check for a collision */ - if (data == data2 || - data->dst_x + data->dst_w <= data2->dst_x || - data->dst_x >= data2->dst_x + data2->dst_w || - data->dst_y + data->dst_h <= data2->dst_y || - data->dst_y >= data2->dst_y + data2->dst_h) - { - collision = 0; - } - - /* if there is a collision calculate the centre position - * and move the windows to the side closest to the center - * of the screen which doesn't have a collision. - */ - if (collision) - { - float shortest_distance_squared = FLT_MAX; - - float distance_squared; - - int x, y; - - int fin_x = data2->dst_x; - - int fin_y = data2->dst_y; - - /* check bottom */ - x = data2->dst_x; - y = data->dst_y + data->dst_h; - distance_squared = (x - data2->src_x) * (x - data2->src_x) - + (y - data2->src_y) * (y - data2->src_y); - if (distance_squared < shortest_distance_squared && - (data->dst_x + data->dst_w <= x || - data->dst_x >= x + data2->dst_w || - data->dst_y + data->dst_h <= y || - data->dst_y >= y + data2->dst_h)) - { - shortest_distance_squared = distance_squared; - fin_x = x; - fin_y = y; - } - - /* check top */ - x = data2->dst_x; - y = data->dst_y - data2->dst_h; - distance_squared = (x - data2->src_x) * (x - data2->src_x) - + (y - data2->src_y) * (y - data2->src_y); - if (distance_squared < shortest_distance_squared && - (data->dst_x + data->dst_w <= x || - data->dst_x >= x + data2->dst_w || - data->dst_y + data->dst_h <= y || - data->dst_y >= y + data2->dst_h)) - { - shortest_distance_squared = distance_squared; - fin_x = x; - fin_y = y; - } - - /* check right */ - x = data->dst_x + data->dst_w; - y = data2->dst_y; - distance_squared = (x - data2->src_x) * (x - data2->src_x) - + (y - data2->src_y) * (y - data2->src_y); - if (distance_squared < shortest_distance_squared && - (data->dst_x + data->dst_w <= x || - data->dst_x >= x + data2->dst_w || - data->dst_y + data->dst_h <= y || - data->dst_y >= y + data2->dst_h)) - { - shortest_distance_squared = distance_squared; - fin_x = x; - fin_y = y; - } - - /* check left */ - x = data->dst_x - data2->dst_w; - y = data2->dst_y; - distance_squared = (x - data2->src_x) * (x - data2->src_x) - + (y - data2->src_y) * (y - data2->src_y); - if (distance_squared < shortest_distance_squared && - (data->dst_x + data->dst_w <= x || - data->dst_x >= x + data2->dst_w || - data->dst_y + data->dst_h <= y || - data->dst_y >= y + data2->dst_h)) - { - shortest_distance_squared = distance_squared; - fin_x = x; - fin_y = y; - } - - if (fin_x < desk_x) - desk_x = fin_x; - if (fin_y < desk_y) - desk_y = fin_y; - if (fin_x + data2->dst_w > desk_w) - desk_w = fin_x + data2->dst_w; - if (fin_y + data2->dst_h > desk_h) - desk_h = fin_y + data2->dst_h; - - data2->dst_x = fin_x; - data2->dst_y = fin_y; - } - } - } + { + EINA_LIST_FOREACH(effects_windows, l2, data2) + { + collision = 1; + + /* check for a collision */ + if (data == data2 || + data->dst_x + data->dst_w <= data2->dst_x || + data->dst_x >= data2->dst_x + data2->dst_w || + data->dst_y + data->dst_h <= data2->dst_y || + data->dst_y >= data2->dst_y + data2->dst_h) + { + collision = 0; + } + + /* if there is a collision calculate the centre position + * and move the windows to the side closest to the center + * of the screen which doesn't have a collision. + */ + if (collision) + { + float shortest_distance_squared = FLT_MAX; + float distance_squared; + int x, y; + int fin_x = data2->dst_x; + int fin_y = data2->dst_y; + + /* check bottom */ + x = data2->dst_x; + y = data->dst_y + data->dst_h; + distance_squared = (x - data2->src_x) * (x - data2->src_x) + + (y - data2->src_y) * (y - data2->src_y); + if (distance_squared < shortest_distance_squared && + (data->dst_x + data->dst_w <= x || + data->dst_x >= x + data2->dst_w || + data->dst_y + data->dst_h <= y || + data->dst_y >= y + data2->dst_h)) + { + shortest_distance_squared = distance_squared; + fin_x = x; + fin_y = y; + } + + /* check top */ + x = data2->dst_x; + y = data->dst_y - data2->dst_h; + distance_squared = (x - data2->src_x) * (x - data2->src_x) + + (y - data2->src_y) * (y - data2->src_y); + if (distance_squared < shortest_distance_squared && + (data->dst_x + data->dst_w <= x || + data->dst_x >= x + data2->dst_w || + data->dst_y + data->dst_h <= y || + data->dst_y >= y + data2->dst_h)) + { + shortest_distance_squared = distance_squared; + fin_x = x; + fin_y = y; + } + + /* check right */ + x = data->dst_x + data->dst_w; + y = data2->dst_y; + distance_squared = (x - data2->src_x) * (x - data2->src_x) + + (y - data2->src_y) * (y - data2->src_y); + if (distance_squared < shortest_distance_squared && + (data->dst_x + data->dst_w <= x || + data->dst_x >= x + data2->dst_w || + data->dst_y + data->dst_h <= y || + data->dst_y >= y + data2->dst_h)) + { + shortest_distance_squared = distance_squared; + fin_x = x; + fin_y = y; + } + + /* check left */ + x = data->dst_x - data2->dst_w; + y = data2->dst_y; + distance_squared = (x - data2->src_x) * (x - data2->src_x) + + (y - data2->src_y) * (y - data2->src_y); + if (distance_squared < shortest_distance_squared && + (data->dst_x + data->dst_w <= x || + data->dst_x >= x + data2->dst_w || + data->dst_y + data->dst_h <= y || + data->dst_y >= y + data2->dst_h)) + { + shortest_distance_squared = distance_squared; + fin_x = x; + fin_y = y; + } + + if (fin_x < desk_x) + desk_x = fin_x; + if (fin_y < desk_y) + desk_y = fin_y; + if (fin_x + data2->dst_w > desk_w) + desk_w = fin_x + data2->dst_w; + if (fin_y + data2->dst_h > desk_h) + desk_h = fin_y + data2->dst_h; + + data2->dst_x = fin_x; + data2->dst_y = fin_y; + } + } + } } - + scale_x = (float)zone_width / (float)(desk_w - desk_x); scale_y = (float)zone_height / (float)(desk_h - desk_y); - + if (scale_x < scale_y) { scale = scale_x; @@ -322,25 +353,25 @@ _place_windows(int zone_width, int zone_height) { scale = scale_y; } - + /* set up the animation values */ EINA_LIST_FOREACH(effects_windows, l, data) - { - data->dst_x -= desk_x; - data->dst_y -= desk_y; - data->dst_x *= scale; - data->dst_y *= scale; - data->dst_w *= scale; - data->dst_h *= scale; - - data->delta_x = (data->dst_x - data->src_x) / anim_length; - data->delta_y = (data->dst_y - data->src_y) / anim_length; - data->delta_w = (data->dst_w - data->src_w) / anim_length; - data->delta_h = (data->dst_h - data->src_h) / anim_length; - - /* hack so the objects get dirtied and drawn */ - data->src_x++; - } + { + data->dst_x -= desk_x; + data->dst_y -= desk_y; + data->dst_x *= scale; + data->dst_y *= scale; + data->dst_w *= scale; + data->dst_h *= scale; + + data->delta_x = (data->dst_x - data->src_x) / anim_length; + data->delta_y = (data->dst_y - data->src_y) / anim_length; + data->delta_w = (data->dst_w - data->src_w) / anim_length; + data->delta_h = (data->dst_h - data->src_h) / anim_length; + + /* hack so the objects get dirtied and drawn */ + data->src_x++; + } } static int @@ -350,7 +381,7 @@ _e_effects_cb_key_down(void *data, int type, void *event) ev = event; if (!strcmp(ev->key, "space")) - e_effects_revert(); + e_effects_revert(); return 1; } @@ -358,39 +389,34 @@ static int _e_effects_cb_mouse_down(void *unused, int type, void *event) { Evas *evas; - Eina_List *l; - Evas_Object *obj; - E_Effects_Object *fx; - E_Effects_Object *fx_under_mouse = NULL; - Ecore_Event_Mouse_Button *ev; evas = ecore_evas_get(canvas); if (!evas) - return 0; - + return 0; + ev = (Ecore_Event_Mouse_Button *) event; if (!ev) - return 0; - + return 0; + /* * The following doesn't work for some reason * so we do it manually. - obj = evas_object_top_at_pointer_get(evas); + * obj = evas_object_top_at_pointer_get(evas); */ EINA_LIST_FOREACH(effects_windows, l, fx) - { - if (fx->x <= ev->x && - fx->y <= ev->y && fx->x + fx->w >= ev->x && fx->y + fx->h >= ev->y) - { - fx_under_mouse = fx; - } - } - + { + if (fx->x <= ev->x && + fx->y <= ev->y && fx->x + fx->w >= ev->x && fx->y + fx->h >= ev->y) + { + fx_under_mouse = fx; + } + } + if (fx_under_mouse) { evas_object_raise(fx_under_mouse->img); @@ -413,52 +439,45 @@ static int _e_effects_animate_cb(void *data) { Eina_List *fxs = NULL; - Eina_List *l; - E_Effects_Object *fx; - int done = 1; - double delta = ecore_loop_time_get() - anim_time; - + if (!(fxs = data)) - return 1; - + return 1; + if (delta > anim_length) { EINA_LIST_FOREACH(fxs, l, fx) - { - e_effects_object_move_resize(fx, - fx->dst_x, fx->dst_y, - fx->dst_w, fx->dst_h); - } - + { + e_effects_object_move_resize(fx, + fx->dst_x, + fx->dst_y, + fx->dst_w, fx->dst_h); + } + if (revert) { _e_revert_done(); revert = 0; } - + anim = NULL; return 0; } else { EINA_LIST_FOREACH(fxs, l, fx) - { - int x = fx->src_x + (delta * fx->delta_x); - - int y = fx->src_y + (delta * fx->delta_y); - - int w = fx->src_w + (delta * fx->delta_w); - - int h = fx->src_h + (delta * fx->delta_h); - - e_effects_object_move_resize(fx, x, y, w, h); - } + { + int x = fx->src_x + (delta * fx->delta_x); + int y = fx->src_y + (delta * fx->delta_y); + int w = fx->src_w + (delta * fx->delta_w); + int h = fx->src_h + (delta * fx->delta_h); + + e_effects_object_move_resize(fx, x, y, w, h); + } } - return 1; } @@ -472,38 +491,41 @@ _e_revert_done() /* Restore the background to the zone. */ if (zone_evas) { - evas_object_release(ref_zone->bg_object, 0); - evas_object_inject(ref_zone->bg_object, zone_evas); + /* RR: again - as per comments above with these calls. don't. + * use them. bad. + * evas_object_release(ref_zone->bg_object, 0); + * evas_object_inject(ref_zone->bg_object, zone_evas); + */ zone_evas = NULL; } - e_object_unref(E_OBJECT(ref_zone)); ref_zone = NULL; } - + if (canvas) { e_canvas_del(canvas); ecore_evas_free(canvas); canvas = NULL; + /* RR: bg to null to as it gets deleted with the canvas */ + bg = NULL; } - + /* Restore inputs */ while (handlers) { ecore_event_handler_del(handlers->data); handlers = eina_list_remove_list(handlers, handlers); } - + e_grabinput_release(input_window, input_window); input_window = 0; - + /* Restore the original windows */ while (effects_windows) { data = effects_windows->data; effects_windows = eina_list_remove(effects_windows, data); - /* free memory */ e_object_del(E_OBJECT(data)); } diff --git a/e_effects_object.c b/e_effects_object.c index 6fc07a3..8d12185 100644 --- a/e_effects_object.c +++ b/e_effects_object.c @@ -4,9 +4,14 @@ #include #include "e_effects_object.h" +/* RR: a smart object may have been nicer here. then evas_object_move/resize/show + * etc. would "just work" and it can be swallowed etc. i would say this is + * adequate, but not "optimal". i'd add points for optimal :) + */ + static void _e_effects_object_free(E_Effects_Object * fx); static void _e_effects_object_draw(E_Effects_Object * fx); -static int _e_effects_x_error(Display * dpy, XErrorEvent * xerror); +/* RR: static int _e_effects_x_error(Display * dpy, XErrorEvent * xerror); */ static void _native_surface_update(E_Effects_Object * fx); static int _damage_cb(void *data, int type, void *event); @@ -16,8 +21,17 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y, { E_Effects_Object *fx; - XSetErrorHandler(_e_effects_x_error); - + /* RR: this sets the handler - but on shutdown on the module - it is not set back! + * no wonder things crtash. the rfunction on shutdown doesn't "exist" anymore. + * (technically this depends if the module is unloaded vs disabled but for + * now lets just say its unloaded - that means .so is dlcose()ed. the memory + * where this function lives exists no more. so at a minimum the error handler + * should be reset to what it was. as such ecore_x instals a "forgiving" + * error handler that just allows for errors and moves on to avoid the wm + * from crashing and exiting with xlib's default error handler. disable this + * as it serves no useful function + * XSetErrorHandler(_e_effects_x_error); + */ fx = E_OBJECT_ALLOC(E_Effects_Object, E_EFFECTS_OBJECT_TYPE, _e_effects_object_free); @@ -32,9 +46,12 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y, fx->h = h; fx->evas = ecore_evas_get(fx->ecore_evas); - ecore_evas_name_class_set(fx->ecore_evas, "E", "e_effects_object"); - ecore_evas_title_set(fx->ecore_evas, "E Effects"); - + /* RR: why set it here per object?. do it in e_effects.c where canvas is + * created + * ecore_evas_name_class_set(fx->ecore_evas, "E", "e_effects_object"); + * ecore_evas_title_set(fx->ecore_evas, "E Effects"); + */ + fx->border = border; fx->img = evas_object_image_add(fx->evas); evas_object_image_filled_set(fx->img, 1); @@ -47,7 +64,6 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y, ecore_event_handler_add (ECORE_X_EVENT_DAMAGE_NOTIFY, _damage_cb, fx)); - return fx; } @@ -137,17 +153,19 @@ _e_effects_object_draw(E_Effects_Object * fx) _native_surface_update(fx); } -static int -_e_effects_x_error(Display * dpy, XErrorEvent * xerror) -{ - char buf[PATH_MAX]; - - if (XGetErrorText(dpy, xerror->error_code, buf, PATH_MAX)) - { - fprintf(stderr, "X ERROR %5d: %s\n", xerror->error_code, buf); - } - return 1; -} +/* RR: + * static int + * _e_effects_x_error(Display * dpy, XErrorEvent * xerror) + * { + * char buf[PATH_MAX]; + * + * if (XGetErrorText(dpy, xerror->error_code, buf, PATH_MAX)) + * { + * fprintf(stderr, "X ERROR %5d: %s\n", xerror->error_code, buf); + * } + * return 1; + * } + */ static void _native_surface_update(E_Effects_Object * fx) @@ -157,18 +175,42 @@ _native_surface_update(E_Effects_Object * fx) XImage *xim; evas_object_image_size_get(fx->img, &iw, &ih); + /* RR: get geometry. this is a round-trip (send message to server, wait + * for reply). there is no need. damaga event will have damaged region + * geometry. get that. */ ecore_x_drawable_geometry_get(fx->pixmap, NULL, NULL, &pw, &ph); + /* RR: XGetImage? ewww. slow as balls. this 1. copies from video memory to + * system memory (server-side), then copies via a socket (unix or tcp) from + * xserver to client, then is copied from the client buffer to the ximage + * memory data buffer. all those copies... are BAD. not to mention, on + * update you copy the WHOLE pixmap. even if just a small region changed. + * damage events deliver the region of the pixmap that changed (and on + * first draw all of it will obviously). + * + * solution here is: + * 1. XGetImage only if XShmGetImage fails. + * 2. only get the regions that changed. + * 3. only copy the changed regions to the image + * 4. handle any format conversions if pixmap is not ARGB32 (same as + * evas image) + * + * btw - i'm willing to let the region updatye slip as this was specifically + * "expose" and as such u will get a whole window contents each time. the + * shm stuff tho i think is a must. any windows animating/redrawing tho will + * cause some nasty cpu usage and slowness by getting the whole window + */ xim = XGetImage(ecore_x_display_get(), fx->pixmap, 0, 0, pw, ph, AllPlanes, ZPixmap); - evas_object_size_hint_request_set(evas_object_smart_parent_get(fx->img), pw, - ph); - - evas_object_image_data_update_add(fx->img, 0, 0, iw, ih); + /* RR: move this up here - abore early if image get fails */ if (!xim) { printf("No X Image :-(\n"); return; } + evas_object_size_hint_request_set(evas_object_smart_parent_get(fx->img), pw, + ph); + + evas_object_image_data_update_add(fx->img, 0, 0, iw, ih); if ((pw != iw) || (ph != ih)) { @@ -197,6 +239,30 @@ _native_surface_update(E_Effects_Object * fx) * Make sure they are both ARGB instead of assuming if * they are not, do something smart like a convertion. */ + /* RR: yet another copy :( remember. pixel data is huge. especially + * when updates happen. excess copies KILL system performance. EFL + * generally is fast because it avoids copies of big data. it + * wastes some time with extra structs and alloc/dealloc of them + * etc. but focuses on the big meat. this pipeline from above + * is pretty bad performance-wise and it's noticable. a long + * pause before the expose window open. this was the idea of the + * in -evas native surface code you didn't manage to get going + * in time. try and unify the pixmap and the image data to + * minimise copies (eg for software enigne turn the image data + * into a sysvshm segment and to gets to the right section with + * the right bytes_per_line etc. to make sure you "fill in" just + * the updated regions. if the visual is not argb32 a copy ( + * conversion) is needed, but u still use a small sysvshm image + * for just that update, for gl and xrender this get and + * possible conversion can be avoided by using the pixmap directly + * in xrender and with GL the texturefrompixmap extention if + * available (if not - do the same as software code, then upload + * sub-texture changes. no need to make the whole image a shm + * segment here as the upload will take place anyway). + * + * even if you got just 1 engine working right (software) and + * gl/xrender (etc.) not working yet, that'd have been good! :) + */ memcpy(data, xim->data, size); #if 0 Evas_Native_Surface ns; @@ -220,15 +286,15 @@ static int _damage_cb(void *data, int type, void *event) { E_Effects_Object *fx; - Ecore_X_Event_Damage *ev; if (!(fx = data)) - return 1; + return 1; if (!(ev = event)) - return 1; + return 1; + /* RR: you don't use the damage region (x, y, w, h)!!! */ if (fx->border->win != ev->drawable) - return 1; + return 1; _native_surface_update(fx); return 1; } diff --git a/e_effects_object.h b/e_effects_object.h index 74baad3..39e96c9 100644 --- a/e_effects_object.h +++ b/e_effects_object.h @@ -15,14 +15,16 @@ #include #include -typedef struct _E_Effects_Object +typedef struct _E_Effects_Object E_Effects_Object; + +struct _E_Effects_Object { E_Object e_obj_inherit; - + Eina_List *handlers; int x, y, w, h; int visible; - + int src_x, src_y; int dst_x, dst_y; int src_w, src_h; @@ -36,7 +38,7 @@ typedef struct _E_Effects_Object Evas_Object *img; Ecore_X_Pixmap pixmap; Ecore_X_Damage damage; -} E_Effects_Object; +}; EAPI E_Effects_Object *e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y, int w, int h); diff --git a/e_mod_main.c b/e_mod_main.c index d543f25..70a5b43 100644 --- a/e_mod_main.c +++ b/e_mod_main.c @@ -2,22 +2,18 @@ #include "e_mod_main.h" /* actual module specifics */ -static void _e_mod_action_exebuf_cb(E_Object * obj, const char *params); - +static void _e_mod_action_effects_cb(E_Object * obj, const char *params); static int _e_mod_run_defer_cb(void *data); - static void _e_mod_run_cb(void *data, E_Menu * m, E_Menu_Item * mi); - static void _e_mod_menu_add(void *data, E_Menu * m); static E_Module *conf_module = NULL; - static E_Action *act = NULL; /* module setup */ EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, - "Effects" + "Effects" }; EAPI void * @@ -25,22 +21,27 @@ e_modapi_init(E_Module * m) { conf_module = m; - if (!e_config->use_composite) - { - e_config->use_composite = 1; - e_config_save_queue(); - } - + /* RR: this is wrong i think. e_config->use_composite just makes e use + * ARGB32 visuals (thus an alpha channel instead of shaped window). it + * doesn't turn on compositing (composite manager) in any way, so disable. + * there isn't a NEED to turn it on + * if (!e_config->use_composite) + * { + * e_config->use_composite = 1; + * e_config_save_queue(); + * } + */ + e_effects_init(); + /* add module supplied action */ act = e_action_add("effects"); if (act) { - act->func.go = _e_mod_action_exebuf_cb; - e_action_predef_name_set("Launch", "Effects", "effects", NULL, NULL, 0); + act->func.go = _e_mod_action_effects_cb; + e_action_predef_name_set(D_("Window : List"), D_("Effects"), "effects", + NULL, NULL, 0); } - e_module_delayed_set(m, 1); - e_effects_init(); return m; } @@ -50,7 +51,7 @@ e_modapi_shutdown(E_Module * m) /* remove module-supplied menu additions */ if (act) { - e_action_predef_name_del("Launch", "Effects"); + e_action_predef_name_del(D_("Window : List"), D_("Effects")); e_action_del("effects"); act = NULL; } @@ -68,25 +69,25 @@ e_modapi_save(E_Module * m) /* action callback */ static void -_e_mod_action_exebuf_cb(E_Object * obj, const char *params) +_e_mod_action_effects_cb(E_Object * obj, const char *params) { E_Zone *zone = NULL; if (obj) { if (obj->type == E_MANAGER_TYPE) - zone = e_util_zone_current_get((E_Manager *) obj); + zone = e_util_zone_current_get((E_Manager *) obj); else if (obj->type == E_CONTAINER_TYPE) - zone = e_util_zone_current_get(((E_Container *) obj)->manager); + zone = e_util_zone_current_get(((E_Container *) obj)->manager); else if (obj->type == E_ZONE_TYPE) - zone = e_util_zone_current_get(((E_Zone *) obj)->container->manager); + zone = e_util_zone_current_get(((E_Zone *) obj)->container->manager); else - zone = e_util_zone_current_get(e_manager_current_get()); + zone = e_util_zone_current_get(e_manager_current_get()); } - + if (!zone) - zone = e_util_zone_current_get(e_manager_current_get()); - + zone = e_util_zone_current_get(e_manager_current_get()); + if (zone) - e_effects_apply(zone); + e_effects_apply(zone); } diff --git a/e_mod_main.h b/e_mod_main.h index 4a83541..1db27df 100644 --- a/e_mod_main.h +++ b/e_mod_main.h @@ -1,12 +1,11 @@ #ifndef E_MOD_MAIN_H #define E_MOD_MAIN_H -EAPI extern E_Module_Api e_modapi; +#define D_(str) dgettext(PACKAGE, str) +EAPI extern E_Module_Api e_modapi; EAPI void *e_modapi_init(E_Module * m); - EAPI int e_modapi_shutdown(E_Module * m); - EAPI int e_modapi_save(E_Module * m); #endif