332 lines
9.6 KiB
Python
332 lines
9.6 KiB
Python
from efl import elementary
|
|
from efl import evas
|
|
|
|
from efl.elementary.window import Window, ELM_WIN_BASIC
|
|
from efl.elementary.transit import Transit
|
|
from efl.elementary.gesture_layer import GestureLayer, ELM_GESTURE_ZOOM, \
|
|
ELM_GESTURE_MOMENTUM, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_MOVE, \
|
|
ELM_GESTURE_STATE_END, ELM_GESTURE_STATE_ABORT, ELM_GESTURE_STATE_START
|
|
from efl.elementary.background import Background
|
|
from efl.elementary.layout import Layout
|
|
from efl.elementary.entry import Entry, ELM_WRAP_MIXED
|
|
from efl.elementary.icon import Icon
|
|
|
|
from efl.evas import Map, EVAS_HINT_EXPAND, EVAS_EVENT_FLAG_NONE
|
|
|
|
#We zoom out to this value so we'll be able to use map and have a nice
|
|
#resolution when zooming in.
|
|
BASE_ZOOM = 0.5
|
|
#The amount of zoom to do when "lifting" objects.
|
|
LIFT_FACTOR = 1.3
|
|
#The base size of the shadow image.
|
|
SHADOW_W = 118
|
|
SHADOW_H = 118
|
|
|
|
zoom_out_animation_duration = 0.4
|
|
|
|
class Photo_Object(object):
|
|
ic = None
|
|
shadow = None
|
|
hit = None
|
|
gl = None
|
|
zoom_out = None
|
|
# bx, by - current wanted coordinates of the photo object.
|
|
# bw, bh - original size of the "ic" object.
|
|
# dx, dy - Used to indicate the distance between the center point
|
|
# where we put down our fingers (when started moving the item) to
|
|
# the coords of the object, so we'll be able to calculate movement
|
|
# correctly.
|
|
bx, by, bw, bh, dx, dy = None, None, None, None, None, None
|
|
# Because gesture layer only knows the amount of rotation/zoom we do
|
|
# per gesture, we have to keep the current rotate/zoom factor and the
|
|
# one that was before we started the gesture.
|
|
base_rotate, rotate = None, None
|
|
base_zoom, zoom = None, None
|
|
shadow_zoom = None
|
|
|
|
def apply_changes(po):
|
|
"""
|
|
This function applies the information from the Photo_Object to the actual
|
|
evas objects. Zoom/rotate factors and etc.
|
|
"""
|
|
|
|
map = evas.Map(4)
|
|
map.point_coord_set(0, po.bx, po.by, 0)
|
|
map.point_coord_set(1, po.bx + po.bw, po.by, 0)
|
|
map.point_coord_set(2, po.bx + po.bw, po.by + po.bh, 0)
|
|
map.point_coord_set(3, po.bx, po.by + po.bh, 0)
|
|
map.point_image_uv_set(0, 0, 0)
|
|
map.point_image_uv_set(1, po.bw, 0)
|
|
map.point_image_uv_set(2, po.bw, po.bh)
|
|
map.point_image_uv_set(3, 0, po.bh)
|
|
map.util_rotate(po.rotate, po.bx + po.bw / 2, po.by + po.bh /2)
|
|
map.util_zoom(po.zoom, po.zoom, po.bx + po.bw / 2, po.by + po.bh /2)
|
|
po.ic.map_enabled = True
|
|
po.ic.map = map
|
|
|
|
shadow_map = Map(4)
|
|
shadow_map.point_coord_set(0, po.bx, po.by, 0)
|
|
shadow_map.point_coord_set(1, po.bx + po.bw, po.by, 0)
|
|
shadow_map.point_coord_set(2, po.bx + po.bw, po.by + po.bh, 0)
|
|
shadow_map.point_coord_set(3, po.bx, po.by + po.bh, 0)
|
|
shadow_map.point_image_uv_set(0, 0, 0)
|
|
shadow_map.point_image_uv_set(1, SHADOW_W, 0)
|
|
shadow_map.point_image_uv_set(2, SHADOW_W, SHADOW_H)
|
|
shadow_map.point_image_uv_set(3, 0, SHADOW_H)
|
|
shadow_map.util_rotate(po.rotate, po.bx + po.bw / 2, po.by + po.bh /2)
|
|
shadow_map.util_zoom(po.zoom * po.shadow_zoom,
|
|
po.zoom * po.shadow_zoom,
|
|
po.bx + (po.bw / 2), po.by + (po.bh / 2))
|
|
po.shadow.map_enabled = True
|
|
po.shadow.map = shadow_map
|
|
#evas_map_free(shadow_map);
|
|
|
|
# Update the position of the hit box
|
|
po.hit.points_clear()
|
|
minx, miny, minz = map.point_coord_get(0)
|
|
maxx = minx
|
|
maxy = miny
|
|
po.hit.point_add(minx, miny)
|
|
for i in range(1, 3):
|
|
x, y, z = map.point_coord_get(i)
|
|
po.hit.point_add(x, y)
|
|
if x < minx:
|
|
minx = x
|
|
elif x > maxx:
|
|
maxx = x
|
|
|
|
if y < miny:
|
|
miny = y
|
|
elif y > maxy:
|
|
maxy = y
|
|
|
|
po.shadow.raise_()
|
|
po.ic.raise_()
|
|
po.hit.raise_()
|
|
#evas_map_free(map);
|
|
|
|
def zoom_out_animation_operation(transit, *args, **kwargs):
|
|
"""Zoom out animation"""
|
|
po, progress = args
|
|
po.zoom = BASE_ZOOM + ((po.base_zoom - BASE_ZOOM) * (1.0 - progress))
|
|
apply_changes(po)
|
|
|
|
def zoom_out_animation_end(transit, *args, **kwargs):
|
|
po = args[0]
|
|
|
|
po.base_zoom = po.zoom = BASE_ZOOM
|
|
apply_changes(po)
|
|
|
|
po.zoom_out = None
|
|
|
|
def rotate_move(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("rotate move <%d,%d> base=<%f> <%f>" % (p.x, p.y, p.base_angle, p.angle))
|
|
po.rotate = po.base_rotate + p.angle - p.base_angle
|
|
if po.rotate < 0:
|
|
po.rotate += 360
|
|
apply_changes(po)
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def rotate_end(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("rotate end/abort <%d,%d> base=<%f> <%f>" % (p.x, p.y, p.base_angle, p.angle))
|
|
po.base_rotate += p.angle - p.base_angle
|
|
if po.rotate < 0:
|
|
po.rotate += 360
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def zoom_start(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("zoom start <%d,%d> <%f>" % (p.x, p.y, p.zoom))
|
|
|
|
# If there's an active animator, stop it
|
|
if po.zoom_out:
|
|
elm_transit_del(po.zoom_out)
|
|
po.zoom_out = None
|
|
|
|
# Give it a "lift" effect right from the start
|
|
po.base_zoom = BASE_ZOOM * LIFT_FACTOR
|
|
po.zoom = po.base_zoom
|
|
po.shadow_zoom = 1.7
|
|
|
|
apply_changes(po)
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def zoom_move(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("zoom move <%d,%d> <%f>" % (p.x, p.y, p.zoom))
|
|
po.zoom = po.base_zoom * p.zoom
|
|
apply_changes(po);
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def zoom_end(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("zoom end/abort <%d,%d> <%f>" % (p.x, p.y, p.zoom))
|
|
|
|
# Apply the zoom out animator
|
|
po.shadow_zoom = 1.3
|
|
po.base_zoom = po.zoom
|
|
po.zoom_out = Transit()
|
|
po.zoom_out.duration = zoom_out_animation_duration
|
|
po.zoom_out.effect_add(zoom_out_animation_operation, po, zoom_out_animation_end)
|
|
po.zoom_out.go()
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def momentum_start(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("momentum_start <%d,%d>" % (p.x2, p.y2))
|
|
|
|
po.dx = p.x2 - po.bx
|
|
po.dy = p.y2 - po.by
|
|
apply_changes(po)
|
|
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def momentum_move(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("momentum move <%d,%d>" % (p.x2, p.y2))
|
|
|
|
po.bx = p.x2 - po.dx
|
|
po.by = p.y2 - po.dy
|
|
apply_changes(po)
|
|
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def momentum_end(event_info, *args, **kwargs):
|
|
po = args[0]
|
|
p = event_info
|
|
|
|
print("momentum end/abort <%d,%d> <%d,%d>" % (p.x2, p.y2, p.mx, p.my))
|
|
#(void) po;
|
|
#(void) p;
|
|
|
|
# Make sure middle is in the screen, if not, fix it.
|
|
# FIXME: Use actual window sizes instead of the hardcoded
|
|
# values
|
|
mx = po.bx + (po.bw / 2)
|
|
my = po.by + (po.bh / 2)
|
|
if mx < 0:
|
|
po.bx = 0 - (po.bw / 2)
|
|
elif mx > 480:
|
|
po.bx = 480 - (po.bw / 2)
|
|
|
|
if my < 0:
|
|
po.by = 0 - (po.bw / 2)
|
|
elif my > 800:
|
|
po.by = 800 - (po.bh / 2)
|
|
|
|
apply_changes(po)
|
|
|
|
return EVAS_EVENT_FLAG_NONE
|
|
|
|
def photo_object_add(parent, ic, icon, x, y, w, h, angle):
|
|
po = Photo_Object()
|
|
po.base_zoom = po.zoom = BASE_ZOOM
|
|
|
|
if ic:
|
|
po.ic = ic
|
|
else:
|
|
po.ic = Icon(parent)
|
|
po.ic.file = icon
|
|
|
|
po.bx = x
|
|
po.by = y
|
|
po.bw = w
|
|
po.bh = h
|
|
|
|
# Add shadow
|
|
po.shadow = Icon(po.ic)
|
|
po.shadow.file = "images/pol_shadow.png"
|
|
po.shadow.size = SHADOW_W, SHADOW_H
|
|
po.shadow.show()
|
|
|
|
po.hit = evas.Polygon(parent.evas)
|
|
po.hit.precise_is_inside = True
|
|
po.hit.repeat_events = True
|
|
po.hit.color = 0, 0, 0, 0
|
|
|
|
po.ic.pos = 0, 0
|
|
po.ic.size = po.bw, po.bh
|
|
po.ic.show()
|
|
|
|
po.hit.show()
|
|
|
|
po.gl = GestureLayer(po.ic)
|
|
po.gl.hold_events = True
|
|
po.gl.attach(po.hit)
|
|
|
|
# FIXME: Add a po.rotate start so we take the first angle!!!!
|
|
po.gl.cb_set(ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_MOVE, rotate_move, po)
|
|
po.gl.cb_set(ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_END, rotate_end, po)
|
|
po.gl.cb_set(ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_ABORT, rotate_end, po)
|
|
po.gl.cb_set(ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START, zoom_start, po)
|
|
po.gl.cb_set(ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE, zoom_move, po)
|
|
po.gl.cb_set(ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END, zoom_end, po)
|
|
po.gl.cb_set(ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT, zoom_end, po)
|
|
po.gl.cb_set(ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_START, momentum_start, po)
|
|
po.gl.cb_set(ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_MOVE, momentum_move, po)
|
|
po.gl.cb_set(ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_END, momentum_end, po)
|
|
po.gl.cb_set(ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_ABORT, momentum_end, po)
|
|
|
|
po.rotate = po.base_rotate = angle
|
|
po.shadow_zoom = 1.3
|
|
|
|
apply_changes(po)
|
|
return po
|
|
|
|
def gesture_layer_clicked(obj):
|
|
w = 480
|
|
h = 800
|
|
|
|
win = Window("gesture-layer", ELM_WIN_BASIC)
|
|
win.title = "Gesture Layer"
|
|
win.autodel = True
|
|
win.size = w, h
|
|
|
|
bg = Background(win)
|
|
bg.file = "images/wood_01.jpg"
|
|
bg.size_hint_weight = EVAS_HINT_EXPAND, EVAS_HINT_EXPAND
|
|
win.resize_object_add(bg)
|
|
bg.show()
|
|
|
|
photos = []
|
|
|
|
photos.append(photo_object_add(win, None, "images/pol_sky.png", 200, 200, 365, 400, 0))
|
|
photos.append(photo_object_add(win, None, "images/pol_twofish.png", 40, 300, 365, 400, 45))
|
|
|
|
en = Entry(win)
|
|
en.text = "You can use whatever object you want, even entries like this."
|
|
en.line_wrap = ELM_WRAP_MIXED
|
|
|
|
postit = Layout(win)
|
|
postit.file = "postit_ent.edj", "main"
|
|
postit.part_content_set("ent", en)
|
|
|
|
photos.append(photo_object_add(win, postit, None, 50, 50, 382, 400, 355))
|
|
|
|
win.callback_delete_request_add(lambda o: elementary.exit())
|
|
win.show()
|
|
|
|
if __name__ == "__main__":
|
|
elementary.init()
|
|
|
|
gesture_layer_clicked(None)
|
|
|
|
elementary.run()
|
|
elementary.shutdown()
|