The large format screen and familiar iPhone OS were easy to get acquainted with. The touch interface and keyboard is much easier to thumb type with. The A4 CPU feels much faster and scrolling is quite smooth. I am still trying out different apps to find what works well for my needs but so far the redesigned mail application is truly an experience.

Netflix has a free application for the iPad and iPhone that allows subscribers to watch their instant watch library via the app. It is a great way to watch movies on the go or without turning on a computer. The built in Youtube app is also great for those who like independent content.

Drawing programs are another breed of fun applications. There are many to choose from, but a good price to feature app is ArtStudio. The $0.99 price belies the advanced features found on this app. With layer support (up to 3 layers), brushes and image import/export, you can save to your photos or email them to others.

News readers are another really excellent group of apps. Many newspapers have free apps allowing easy access to their content. I haven’t gotten a chance to check out most of them, but the WSJ app is pretty nice. The interface takes a little getting used to, but once you get the hang of it, it is far superior to searching thru the printed version. SkyGrid is another news aggregator and allows searching multiple sources for recent news.

Back to the post topic. Wordpress is a popular blogging software (which powers this blog), and this post is being written on their iPad app. The app is open source as well, so if you are interested in developing iPhone/iPad apps, you can start by checking out the code. My complaint about this app is the save feature is a little broken. This is my third attempt at writing this post. When you click the home button, it seems to recover your changes, but when you hit save, it reverts to the older version. So hit Save before you go play a tune.

-Huey

Wanting to use it for my own photos, I couldn’t wait to get started. Since I already have a bunch of my own photos hosted using Gallery2, I decided to see if I could hook up an RSS feed and get it running quickly. Unfortunately the default installation of the RSS plugin with Gallery2 didn’t support media rss. My plugin version was a bit outdated so first I had to upgrade it.

Being new to Gallery2 development, I had to take a little bit and familiarize myself with the code. The code structure is very well done and was pretty easy to start seeing what needed to be done. I wanted to stick with the existing convention and not break anything unintentionally, so I made copies where needed and was careful about what I changed in shared files.

The code is located mostly under the /modules directory. The /core sub-directory contains the Gallery core files. What we’re interested in lies in /rss. Makes sense right? First thing I did was to make a examine the existing usage. When viewing an album via a browser, the RSS feed link shows that the resource is accessed via g2_view=rss.SimpleRender. So I made a copy of /rss/SimpleRender.inc to /rss/MediaRss.inc. My original version of the RSS plugin did not have any support for the media rss format, but the latest update does. That helps make my task a LOT easier, but there is still more to do.

1. Add the ‘useMedia’ parameter and the page variable to the params array.
   
   $params['useCloud'] = false;
   $params['useMedia'] = true;

   $params['page'] = GalleryUtilities::getRequestVariables('page');
$ret = $this->continueRender($params);


Next, we need to examine the other classes that are used to support the feed generation. Looking under the /classes directory (/modules/rss/classes), we see two that catch the eye immediately. RssHelper.class and RssGenerator.class.

RssHelper.class generates the SQL which is used to find items to show in the feed. One of the main things missing here is the ability to paginate results. So let’s add it! In the getFeed function, find the function call for fetchAlbumTree and make the following change:
From
RssHelper::fetchAlbumTree(
$entity->getId(),
$param['count'],
$newOnly,
$param['feedType'] != 'album',
$param['feedType'] == 'photosRecursive' ? $param['photosRecursiveLimit'] : 0,
$param['feedType'] == 'photosRandomRecursive');

To
RssHelper::fetchAlbumTree(
$entity->getId(),
array('count' => $param['count'], 'offset' => $param['offset']),
$newOnly,
$param['feedType'] != 'album',
$param['feedType'] == 'photosRecursive' ? $param['photosRecursiveLimit'] : 0,
$param['feedType'] == 'photosRandomRecursive');


We’ll put in the calculations for the offset in a bit. First we worry about how to make sure it’s used. In the ‘fetchAlbumTree’ function, we need to check the $limit parameter and use it to set the offset.

if (isset($limit)) {
$params['limit'] = array('count' => $limit);
}

Becomes

if (isset($limit)) {
if (is_array($limit)) $params['limit'] = $limit;
else $params['limit'] = array('count' => $limit);
}
}

