Created
June 13, 2013 05:43
-
-
Save anonymous/5771498 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Album = class() | |
function Album:init() | |
self.title = "" | |
self.comment = "" | |
self.firstPhoto = "Documents:Frame" | |
self.photos = {} | |
self.x = 0 | |
self.y = 0 | |
self.size = 600 | |
self.displayX = 0 | |
self.displayY = 0 | |
self.displaySize = 600 | |
self.minx = 0 | |
self.maxx = 0 | |
self.miny = 0 | |
self.maxy = 0 | |
self.sizeincrement = 0 | |
self.whenToZoom = math.random(10, 1000) | |
self.iconindex = 1 | |
end | |
function Album:draw() | |
if viewMode == TOPVIEW then | |
if view.framesSinceLastTouch > self.whenToZoom then | |
self.sizeincrement = math.min(self.sizeincrement + 0.05, 100) | |
else | |
self.sizeincrement = 0 | |
end | |
self.displayX = self.x-self.sizeincrement/2 | |
self.displayY = self.y-self.sizeincrement/2 | |
self.displaySize = self.size + self.sizeincrement | |
self.photos[self.iconindex]:download() | |
clip(self.x-view.offset,self.y,self.size,self.size*2/3) | |
sprite(self.photos[self.iconindex].photo, self.displayX, self.displayY, self.displaySize) | |
clip() | |
pushMatrix() | |
stroke(0, 0, 0, 255) | |
translate(0,0,1) | |
strokeWidth(25) | |
line(self.minx,self.miny,self.maxx,self.miny) | |
line(self.minx,self.maxy,self.maxx,self.maxy) | |
line(self.minx,self.miny,self.minx,self.maxy) | |
line(self.maxx,self.miny,self.maxx,self.maxy) | |
if view.maxOffset < self.x+self.size-WIDTH then | |
view.maxOffset = self.x+self.size-WIDTH | |
end | |
fontSize(40) | |
fill(0, 0, 0, 255) | |
translate(15, 5, 2) | |
text(self.title, self.x, self.y) | |
translate(-1, 2, 2) | |
fill(192, 192, 192, 255) | |
text(self.title, self.x, self.y) | |
popMatrix() | |
elseif viewMode == ALBUM then | |
fill(64, 64, 64, 255) | |
strokeWidth(0) | |
rect(0,0,300,HEIGHT) | |
fill(0, 0, 0, 255) | |
fontSize(32) | |
text(self.title, 20, HEIGHT/2-50) | |
textWrapWidth(260) | |
fontSize(15) | |
sx,sy = textSize(self.comment) | |
text(self.comment, 20, HEIGHT/2-60-sy) | |
textWrapWidth(0) | |
for _, photo in pairs(self.photos) do | |
photo:draw() | |
end | |
elseif viewMode == PHOTO then | |
currentPhoto:draw() | |
end | |
end | |
function Album:touched(touch) | |
tx = view.touch.x+view.offset | |
ty = view.touch.y | |
for _, photo in pairs(self.photos) do | |
if tx > photo.minx and tx < photo.maxx and ty > photo.miny and ty < photo.maxy then | |
currentPhoto = photo | |
viewMode = PHOTO | |
end | |
end | |
end | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
function parseData(data, status, headers) | |
print("parsedata") | |
if albums["Mexico"] ~= nil then | |
olddata = readLocalData("layout", "") | |
if data == olddata then | |
return | |
else | |
--if false then | |
for _, album in pairs(albums) do | |
if album.title ~= "Water Molotov" then | |
for __, photo in pairs(album.photos) do | |
photo.photo = nil | |
photo = nil | |
end | |
print("deleting "..album.title) | |
albums[album.title] = nil | |
end | |
end | |
collectgarbage() | |
--sound(SOUND_JUMP, 1271) | |
end | |
end | |
saveLocalData("layout", data) | |
for entry in string.gmatch(data, "[^\r\n]+") do | |
r = {} | |
for x in string.gmatch(entry, '[^#]+') do | |
table.insert(r, x) | |
end | |
if r[1] == "A" then | |
album = r[2] | |
if albums[album] == nil then | |
print("creating "..album) | |
albums[album] = Album() | |
end | |
albums[album].title = album | |
albums[album].x = photox*r[3] + 500 | |
albums[album].y = photoy*r[4] | |
albums[album].size = photox*r[5] | |
albums[album].displaySize = photox*r[5] | |
albums[album].iconindex = tonumber(r[6]) | |
if albums[album].iconindex == 2.5 then | |
albums[album].iconindex = 2 | |
albums[album].size = photox*2.5 | |
albums[album].displaySize = photox*2.5 | |
end | |
albums[album].comment = r[7] | |
albums[album].minx = albums[album].x | |
albums[album].miny = albums[album].y | |
albums[album].maxx = albums[album].x + albums[album].size | |
albums[album].maxy = albums[album].y + albums[album].size*2/3 | |
end | |
if r[1] == "I" then | |
album = r[2] | |
local xpos = r[3] | |
local ypos = r[4] | |
local sizefactor = r[5] | |
local title = r[6] | |
local url = r[7] | |
if albums[album] == nil then | |
albums[album] = Album() | |
end | |
currentAlbum = albums[album] | |
albums[album].title = album | |
p = Photo() | |
p.url = url | |
p.title = title | |
p.x = photox * xpos + 300 | |
p.y = photoy * ypos | |
p.size = photox * sizefactor | |
p.displaySize = p.size | |
p.minx = p.x | |
p.miny = p.y | |
p.maxx = p.x + p.size | |
p.maxy = p.y + p.size*2/3 | |
for x in string.gmatch(p.url, '[^/]+') do | |
p.filename = x | |
end | |
p.filename = string.sub(p.filename, 1, -5) | |
table.insert(albums[album].photos, p) | |
end | |
end | |
-- Go through albums and fill in prev and next for each photo | |
for _, a in pairs(albums) do | |
for i = 1, #a.photos do | |
if i > 1 then | |
a.photos[i].prev = a.photos[i-1] | |
end | |
if i < #a.photos then | |
a.photos[i].next = a.photos[i+1] | |
end | |
end | |
end | |
if false then | |
for __, a in pairs(albums) do | |
for _, p in pairs(a.photos) do | |
if p.downloaded == false then | |
http.request(p.url, function(theImage, status, head) | |
p.photo = theImage | |
p.downloaded = true | |
end) | |
end | |
end | |
end | |
end | |
end | |
function table.contains(table, element) | |
for _, value in pairs(table) do | |
if value == element then | |
return true | |
end | |
end | |
return false | |
end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
-- Module options: | |
local always_try_using_lpeg = true | |
--[==[ | |
David Kolf's JSON module for Lua 5.1/5.2 | |
======================================== | |
*Version 2.2* | |
This module writes no global values, not even the module table. | |
Import it using | |
json = require ("dkjson") | |
EDIT: this version included in Gister writes a single value 'json', as Codea disallows require -ap | |
Exported functions and values: | |
`json.encode (object [, state])` | |
-------------------------------- | |
Create a string representing the object. `Object` can be a table, | |
a string, a number, a boolean, `nil`, `json.null` or any object with | |
a function `__tojson` in its metatable. A table can only use strings | |
and numbers as keys and its values have to be valid objects as | |
well. It raises an error for any invalid data types or reference | |
cycles. | |
`state` is an optional table with the following fields: | |
- `indent` | |
When `indent` (a boolean) is set, the created string will contain | |
newlines and indentations. Otherwise it will be one long line. | |
- `keyorder` | |
`keyorder` is an array to specify the ordering of keys in the | |
encoded output. If an object has keys which are not in this array | |
they are written after the sorted keys. | |
- `level` | |
This is the initial level of indentation used when `indent` is | |
set. For each level two spaces are added. When absent it is set | |
to 0. | |
- `buffer` | |
`buffer` is an array to store the strings for the result so they | |
can be concatenated at once. When it isn't given, the encode | |
function will create it temporary and will return the | |
concatenated result. | |
- `bufferlen` | |
When `bufferlen` is set, it has to be the index of the last | |
element of `buffer`. | |
- `tables` | |
`tables` is a set to detect reference cycles. It is created | |
temporary when absent. Every table that is currently processed | |
is used as key, the value is `true`. | |
When `state.buffer` was set, the return value will be `true` on | |
success. Without `state.buffer` the return value will be a string. | |
`json.decode (string [, position [, null]])` | |
-------------------------------------------- | |
Decode `string` starting at `position` or at 1 if `position` was | |
omitted. | |
`null` is an optional value to be returned for null values. The | |
default is `nil`, but you could set it to `json.null` or any other | |
value. | |
The return values are the object or `nil`, the position of the next | |
character that doesn't belong to the object, and in case of errors | |
an error message. | |
Two metatables are created. Every array or object that is decoded gets | |
a metatable with the `__jsontype` field set to either `array` or | |
`object`. If you want to provide your own metatables use the syntax | |
json.decode (string, position, null, objectmeta, arraymeta) | |
To prevent the assigning of metatables pass `nil`: | |
json.decode (string, position, null, nil) | |
`<metatable>.__jsonorder` | |
------------------------- | |
`__jsonorder` can overwrite the `keyorder` for a specific table. | |
`<metatable>.__jsontype` | |
------------------------ | |
`__jsontype` can be either `"array"` or `"object"`. This value is only | |
checked for empty tables. (The default for empty tables is `"array"`). | |
`<metatable>.__tojson (self, state)` | |
------------------------------------ | |
You can provide your own `__tojson` function in a metatable. In this | |
function you can either add directly to the buffer and return true, | |
or you can return a string. On errors nil and a message should be | |
returned. | |
`json.null` | |
----------- | |
You can use this value for setting explicit `null` values. | |
`json.version` | |
-------------- | |
Set to `"dkjson 2.2"`. | |
`json.quotestring (string)` | |
--------------------------- | |
Quote a UTF-8 string and escape critical characters using JSON | |
escape sequences. This function is only necessary when you build | |
your own `__tojson` functions. | |
`json.addnewline (state)` | |
------------------------- | |
When `state.indent` is set, add a newline to `state.buffer` and spaces | |
according to `state.level`. | |
LPeg support | |
------------ | |
When the local configuration variable `always_try_using_lpeg` is set, | |
this module tries to load LPeg to replace the `decode` function. The | |
speed increase is significant. You can get the LPeg module at | |
<http://www.inf.puc-rio.br/~roberto/lpeg/>. | |
When LPeg couldn't be loaded, the pure Lua functions stay active. | |
In case you don't want this module to require LPeg on its own, | |
disable the option `always_try_using_lpeg` in the options section at | |
the top of the module. | |
In this case you can later load LPeg support using | |
### `json.use_lpeg ()` | |
Require the LPeg module and replace the functions `quotestring` and | |
and `decode` with functions that use LPeg patterns. | |
This function returns the module table, so you can load the module | |
using: | |
json = require "dkjson".use_lpeg() | |
Alternatively you can use `pcall` so the JSON module still works when | |
LPeg isn't found. | |
json = require "dkjson" | |
pcall (json.use_lpeg) | |
### `json.using_lpeg` | |
This variable is set to `true` when LPeg was loaded successfully. | |
--------------------------------------------------------------------- | |
Contact | |
------- | |
You can contact the author by sending an e-mail to 'kolf' at the | |
e-mail provider 'gmx.de'. | |
--------------------------------------------------------------------- | |
*Copyright (C) 2010, 2011, 2012 David Heiko Kolf* | |
Permission is hereby granted, free of charge, to any person obtaining | |
a copy of this software and associated documentation files (the | |
"Software"), to deal in the Software without restriction, including | |
without limitation the rights to use, copy, modify, merge, publish, | |
distribute, sublicense, and/or sell copies of the Software, and to | |
permit persons to whom the Software is furnished to do so, subject to | |
the following conditions: | |
The above copyright notice and this permission notice shall be | |
included in all copies or substantial portions of the Software. | |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
SOFTWARE. | |
<!-- This documentation can be parsed using Markdown to generate HTML. | |
The source code is enclosed in a HTML comment so it won't be displayed | |
by browsers, but it should be removed from the final HTML file as | |
it isn't a valid HTML comment (and wastes space). | |
--> | |
<!--]==] | |
-- global dependencies: | |
local pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset = | |
pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset | |
local error, require, pcall, select = error, require, pcall, select | |
local floor, huge = math.floor, math.huge | |
local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat = | |
string.rep, string.gsub, string.sub, string.byte, string.char, | |
string.find, string.len, string.format | |
local concat = table.concat | |
local _ENV = nil -- blocking globals in Lua 5.2 | |
json = { version = "dkjson 2.2" } | |
pcall (function() | |
-- Enable access to blocked metatables. | |
-- Don't worry, this module doesn't change anything in them. | |
local debmeta = require "debug".getmetatable | |
if debmeta then getmetatable = debmeta end | |
end) | |
json.null = setmetatable ({}, { | |
__tojson = function () return "null" end | |
}) | |
local function isarray (tbl) | |
local max, n, arraylen = 0, 0, 0 | |
for k,v in pairs (tbl) do | |
if k == 'n' and type(v) == 'number' then | |
arraylen = v | |
if v > max then | |
max = v | |
end | |
else | |
if type(k) ~= 'number' or k < 1 or floor(k) ~= k then | |
return false | |
end | |
if k > max then | |
max = k | |
end | |
n = n + 1 | |
end | |
end | |
if max > 10 and max > arraylen and max > n * 2 then | |
return false -- don't create an array with too many holes | |
end | |
return true, max | |
end | |
local escapecodes = { | |
["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f", | |
["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t" | |
} | |
local function escapeutf8 (uchar) | |
local value = escapecodes[uchar] | |
if value then | |
return value | |
end | |
local a, b, c, d = strbyte (uchar, 1, 4) | |
a, b, c, d = a or 0, b or 0, c or 0, d or 0 | |
if a <= 0x7f then | |
value = a | |
elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then | |
value = (a - 0xc0) * 0x40 + b - 0x80 | |
elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then | |
value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80 | |
elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then | |
value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80 | |
else | |
return "" | |
end | |
if value <= 0xffff then | |
return strformat ("\\u%.4x", value) | |
elseif value <= 0x10ffff then | |
-- encode as UTF-16 surrogate pair | |
value = value - 0x10000 | |
local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400) | |
return strformat ("\\u%.4x\\u%.4x", highsur, lowsur) | |
else | |
return "" | |
end | |
end | |
local function fsub (str, pattern, repl) | |
-- gsub always builds a new string in a buffer, even when no match | |
-- exists. First using find should be more efficient when most strings | |
-- don't contain the pattern. | |
if strfind (str, pattern) then | |
return gsub (str, pattern, repl) | |
else | |
return str | |
end | |
end | |
local function quotestring (value) | |
-- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js | |
value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8) | |
if strfind (value, "[\194\216\220\225\226\239]") then | |
value = fsub (value, "\194[\128-\159\173]", escapeutf8) | |
value = fsub (value, "\216[\128-\132]", escapeutf8) | |
value = fsub (value, "\220\143", escapeutf8) | |
value = fsub (value, "\225\158[\180\181]", escapeutf8) | |
value = fsub (value, "\226\128[\140-\143\168\175]", escapeutf8) | |
value = fsub (value, "\226\129[\160-\175]", escapeutf8) | |
value = fsub (value, "\239\187\191", escapeutf8) | |
value = fsub (value, "\239\191[\176\191]", escapeutf8) | |
end | |
return "\"" .. value .. "\"" | |
end | |
json.quotestring = quotestring | |
local function addnewline2 (level, buffer, buflen) | |
buffer[buflen+1] = "\n" | |
buffer[buflen+2] = strrep (" ", level) | |
buflen = buflen + 2 | |
return buflen | |
end | |
function json.addnewline (state) | |
if state.indent then | |
state.bufferlen = addnewline2 (state.level or 0, | |
state.buffer, state.bufferlen or #(state.buffer)) | |
end | |
end | |
local encode2 -- forward declaration | |
local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder) | |
local kt = type (key) | |
if kt ~= 'string' and kt ~= 'number' then | |
return nil, "type '" .. kt .. "' is not supported as a key by JSON." | |
end | |
if prev then | |
buflen = buflen + 1 | |
buffer[buflen] = "," | |
end | |
if indent then | |
buflen = addnewline2 (level, buffer, buflen) | |
end | |
buffer[buflen+1] = quotestring (key) | |
buffer[buflen+2] = ":" | |
return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder) | |
end | |
encode2 = function (value, indent, level, buffer, buflen, tables, globalorder) | |
local valtype = type (value) | |
local valmeta = getmetatable (value) | |
valmeta = type (valmeta) == 'table' and valmeta -- only tables | |
local valtojson = valmeta and valmeta.__tojson | |
if valtojson then | |
if tables[value] then | |
return nil, "reference cycle" | |
end | |
tables[value] = true | |
local state = { | |
indent = indent, level = level, buffer = buffer, | |
bufferlen = buflen, tables = tables, keyorder = globalorder | |
} | |
local ret, msg = valtojson (value, state) | |
if not ret then return nil, msg end | |
tables[value] = nil | |
buflen = state.bufferlen | |
if type (ret) == 'string' then | |
buflen = buflen + 1 | |
buffer[buflen] = ret | |
end | |
elseif value == nil then | |
buflen = buflen + 1 | |
buffer[buflen] = "null" | |
elseif valtype == 'number' then | |
local s | |
if value ~= value or value >= huge or -value >= huge then | |
-- This is the behaviour of the original JSON implementation. | |
s = "null" | |
else | |
s = tostring (value) | |
end | |
buflen = buflen + 1 | |
buffer[buflen] = s | |
elseif valtype == 'boolean' then | |
buflen = buflen + 1 | |
buffer[buflen] = value and "true" or "false" | |
elseif valtype == 'string' then | |
buflen = buflen + 1 | |
buffer[buflen] = quotestring (value) | |
elseif valtype == 'table' then | |
if tables[value] then | |
return nil, "reference cycle" | |
end | |
tables[value] = true | |
level = level + 1 | |
local isa, n = isarray (value) | |
if n == 0 and valmeta and valmeta.__jsontype == 'object' then | |
isa = false | |
end | |
local msg | |
if isa then -- JSON array | |
buflen = buflen + 1 | |
buffer[buflen] = "[" | |
for i = 1, n do | |
buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder) | |
if not buflen then return nil, msg end | |
if i < n then | |
buflen = buflen + 1 | |
buffer[buflen] = "," | |
end | |
end | |
buflen = buflen + 1 | |
buffer[buflen] = "]" | |
else -- JSON object | |
local prev = false | |
buflen = buflen + 1 | |
buffer[buflen] = "{" | |
local order = valmeta and valmeta.__jsonorder or globalorder | |
if order then | |
local used = {} | |
n = #order | |
for i = 1, n do | |
local k = order[i] | |
local v = value[k] | |
if v then | |
used[k] = true | |
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder) | |
prev = true -- add a seperator before the next element | |
end | |
end | |
for k,v in pairs (value) do | |
if not used[k] then | |
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder) | |
if not buflen then return nil, msg end | |
prev = true -- add a seperator before the next element | |
end | |
end | |
else -- unordered | |
for k,v in pairs (value) do | |
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder) | |
if not buflen then return nil, msg end | |
prev = true -- add a seperator before the next element | |
end | |
end | |
if indent then | |
buflen = addnewline2 (level - 1, buffer, buflen) | |
end | |
buflen = buflen + 1 | |
buffer[buflen] = "}" | |
end | |
tables[value] = nil | |
else | |
return nil, "type '" .. valtype .. "' is not supported by JSON." | |
end | |
return buflen | |
end | |
function json.encode (value, jstate) | |
local jstate = jstate or {} | |
local oldbuffer = jstate.buffer | |
local buffer = oldbuffer or {} | |
local ret, msg = encode2 (value, jstate.indent, jstate.level or 0, | |
buffer, jstate.bufferlen or 0, jstate.tables or {}, jstate.keyorder) | |
if not ret then | |
error (msg, 2) | |
elseif oldbuffer then | |
state.bufferlen = ret | |
return true | |
else | |
return concat (buffer) | |
end | |
end | |
local function loc (str, where) | |
local line, pos, linepos = 1, 1, 0 | |
while true do | |
pos = strfind (str, "\n", pos, true) | |
if pos and pos < where then | |
line = line + 1 | |
linepos = pos | |
pos = pos + 1 | |
else | |
break | |
end | |
end | |
return "line " .. line .. ", column " .. (where - linepos) | |
end | |
local function unterminated (str, what, where) | |
return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where) | |
end | |
local function scanwhite (str, pos) | |
while true do | |
pos = strfind (str, "%S", pos) | |
if not pos then return nil end | |
if strsub (str, pos, pos + 2) == "\239\187\191" then | |
-- UTF-8 Byte Order Mark | |
pos = pos + 3 | |
else | |
return pos | |
end | |
end | |
end | |
local escapechars = { | |
["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f", | |
["n"] = "\n", ["r"] = "\r", ["t"] = "\t" | |
} | |
local function unichar (value) | |
if value < 0 then | |
return nil | |
elseif value <= 0x007f then | |
return strchar (value) | |
elseif value <= 0x07ff then | |
return strchar (0xc0 + floor(value/0x40), | |
0x80 + (floor(value) % 0x40)) | |
elseif value <= 0xffff then | |
return strchar (0xe0 + floor(value/0x1000), | |
0x80 + (floor(value/0x40) % 0x40), | |
0x80 + (floor(value) % 0x40)) | |
elseif value <= 0x10ffff then | |
return strchar (0xf0 + floor(value/0x40000), | |
0x80 + (floor(value/0x1000) % 0x40), | |
0x80 + (floor(value/0x40) % 0x40), | |
0x80 + (floor(value) % 0x40)) | |
else | |
return nil | |
end | |
end | |
local function scanstring (str, pos) | |
local lastpos = pos + 1 | |
local buffer, n = {}, 0 | |
while true do | |
local nextpos = strfind (str, "[\"\\]", lastpos) | |
if not nextpos then | |
return unterminated (str, "string", pos) | |
end | |
if nextpos > lastpos then | |
n = n + 1 | |
buffer[n] = strsub (str, lastpos, nextpos - 1) | |
end | |
if strsub (str, nextpos, nextpos) == "\"" then | |
lastpos = nextpos + 1 | |
break | |
else | |
local escchar = strsub (str, nextpos + 1, nextpos + 1) | |
local value | |
if escchar == "u" then | |
value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16) | |
if value then | |
local value2 | |
if 0xD800 <= value and value <= 0xDBff then | |
-- we have the high surrogate of UTF-16. Check if there is a | |
-- low surrogate escaped nearby to combine them. | |
if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then | |
value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16) | |
if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then | |
value = (value - 0xD800) * 0x400 + (value2 - 0xDC00) + 0x10000 | |
else | |
value2 = nil -- in case it was out of range for a low surrogate | |
end | |
end | |
end | |
value = value and unichar (value) | |
if value then | |
if value2 then | |
lastpos = nextpos + 12 | |
else | |
lastpos = nextpos + 6 | |
end | |
end | |
end | |
end | |
if not value then | |
value = escapechars[escchar] or escchar | |
lastpos = nextpos + 2 | |
end | |
n = n + 1 | |
buffer[n] = value | |
end | |
end | |
if n == 1 then | |
return buffer[1], lastpos | |
elseif n > 1 then | |
return concat (buffer), lastpos | |
else | |
return "", lastpos | |
end | |
end | |
local scanvalue -- forward declaration | |
local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta) | |
local len = strlen (str) | |
local tbl, n = {}, 0 | |
local pos = startpos + 1 | |
if what == 'object' then | |
setmetatable (tbl, objectmeta) | |
else | |
setmetatable (tbl, arraymeta) | |
end | |
while true do | |
pos = scanwhite (str, pos) | |
if not pos then return unterminated (str, what, startpos) end | |
local char = strsub (str, pos, pos) | |
if char == closechar then | |
return tbl, pos + 1 | |
end | |
local val1, err | |
val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) | |
if err then return nil, pos, err end | |
pos = scanwhite (str, pos) | |
if not pos then return unterminated (str, what, startpos) end | |
char = strsub (str, pos, pos) | |
if char == ":" then | |
if val1 == nil then | |
return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")" | |
end | |
pos = scanwhite (str, pos + 1) | |
if not pos then return unterminated (str, what, startpos) end | |
local val2 | |
val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) | |
if err then return nil, pos, err end | |
tbl[val1] = val2 | |
pos = scanwhite (str, pos) | |
if not pos then return unterminated (str, what, startpos) end | |
char = strsub (str, pos, pos) | |
else | |
n = n + 1 | |
tbl[n] = val1 | |
end | |
if char == "," then | |
pos = pos + 1 | |
end | |
end | |
end | |
scanvalue = function (str, pos, nullval, objectmeta, arraymeta) | |
pos = pos or 1 | |
pos = scanwhite (str, pos) | |
if not pos then | |
return nil, strlen (str) + 1, "no valid JSON value (reached the end)" | |
end | |
local char = strsub (str, pos, pos) | |
if char == "{" then | |
return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta) | |
elseif char == "[" then | |
return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta) | |
elseif char == "\"" then | |
return scanstring (str, pos) | |
else | |
local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos) | |
if pstart then | |
local number = tonumber (strsub (str, pstart, pend)) | |
if number then | |
return number, pend + 1 | |
end | |
end | |
pstart, pend = strfind (str, "^%a%w*", pos) | |
if pstart then | |
local name = strsub (str, pstart, pend) | |
if name == "true" then | |
return true, pend + 1 | |
elseif name == "false" then | |
return false, pend + 1 | |
elseif name == "null" then | |
return nullval, pend + 1 | |
end | |
end | |
return nil, pos, "no valid JSON value at " .. loc (str, pos) | |
end | |
end | |
local function optionalmetatables(...) | |
if select("#", ...) > 0 then | |
return ... | |
else | |
return {__jsontype = 'object'}, {__jsontype = 'array'} | |
end | |
end | |
function json.decode (str, pos, nullval, ...) | |
local objectmeta, arraymeta = optionalmetatables(...) | |
return scanvalue (str, pos, nullval, objectmeta, arraymeta) | |
end | |
function json.use_lpeg () | |
local g = require ("lpeg") | |
local pegmatch = g.match | |
local P, S, R, V = g.P, g.S, g.R, g.V | |
local function ErrorCall (str, pos, msg, state) | |
if not state.msg then | |
state.msg = msg .. " at " .. loc (str, pos) | |
state.pos = pos | |
end | |
return false | |
end | |
local function Err (msg) | |
return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall) | |
end | |
local Space = (S" \n\r\t" + P"\239\187\191")^0 | |
local PlainChar = 1 - S"\"\\\n\r" | |
local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars | |
local HexDigit = R("09", "af", "AF") | |
local function UTF16Surrogate (match, pos, high, low) | |
high, low = tonumber (high, 16), tonumber (low, 16) | |
if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then | |
return true, unichar ((high - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000) | |
else | |
return false | |
end | |
end | |
local function UTF16BMP (hex) | |
return unichar (tonumber (hex, 16)) | |
end | |
local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit)) | |
local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP | |
local Char = UnicodeEscape + EscapeSequence + PlainChar | |
local String = P"\"" * g.Cs (Char ^ 0) * (P"\"" + Err "unterminated string") | |
local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0)) | |
local Fractal = P"." * R"09"^0 | |
local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1 | |
local Number = (Integer * Fractal^(-1) * Exponent^(-1))/tonumber | |
local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1) | |
local SimpleValue = Number + String + Constant | |
local ArrayContent, ObjectContent | |
-- The functions parsearray and parseobject parse only a single value/pair | |
-- at a time and store them directly to avoid hitting the LPeg limits. | |
local function parsearray (str, pos, nullval, state) | |
local obj, cont | |
local npos | |
local t, nt = {}, 0 | |
repeat | |
obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state) | |
if not npos then break end | |
pos = npos | |
nt = nt + 1 | |
t[nt] = obj | |
until cont == 'last' | |
return pos, setmetatable (t, state.arraymeta) | |
end | |
local function parseobject (str, pos, nullval, state) | |
local obj, key, cont | |
local npos | |
local t = {} | |
repeat | |
key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state) | |
if not npos then break end | |
pos = npos | |
t[key] = obj | |
until cont == 'last' | |
return pos, setmetatable (t, state.objectmeta) | |
end | |
local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray) * Space * (P"]" + Err "']' expected") | |
local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject) * Space * (P"}" + Err "'}' expected") | |
local Value = Space * (Array + Object + SimpleValue) | |
local ExpectedValue = Value + Space * Err "value expected" | |
ArrayContent = Value * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() | |
local Pair = g.Cg (Space * String * Space * (P":" + Err "colon expected") * ExpectedValue) | |
ObjectContent = Pair * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() | |
local DecodeValue = ExpectedValue * g.Cp () | |
function json.decode (str, pos, nullval, ...) | |
local state = {} | |
state.objectmeta, state.arraymeta = optionalmetatables(...) | |
local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state) | |
if state.msg then | |
return nil, state.pos, state.msg | |
else | |
return obj, retpos | |
end | |
end | |
-- use this function only once: | |
json.use_lpeg = function () return json end | |
json.using_lpeg = true | |
return json -- so you can get the module using json = require "dkjson".use_lpeg() | |
end | |
if always_try_using_lpeg then | |
pcall (json.use_lpeg) | |
end | |
return json | |
--> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
-- Photographs | |
displayMode(FULLSCREEN_NO_BUTTONS) | |
supportedOrientations(LANDSCAPE_ANY) | |
TOPVIEW = 0 | |
ALBUM = 1 | |
PHOTO = 2 | |
-- Use this function to perform your initial setup | |
function setup() | |
photoy = HEIGHT/5 | |
photox = photoy*3/2 | |
textOpacity = 0 | |
textOpacityClamped = 0 | |
maxOffset = 1000 | |
topOffset = 0 | |
albumOffset = 0 | |
view = View2D() | |
albums = {} | |
currentAlbum = nil | |
currentPhoto = nil | |
newPhoto = nil | |
viewMode = TOPVIEW | |
timer = 100 | |
downloadsThisFrame = 0 | |
globalTitle = "Juan Buhler" | |
globalComment = "I'm a street photographer.\n\nOriginally from Argentina, in 1996 I moved to the United States to work in special effects. I have credits on computer animated feature films such as Brave, Toy Story 3, Wall-E and Ratatouille. Before that, I worked on Antz, Shrek, Shrek 2 and Madagascar.\n\nCurrently, I am driving a 1989 VW camper van down the Americas, from California to Tierra del Fuego. Check out vanenvan.com to read about that.\n\nMy website, jbuhler.com, has been online since 1999 or so, and my photoblog, Water Molotov, has had a new photo posted every day since early 2005.\n\nYou can contact me at juan@jbuhl\er.com.\n\ntap to go into a gallery / double tap to come back." | |
waitChar = 144 | |
waitText = "" | |
font("Futura-Medium") | |
textMode(CORNER) | |
spriteMode(CORNER) | |
lineCapMode(SQUARE) | |
loadLayout() | |
end | |
function loadLayout() | |
--First add photoblog | |
local photoblogData = readLocalData("photoblog", "") | |
if photoblogData ~= "" then | |
rssLoaded(photoblogData, "foo", "bar") | |
end | |
http.request("http://photoblog.jbuhler.com/feed/?json", rssLoaded) | |
--Then load rest of the layout | |
data = readLocalData("layout", "") | |
parseData(data, "foo", "bar") | |
http.request('http://www.jbuhler.com/Codea/portfolio.txt', parseData) | |
end | |
-- This function gets called once every frame | |
function draw() | |
downloadsThisFrame = 0 | |
waitChar = waitChar + .3 | |
if waitChar > 155.9 then waitChar = 145 end | |
waitText = string.char(240,159,149,waitChar) | |
-- This sets a dark background color | |
background(0, 0, 0, 255) | |
if math.abs(view.offsetDelta) > .2 then | |
textOpacity = textOpacity + 1500 | |
else | |
textOpacity = textOpacity * .95 | |
end | |
textOpacityClamped = math.min(textOpacity, 255) | |
view:draw() | |
if view.tapCount == 2 then | |
viewMode = viewMode - 1 | |
if viewMode < 0 then | |
viewMode = 0 | |
end | |
if viewMode == ALBUM then | |
view.offset = albumOffset | |
else | |
view.offset = topOffset | |
end | |
view.maxOffset = 0 | |
view.tapCount = 0 | |
view.touch = nil | |
view.framesSinceLastTouch = 0 | |
elseif view.tapCount == 1 and view.taptimer < 0 then | |
if viewMode == ALBUM then | |
albumOffset = view.offset | |
currentAlbum:touched(touch) | |
view.offset = 0 | |
textOpacity = 100000 | |
elseif viewMode == TOPVIEW then | |
tx = view.touch.x+view.offset | |
ty = view.touch.y | |
topOffset = view.offset | |
textOpacity = 100000 | |
for _, album in pairs(albums) do | |
if tx > album.minx and tx < album.maxx and ty > album.miny and ty < album.maxy then | |
if album ~= currentAlbum then | |
for _, photo in pairs(currentAlbum.photos) do | |
photo.photo = "" | |
photo.downloaded = 0 | |
end | |
collectgarbage() | |
end | |
currentAlbum = album | |
currentPhoto = album.photos[1] | |
viewMode = ALBUM | |
break | |
end | |
end | |
view.offset = 0 | |
elseif viewMode == PHOTO then | |
viewMode = ALBUM | |
view.offset = albumOffset | |
end | |
view.maxOffset = view.offset | |
view.tapCount = 0 | |
view.touch = nil | |
view.framesSinceLastTouch = 0 | |
collectgarbage() | |
return | |
end | |
if viewMode == TOPVIEW then | |
for _, album in pairs(albums) do | |
album:draw() | |
end | |
pushMatrix() | |
translate(0,0,5) | |
fill(92, 92, 92, 255) | |
strokeWidth(0) | |
rect(0,0,500,HEIGHT) | |
fill(255, 255, 255, 255) | |
fontSize(32) | |
textAlign(LEFT) | |
text(globalTitle, 20, HEIGHT/2+100) | |
textWrapWidth(460) | |
fontSize(15) | |
sx,sy = textSize(globalComment) | |
text(globalComment, 20, HEIGHT/2+90-sy) | |
textWrapWidth(0) | |
popMatrix() | |
elseif viewMode >= ALBUM then | |
if currentAlbum ~= nil then | |
currentAlbum:draw() | |
end | |
end | |
if viewMode == PHOTO then | |
if currentPhoto ~= nil then | |
currentPhoto:draw() | |
end | |
end | |
--[[ | |
waiting = true | |
if waiting then | |
waitingAngle = waitingAngle + 5 | |
pushMatrix() | |
translate(view.offset+WIDTH/2, HEIGHT/2) | |
rotate(waitingAngle) | |
sprite("Space Art:Eclipse", 0, 0, 200) | |
popMatrix() | |
end | |
]]-- | |
--pushMatrix() | |
--fill(255, 255, 255, 255) | |
--fontSize(20) | |
--text(math.floor(10/DeltaTime)/10, view.offset + 5,HEIGHT-30) | |
--text(view.maxOffset, view.offset + 100, HEIGHT-30) | |
--text(view.framesSinceLastTouch, view.offset + 100, HEIGHT-30) | |
--popMatrix() | |
if newPhoto ~= nil then | |
currentPhoto = newPhoto | |
newPhoto = nil | |
end | |
end | |
function touched(touch) | |
view:touched(touch) | |
end | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Photo = class() | |
function Photo:init(x) | |
-- you can accept and set parameters here | |
self.title = "" | |
self.photo = "" | |
self.prev = nil | |
self.next = nil | |
self.url = "" | |
self.filename = "" | |
self.downloaded = 0 | |
self.x = 0 | |
self.y = 0 | |
self.size = 1 | |
self.displayX = 0 | |
self.displayY = 0 | |
self.displaySize = 1 | |
self.opacity = 1 | |
self.minx = 0 | |
self.maxx = 0 | |
self.miny = 0 | |
self.maxy = 0 | |
self.maxOffset = 100 | |
self.sizeincrement = 0 | |
self.whenToZoom = math.random(100, 3000) | |
end | |
function Photo:download() | |
if self.downloaded == 0 then | |
self.downloaded = 1 | |
downloadsThisFrame = downloadsThisFrame + 1 | |
downloadTimer = 0 | |
local theImage = readImage("Documents:" .. self.filename) | |
--local theImage = readImage("Cargo Bot:Background Fade") | |
if theImage == nil then | |
print("downloading "..self.filename) | |
http.request(self.url, function(theImage, status, head) | |
if type(theImage) == "userdata" then | |
self.photo = theImage | |
saveImage("Documents:" .. self.filename, theImage) | |
print("saved " .. self.filename) | |
else | |
print("image " .. self.filename .. " not found.") | |
end | |
end) | |
else | |
self.photo = theImage | |
end | |
end | |
end | |
function Photo:draw() | |
if downloadsThisFrame < 1 then | |
self:download() | |
end | |
if viewMode == ALBUM and self.minx < WIDTH+view.offset and self.maxx > view.offset then | |
if view.framesSinceLastTouch > self.whenToZoom then | |
self.sizeincrement = math.min(self.sizeincrement + .1, 100) | |
else | |
self.sizeincrement = 0 | |
end | |
self.displayX = self.x-self.sizeincrement/2 | |
self.displayY = self.y-self.sizeincrement/2 | |
self.displaySize = self.size + self.sizeincrement | |
pushMatrix() | |
clip(self.x-view.offset,self.y,self.size,self.size*2/3) | |
if self.photo == "" then | |
pushMatrix() | |
translate(self.size/2-15,self.size/3-15,5) | |
fill(127, 127, 127, 255) | |
font("AppleColorEmoji") | |
fontSize(30) | |
text(waitText, self.x, self.y) | |
font("Futura-Medium") | |
popMatrix() | |
end | |
sprite(self.photo, self.displayX, self.displayY, self.displaySize) | |
clip() | |
stroke(0, 0, 0, 255) | |
translate(0,0,1) | |
strokeWidth(5) | |
line(self.minx-2,self.miny,self.maxx+2,self.miny) | |
line(self.minx-2,self.maxy,self.maxx+2,self.maxy) | |
line(self.minx,self.miny-2,self.minx,self.maxy+2) | |
line(self.maxx,self.miny-2,self.maxx,self.maxy+2) | |
if view.maxOffset < self.x+self.size-WIDTH then | |
view.maxOffset = self.x+self.size-WIDTH | |
end | |
popMatrix() | |
fontSize(10) | |
pushMatrix() | |
fill(0, 0, 0, textOpacityClamped) | |
translate(5, 2, 2) | |
text(self.title, self.x, self.y) | |
translate(-1, 1, 2) | |
fill(255, 255, 255, textOpacityClamped) | |
text(self.title, self.x, self.y) | |
popMatrix() | |
elseif viewMode == PHOTO then | |
local p = self.photo | |
pushMatrix() | |
fill(53, 53, 53, textOpacityClamped) | |
translate(5, 2, 2) | |
fontSize(20) | |
textAlign(RIGHT) | |
text(self.title, 45, HEIGHT/2 - WIDTH/3 - 10) | |
translate(-1, 2, 2) | |
fill(200,200,200, textOpacityClamped) | |
text(self.title, 45, HEIGHT/2 - WIDTH/3 - 10) | |
popMatrix() | |
if self.next ~= nil then | |
if view.offset > 75 and view.scrollTimer > 50 then | |
newPhoto = self.next | |
view.offset = 70-WIDTH | |
view.scrollTimer = 0 | |
end | |
sprite(self.next.photo, WIDTH+10, HEIGHT/2 - WIDTH/3 + 30, WIDTH-90) | |
end | |
if self.prev ~= nil then | |
if view.offset < -75 and view.scrollTimer > 50 then | |
view.offset = WIDTH-70 | |
newPhoto = self.prev | |
view.scrollTimer = 0 | |
end | |
sprite(self.prev.photo, 80-WIDTH, HEIGHT/2 - WIDTH/3 + 30, WIDTH-90) | |
end | |
sprite(p, 45, HEIGHT/2 - WIDTH/3 + 30, WIDTH-90) | |
end | |
end | |
function Photo:touched(touch) | |
end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
function rssLoaded(data, status, headers) | |
album = "Water Molotov" | |
if albums[album] ~= nil then | |
olddata = readLocalData("photoblog", "") | |
if data == olddata then | |
return | |
end | |
albums[album] = nil | |
collectgarbage() | |
end | |
saveLocalData("photoblog", data) | |
albums[album] = Album() | |
albums[album].title = album | |
albums[album].x = photox*0 + 500 | |
albums[album].y = photoy*0 | |
albums[album].size = photox*2 | |
albums[album].displaySize = photox*2 | |
albums[album].iconindex = 1 | |
albums[album].comment = "Water Molotov is my photoblog.\nIt's a silly name. I've been posting one photo per day since early 2005. These are the last twenty." | |
albums[album].minx = albums[album].x | |
albums[album].miny = albums[album].y | |
albums[album].maxx = albums[album].x + albums[album].size | |
albums[album].maxy = albums[album].y + albums[album].size*2/3 | |
layout = {{0,2,3},{0,0,2},{2,0,2},{3,3,2},{3,2,1},{4,0,3},{5,3,2},{7,3,2},{7,2,1},{8,2,1},{7,0,2},{9,4,1},{10,4,1},{9,2,2},{9,0,2},{11,0,1},{12,0,1},{11,1,2},{11,3,2},{13,0,2}} | |
obj, pos, err = json.decode(data) | |
xpos = 0 | |
ypos = 0 | |
sizefactor = 1. | |
pn = 1 | |
for j = 1, #obj do | |
-- Extract filename from content string | |
i=0 | |
s = obj[j].content | |
st1,en1 = string.find(s, "title") | |
if st1 ~= nil then | |
s2 = string.sub(s,en1+8) | |
st2 = string.find(s2, ";") | |
if st2 ~= nil then | |
s3 = string.sub(s2, 1, st2-6) | |
p = Photo() | |
p.url = "http://photoblog.jbuhler.com/wp-content/uploads/" .. s3 .. ".jpg" | |
p.filename = s3 | |
p.title = obj[j].title | |
p.x = layout[pn][1]*photox + 300 | |
p.y = layout[pn][2]*photoy | |
p.size = layout[pn][3]*photox | |
p.displaySize = p.size | |
p.minx = p.x | |
p.miny = p.y | |
p.maxx = p.x + p.size | |
p.maxy = p.y + p.size*2/3 | |
if p.url ~= "" then | |
table.insert(albums[album].photos, p) | |
pn = pn + 1 | |
ypos = ypos + 1 | |
if ypos > 4 then | |
ypos = 0 | |
xpos = xpos + 1 | |
end | |
end | |
end | |
end | |
end | |
ss = json.encode(albums[album]) | |
for i = 1, #albums[album].photos do | |
if i > 1 then | |
albums[album].photos[i].prev = albums[album].photos[i-1] | |
end | |
if i < #albums[album].photos then | |
albums[album].photos[i].next = albums[album].photos[i+1] | |
end | |
end | |
end | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
View2D = class() | |
function View2D:init() | |
self.offset = 300 | |
self.maxOffset = 0 | |
self.offsetDelta = 0 | |
self.offsetDeltaHard = 0 | |
self.oldOffset = 0 | |
self.touch = nil | |
self.moving = false | |
self.timer = 60 | |
self.taptimer = 10 | |
self.scrollTimer = 0 | |
self.started = false | |
self.started2 = false | |
self.tapCount = 0 | |
self.minx = 0 | |
self.maxx = WIDTH | |
self.miny = 0 | |
self.maxy = HEIGHT | |
self.framesSinceLastTouch = 0 | |
end | |
function View2D:draw() | |
self:processTouches() | |
self.timer = self.timer - 1 | |
self.taptimer = self.taptimer - 1 | |
self.framesSinceLastTouch = self.framesSinceLastTouch + 1 | |
self.scrollTimer = self.scrollTimer + 1 | |
--if not self.moving then | |
self.offset = self.offset - self.offsetDelta | |
if self.offset < 0 then | |
self.offset = self.offset / 1.1 | |
self.offsetDelta = 0 | |
elseif self.offset > self.maxOffset then | |
self.offset = self.maxOffset + (self.offset-self.maxOffset)/1.1 | |
self.offsetDelta = 0 | |
elseif viewMode == ALBUM and self.offset>150 and self.offset<350 then | |
self.offset = 300 + (self.offset-300)/1.05 | |
elseif viewMode == TOPVIEW and self.offset>250 and self.offset<550 then | |
self.offset = 500 + (self.offset-500)/1.05 | |
end | |
--else | |
--if self.offset < 0 or self.offset > self.maxOffset then | |
-- self.offsetDelta = self.offsetDelta / 2 | |
--self.offset = self.offset - self.offsetDelta | |
--end | |
--end | |
ortho(self.offset, WIDTH+self.offset, 0, HEIGHT, -10, 10) | |
if not self.moving then | |
self.offsetDelta = self.offsetDelta * .9 | |
end | |
end | |
function View2D:touched(touch) | |
if CurrentTouch.state == ENDED and self.timer < 0 then | |
self.touch = touch | |
self.taptimer = 30 | |
else | |
if CurrentTouch.state == MOVING then | |
self.moving = true | |
self.offsetDelta = CurrentTouch.deltaX | |
self.offsetDeltaHard = CurrentTouch.deltaX | |
self.timer = 30 | |
else | |
self.moving = false | |
end | |
end | |
end | |
function View2D:processTouches() | |
if self.touch ~= nil then | |
self.tapCount = self.touch.tapCount | |
end | |
end |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment