update slides

resources/slides.lua

 gShowBounds = false
+gUseBlurInTransitions = false
 
 gPath = "/skia/trunk/resources/"
 
 function load_file(file)
     local prev_path = package.path
     package.path = package.path .. ";" .. gPath .. file .. ".lua"
     require(file)
     package.path = prev_path
 end
 
 load_file("slides_utils")
 
 gSlides = parse_file(io.open("/skia/trunk/resources/slides_content2.lua", "r"))
 
 function make_rect(l, t, r, b)
     return { left = l, top = t, right = r, bottom = b }
 end
 
 function make_paint(typefacename, stylebits, size, color)
     local paint = Sk.newPaint();
     paint:setAntiAlias(true)
     paint:setSubpixelText(true)
     paint:setTypeface(Sk.newTypeface(typefacename, stylebits))
     paint:setTextSize(size)
     paint:setColor(color)
     return paint
 end
 
-function center_rect(sw, sh, dst)
-    local dw = dst.right - dst.left
-    local dh = dst.bottom - dst.top
-
-    local rw, rh
-
-    if sw / sh > dw / dh then
-        rw = dw
-        rh = sh * dw / sw
-    else
-        rh = dh
-        rw = sw * dh / sh
-    end
-
-    local x = dst.left + ((sw - rw) / 2)
-    local y = dst.top  + ((sh - rh) / 2)
-    return make_rect(x, y, x + rw, y + rh)
-end
-
-function draw_image_centered(canvas, image)
-    local sw = image:width()
-    local sh = image:height()
-    local dstR = center_rect(image:width(), image:height(), make_rect(20, 20, 620, 460))
-    canvas:drawImageRect(image, nil, dstR)
-end
-
 function draw_bullet(canvas, x, y, paint, indent)
     if 0 == indent then
         return
     end
     local ps = paint:getTextSize()
     local cx = x - ps * .8
     local cy = y - ps * .4
     local radius = ps * .2
     canvas:drawCircle(cx, cy, radius, paint)
 end
@@ skipping 92 matching lines @@
 gRedPaint:setColor{a=1, r=1, g=0, b=0 }
 
 -- animation.proc is passed the canvas before drawing.
 -- The animation.proc returns itself or another animation (which means keep animating)
 -- or it returns nil, which stops the animation.
 --
 local gCurrAnimation
 
 gSlideIndex = 1
 
+-----------------------------------------------------------------------------
+
 function new_drawable_picture(pic)
     return {
         picture = pic,
         width = pic:width(),
         height = pic:height(),
         draw = function (self, canvas, x, y, paint)
             canvas:drawPicture(self.picture, x, y, paint)
         end
     }
 end
 
 function new_drawable_image(img)
     return {
         image = img,
         width = img:width(),
         height = img:height(),
         draw = function (self, canvas, x, y, paint)
             canvas:drawImage(self.image, x, y, paint)
         end
     }
 end
 
+function convert_to_picture_drawable(slide)
+    local rec = Sk.newPictureRecorder()
+    drawSlide(rec:beginRecording(640, 480), slide, gTemplate)
+    return new_drawable_picture(rec:endRecording())
+end
+
+function convert_to_image_drawable(slide)
+    local surf = Sk.newRasterSurface(640, 480)
+    drawSlide(surf:getCanvas(), slide, gTemplate)
+    return new_drawable_image(surf:newImageSnapshot())
+end
+
 function new_drawable_slide(slide)
     return {
         slide = slide,
         draw = function (self, canvas, x, y, paint)
             if (nil == paint or ("number" == type(paint) and (1 == paint))) then
                 canvas:save()
             else
                 canvas:saveLayer(paint)
             end
             canvas:translate(x, y)
             drawSlide(canvas, self.slide, gTemplate)
             canvas:restore()
         end
     }
 end
 
+gNewDrawableFactory = {
+    default = new_drawable_slide,
+    picture = convert_to_picture_drawable,
+    image = convert_to_image_drawable,
+}
+
+-----------------------------------------------------------------------------
+
 function next_slide()
     local prev = gSlides[gSlideIndex]
 
     if gSlideIndex < #gSlides then
         gSlideIndex = gSlideIndex + 1
         spawn_transition(prev, gSlides[gSlideIndex], true)
     end
 end
 
 function prev_slide()
     local prev = gSlides[gSlideIndex]
 
     if gSlideIndex > 1 then
         gSlideIndex = gSlideIndex - 1
         spawn_transition(prev, gSlides[gSlideIndex], false)
     end
 end
 
-function convert_to_picture_drawable(slide)
-    local rec = Sk.newPictureRecorder()
-    drawSlide(rec:beginRecording(640, 480), slide, gTemplate)
-    return new_drawable_picture(rec:endRecording())
-end
-
-function convert_to_image_drawable(slide)
-    local surf = Sk.newRasterSurface(640, 480)
-    drawSlide(surf:getCanvas(), slide, gTemplate)
-    return new_drawable_image(surf:newImageSnapshot())
-end
-
-gMakeDrawable = new_drawable_slide
+gDrawableType = "default"
 
 load_file("slides_transitions")
 
 function spawn_transition(prevSlide, nextSlide, is_forward)
     local transition
     if is_forward then
         transition = gTransitionTable[nextSlide.transition]
     else
         transition = gTransitionTable[prevSlide.transition]
     end
 
     if not transition then
         transition = fade_slide_transition
     end
 
-    local prevDrawable = gMakeDrawable(prevSlide)
-    local nextDrawable = gMakeDrawable(nextSlide)
+    local prevDrawable = gNewDrawableFactory[gDrawableType](prevSlide)
+    local nextDrawable = gNewDrawableFactory[gDrawableType](nextSlide)
     gCurrAnimation = transition(prevDrawable, nextDrawable, is_forward)
 end
 
 --------------------------------------------------------------------------------------
 
 function spawn_rotate_animation()
     gCurrAnimation = {
         angle = 0,
         angle_delta = 5,
         pivot_x = 320,
@@ skipping 81 matching lines @@
 
 local keyProcs = {
     n = next_slide,
     p = prev_slide,
     r = spawn_rotate_animation,
     s = spawn_scale_animation,
     ["="] = function () scale_text_delta(gTemplate, 1) end,
     ["-"] = function () scale_text_delta(gTemplate, -1) end,
 
     b = function () gShowBounds = not gShowBounds end,
+    B = function () gUseBlurInTransitions = not gUseBlurInTransitions end,
+
+    ["1"] = function () gDrawableType = "default" end,
+    ["2"] = function () gDrawableType = "picture" end,
+    ["3"] = function () gDrawableType = "image" end,
 }
 
 function onCharHandler(uni)
     local proc = keyProcs[uni]
     if proc then
         proc()
         return true
     end
     return false
 end