The offset parameter is now used in the $gallery->search call. Now, I thought I was all done, but when reviewing the response, I noticed the media:thumbnail url was set the same as the description. This resulted in Cooliris not being able to pull in the thumbnails for the wall. The bug is in the RssHelper.class code, function addPhotoOrAlbum. Here is the change:

$itemSettings['thumbnail']['url'] = $url;
SHOULD BE
$itemSettings['thumbnail']['url'] = $imageUrl;


RssGenerator.class does just that. Depending on the version of RSS and whether you are ‘useMedia’, it generates the correct response XML document for feed readers. There are a few changes here.

1. Add a ‘default’ statement to function generate() so we use 2.0 by default
   
case '2.0':
default:
return $this->generate200();
break;

2. Because we want pagination of our results, for the infinite wall experience in cooliris, we need to determine the next and previous feed URLs. We will use an Apache rewrite rule for a pretty URL, so here’s the code to generate the links based on the current URL.
   

        $platform =& $gallery->getPlatform();
         $lf = $platform->getLineEnding();
   
         if (isset($this->_properties['useMedia']) && $this->_properties['useMedia'] == 1) {
           $generator = $gallery->getUrlGenerator();
           //GalleryUtilities::putRequestVariable('page', 4);
           $current = $generator->getCurrentRequestUri();
           $matches = array();
           if (preg_match("#media(\d*).rss$#", $current, $matches)) {
             $curPage = $matches[1];
             if (intval($curPage) < 1) {
               $curPage = 1;
             }
             $nextPage = $generator->makeUrl($current);
             $nextPage = preg_replace("#media\d*.rss#", "media" . ($curPage + 1) . ".rss", $nextPage);
             if ($curPage > 1) {
               $prevPage = $generator->makeUrl($current);
               $prevPage = preg_replace("#media\d*.rss#", "media" . ($curPage - 1) . ".rss", $prevPage);
             }
           }
   
           $multiPage = <<<MULTIPAGE
       <atom:link rel="previous" href="$prevPage" />
       <atom:link rel="next" href="$nextPage" />
   MULTIPAGE;
         }

3. Since we’re using ATOM, we need to tell setup the XML namespace in our response.
   
if (isset($this->_properties['useMedia']) && $this->_properties['useMedia'] == 1) {
$data = '';
}

4. Finally, we add the links into the response right after the link tag.
   
' ' . $this->_properties['link'] . '' . $lf .
$multiPage . $lf .
'' .


5. All this, but we’re not handling the pages correctly during the request. What we’re missing is the ability to control where the slice happens. Open up Render.inc in the /modules/rss/ directory and find where $generator->sliceItems($count); is being called. We have already changed RssHelper::getFeed to handle the SQL offset, all we need is to set the ‘offset’ variable.
   

       if (isset($params['page']) && $params['page'] > 1) {
           $start = ($params['page'] - 1) * $count;
       } else {
           $start = 0;
       }
       $params['count'] = $count;
       $params['offset'] = $start;
   
       $generator = new RssGenerator();
   

Pretty SEO URLs

We want to present easy to understand URLs to any spider. Instead of /main.php?g2_view=rss.MediaRss&g2_itemId=xxxx….., let’s do something like the /v/album1/subAlbum/ style URL. Of course, the Cooliris embed wall only seems to like urls that end in .rss which means we MUST do this step.

If we take a look at the existing rewrite rule for Paths, we can just modify their scheme to fit our needs.

RewriteCond %{THE_REQUEST} /gallery/v/([^?]+)(\?.|\ .)
RewriteCond %{REQUEST_URI} !/gallery/main\.php$
RewriteRule . /gallery/main.php?g2_path=%1 [QSA,L]

Now it look simply like everything after /gallery/v/ and before query parameters is dumped into a g2_path variable. We need the same thing except we must also check the page that we are on. I settled on a URL like:
/gallery/m/album_path_info/media2.rss
Here, we use the same path method that View does and we have additional page information after media. Our rewrite rule would look something like:

RewriteCond %{REQUEST_URI} /gallery/m/([^?]+)/media(\d*).rss
RewriteRule . /gallery/main.php?g2_view=rss.MediaRss&g2_path=%1&g2_page=%2 [QSA,L]


That’s pretty much it. We can now access any of our albums with a media.rss feed that allows pagination and viewing in Cooliris’s Embed Wall.

