add gradients and drawPaint to lua

resources/slides.lua

 function tostr(t)
     local str = ""
     for k, v in next, t do
         if #str > 0 then
             str = str .. ", "
         end
         if type(k) == "number" then
             str = str .. "[" .. k .. "] = "
         else
             str = str .. tostring(k) .. " = "
@@ skipping 78 matching lines @@
     paint:setColor(color)
     return paint
 end
 
 function drawSlide(canvas, slide, template)
     template = template.slide   -- need to sniff the slide to know if we're title or slide
 
     local x = template.margin_x
     local y = template.margin_y
 
-    local scale = 1.15
+    local scale = 1.25
     for i = 1, #slide do
         local node = slide[i]
-        local paint = template[node.indent + 1]
+        local paint = template[node.indent + 1].paint
+        local extra_dy = template[node.indent + 1].extra_dy
         local fm = paint:getFontMetrics()
         local x_offset = -fm.ascent * node.indent
 
         y = y - fm.ascent * scale
         canvas:drawText(node.text, x + x_offset, y, paint)
-        y = y + fm.descent * scale
+        y = y + fm.descent * scale + extra_dy
     end
 end
 
+function scale_text_delta(template, delta)
+    template = template.slide
+    for i = 1, #template do
+        local paint = template[i].paint
+        paint:setTextSize(paint:getTextSize() + delta)
+    end
+end
+
 function slide_transition(prev, next, is_forward)
     local rec = {
         proc = function(self, canvas, drawSlideProc)
             if self:isDone() then
                 drawSlideProc(canvas)
                 return nil
             end
             self.prevDrawable:draw(canvas, self.curr_x, 0)
             self.nextDrawable:draw(canvas, self.curr_x + 640, 0)
             self.curr_x = self.curr_x + self.step_x
@@ skipping 11 matching lines @@
         rec.nextDrawable = prev
         rec.curr_x = -640
         rec.step_x = 15
         rec.isDone = function (self) return self.curr_x >= 0 end
     end
     return rec
 end
 
 function sqr(value) return value * value end
 
-function ease(value) 
 function set_blur(paint, alpha)
     local sigma = sqr(1 - alpha) * 20
---    paint:setImageFilter(Sk.newBlurImageFilter(sigma, sigma))
+    paint:setImageFilter(Sk.newBlurImageFilter(sigma, sigma))
     paint:setAlpha(alpha)
 end
 
 function fade_slide_transition(prev, next, is_forward)
     local rec = {
         paint = Sk.newPaint(),
         prevDrawable = prev,
         nextDrawable = next,
         proc = function(self, canvas, drawSlideProc)
             if self:isDone() then
@@ skipping 30 matching lines @@
         rec.step = function (self)
             self.prev_x = self.prev_x + 20
             self.prev_a = (640 - self.prev_x) / 640
             self.next_a = 1 - self.prev_a
         end
     end
     return rec
 end
 
 --------------------------------------------------------------------------------------
+function make_tmpl(paint, extra_dy)
+    return { paint = paint, extra_dy = extra_dy }
+end
 
 function SkiaPoint_make_template()
     local title = {
         margin_x = 30,
         margin_y = 100,
     }
-    title[1] = make_paint("Arial", 1, 50, { a=1, r=0, g=0, b=0 })
+    title[1] = make_paint("Arial", 1, 50, { a=1, r=1, g=1, b=1 })
     title[1]:setTextAlign("center")
-    title[2] = make_paint("Arial", 1, 25, { a=1, r=.3, g=.3, b=.3 })
+    title[2] = make_paint("Arial", 1, 25, { a=1, r=.75, g=.75, b=.75 })
     title[2]:setTextAlign("center")
 
     local slide = {
         margin_x = 20,
-        margin_y = 30,
+        margin_y = 25,
     }
-    slide[1] = make_paint("Arial", 1, 36, { a=1, r=0, g=0, b=0 })
-    slide[2] = make_paint("Arial", 0, 30, { a=1, r=0, g=0, b=0 })
-    slide[3] = make_paint("Arial", 0, 24, { a=1, r=.2, g=.2, b=.2 })
+    slide[1] = make_tmpl(make_paint("Arial", 1, 36, { a=1, r=1, g=1, b=1 }), 18)
+    slide[2] = make_tmpl(make_paint("Arial", 0, 30, { a=1, r=1, g=1, b=1 }), 0)
+    slide[3] = make_tmpl(make_paint("Arial", 0, 24, { a=1, r=.8, g=.8, b=.8 }), 0)
 
     return {
         title = title,
         slide = slide,
     }
 end
 
 gTemplate = SkiaPoint_make_template()
 
 gRedPaint = Sk.newPaint()
@@ skipping 127 matching lines @@
             canvas:scale(self.scale, self.scale)
             canvas:translate(-self.pivot_x, -self.pivot_y)
             drawSlideProc(canvas)
 
             self.scale = self.scale * self.scale_delta
             return self
         end
     }
 end
 
+local bgPaint = nil
+
+function draw_bg(canvas)
+    if not bgPaint then
+        bgPaint = Sk.newPaint()
+        local grad = Sk.newLinearGradient(  0,   0, { a=1, r=0, g=0, b=.3 },
+                                          640, 480, { a=1, r=0, g=0, b=.8 })
+        bgPaint:setShader(grad)
+    end
+
+    canvas:drawPaint(bgPaint)
+end
+
 function onDrawContent(canvas, width, height)
     local matrix = Sk.newMatrix()
     matrix:setRectToRect(make_rect(0, 0, 640, 480), make_rect(0, 0, width, height), "center")
     canvas:concat(matrix)
 
+    draw_bg(canvas)
+
     local drawSlideProc = function(canvas)
         drawSlide(canvas, gSlides[gSlideIndex], gTemplate)
     end
 
     if gCurrAnimation then
         gCurrAnimation = gCurrAnimation:proc(canvas, drawSlideProc)
         return true
     else
         drawSlideProc(canvas)
         return false
     end
 end
 
 function onClickHandler(x, y)
     return false
 end
 
 local keyProcs = {
     n = next_slide,
     p = prev_slide,
     r = spawn_rotate_animation,
     s = spawn_scale_animation,
+    u = function () scale_text_delta(gTemplate, 1) end,
+    d = function () scale_text_delta(gTemplate, -1) end,
 }
 
 function onCharHandler(uni)
     local proc = keyProcs[uni]
     if proc then
         proc()
         return true
     end
     return false
 end