For future enhancements, it should be possible to hook up the album navigation thru Javascript and have a seamless interface suitable for a Gallery2 Theme.

Maybe I’ll do that for fun next weekend.
-Huey

In my Action file, I add actions to the stack for nav, footer, etc.

class IndexController extends ....
{
function indexAction()
{
$this->_helper->actionStack('main', 'nav', 'default');
$this->_helper->actionStack('footer', 'nav', 'default');
$this->_helper->actionStack('right', 'nav', 'default');
/* other stuff */
}
}


Then I have a NavController that simply calls setResponseSegment or renderScript to set the named variables.


class NavController ..
{
function footerAction()
{
/* Stuff to display */
$this->renderScript('nav/footer.phtml', 'nav');
// Or I could use
// $this->_helper->viewRenderer->setResponseSegment('nav');
}
}


This allows me to finally use the nav variable in my layout file
layout/default.phtml

echo $this->layout()->nav;

Simple eh?

Basically I have a ConfigDB singleton pattern that gets one db connection, then sets the default adapter so when I extend the Zend_DB_Table_Abstract class, the default connection gets carried around.

class ConfigDB {
static private $instance;
private function __construct() {
}
public static function getInstance() {
if (!ConfigDB::$instance) {
$params = array(
/* redacted */
);
ConfigDB::$instance = Zend_Db::factory('Mysqli', $params);
Zend_Db_Table_Abstract::setDefaultAdapter(ConfigDB::$instance);
}
return ConfigDB::$instance;
}
public static function selectDb($db) {
return ConfigDB::$instance->getConnection()->select_db($db);
}
}
ConfigDB::getInstance();

That grabs the connection and sets the default adapter. So in my model class I can do:
class Country extends Zend_Db_Table_Abstract {
protected $_name = 'countries';
protected $_primary = 'country_id';
function __construct($country = 1, $abbr = '')
{
parent::__construct();
}
}

That’s it

Monkey Do. Having recently downloaded and installed the GreaseMonkey plugin for FireFox, I searched and couldn’t find a suitable userscript to handle the situation. Being the obsessive type, I went ahead and wrote two quick scripts to help me get at the actual image urls. One, ‘Flickr Img Src Exposer‘, exposes the image url on an individual photo. It adds a link ‘IMG LINK’ underneath the image allowing for easy copying. The second script, ‘Flickr Download Links‘, works when you are exploring the last 7 days’ interesting photos. I got tired of clicking on each photo and then saving the image, so I put a ‘LINK’ under each photo in the page. Clicking on the link takes you to a gallery of all the available image sizes. You can click on the download link to get the image downloaded or copy the images source from the image displayed. The largest size may not be available and you’ll find out if so after clicking on it. I chose not to display the largest image size to save Flickr some bandwidth.

Monkey no get spaceball.gif. This has proved somewhat useful for me and I thought I’d share it with others. You can find the scripts on ‘http://userscripts.org‘.

This can be improved very easily. For example, instead of only searching Y! Shopping, the initial box can be a drop down menu populated with results from a text analysis tool. Then the user can perform a web/news/product search by following the corresponding links.

A key benefit to this implementation, any web publisher only needs to include a single (two at the moment) javascript reference in their header to receive this functionality. They don’t have to link terms by hand, or do any backend work to support this. They get better user experience and a richer webpage essentially for free.

Downloading the plugin

You can download the latest version on my plugin amazonLinker.tar.gz. I will be adding a version number as soon as I put it in my CVS respository.

Installation

1. uncompress the package and copy the results to <WordPress Directory>/wp-content/plugins/. You should end up with the following file <WordPress Directory>/wp-content/plugins/amazon/amazon-price.php
2. Login to your admin dashboard, click on Plugins and Activate the Amazon Product Linker
3. You’re done!

Usage

Simply add something like <asin>1580420818</asin> in your posts or pages and you will see the title and even prices being brought into your page. Here is what the above code looks like 1580420818. Currently, only Books gets special treatment but I will enhance the tool in the future to allow different displays for different product groups. Everything else just gets a title currently.

Happy Word Pressing!

If you don’t know what sudoku puzzles are, check out sudoku

Here is my javascript solution to sudoku puzzles

Update: I’ve modified my sudoku solver to be a generic sudoku puzzle. You can play it for free at www.numbercrazy.com.