function getBackgroundPage(id, src) {

    // get the firefox hidden window
    var win = Components.classes["@mozilla.org/appshell/appShellService;1"].
                   getService(Components.interfaces.nsIAppShellService).
                   hiddenDOMWindow;

    // if the iframe was previously loaded store it and callback
    var iframe = win.document.getElementsById(id);
    if (iframe)
      return iframe.contentWindow;

    // create the iframe
    iframe = win.document.createElement("iframe");
    iframe.setAttribute("id", id);
    iframe.setAttribute("style", "display:none;");

    // load the source
    iframe.setAttribute("src", src);
    win.document.documentElement.appendChild(iframe);

    // return the content window
    return iframe.contentWindow;

Now you can access your background page by including the script in your overlay and doing:

  var bgp = getBackgroundPage("id for background page", "url of the background page");

** UPDATE **
instead of setting the style to display:none you should instead set the attribute “collapsed” to true. This causes docshell errors in some cases.

iframe.setAttribute(“style”, “display:none;”);
iframe.setAttribute(“collapsed”, “true”);

After much trial and error the website for my company “Web Tech Studios” is now live. Please, look it over and let me know what you think. You can also follow me on twitter @webtechstudios.

With Firefox 3.5 we were able to fix this by creating the diamond using only html and some specialized css tags. Using the tags: -moz-transform, -moz-border-radius, and -moz-box-shadow we rotate the div 45 degrees and add a shadow to them.

  display: inline-block !important;
  border: 2px solid #494949 !important;
  background: none !important;
  background-color: white !important;
  -moz-transform: rotate(45deg) !important;
  -moz-border-radius: 4px !important;
  -moz-box-shadow: grey 2px 2px 2px !important;

This also rotates the content within the div. To fix that we rotate the image back 45 degrees.

  -moz-transform: rotate(-45deg) !important;

And viola, a diamond with all the html event goodness, made with only html and css. Safari and Chrome support these transforms with -webkit-transform so this same effect can be used there.

First create a file called template.py in your application. Then we create a method that will cache a template when called and return the rendered template.

from django.template import Context, loader

template_cache = {}
def render_cached(template_name, dictionary=None):
    global template_cache

    t = template_cache.get(template_name, None)
    if not t or settings.DEBUG:
        template_cache[template_name] = t = loader.get_template(template_name)

    dictionary = dictionary or {}
    context_instance = Context(dictionary)
    return t.render(context_instance)

This method takes two arguments the template name and a dictionary to use for the template context. It first gets the template out of the cache. It then looks if the template was retrieved or if your debug setting is on. If either of these cases exist, it uses the base django loader to retrieve the parsed template and store it in the cache dictionary. Then we create a context instance for the dictionary and return the rendered code.

To be able to use the method you just import and call it.

from template import render_cached
html = render_cached("sometemplate.html", {})

• New Search Clovers for selection based searching functionality
• Updated Bing provider
• Updated compatibility for ff 3.6betas
• Improve sqlite performance
• Trim leading and trailing spaces from searches to improve accuracy
• Updated kwiclick skin
• Replace getBoxObjectFor with getBoundingClientRect
• Clover preferences to fine tune functionality
• Turn on/off clover from statusbar button
• Updated wikipedia provider increases accuracy of searching and results

Here is the video for the 2.4 release which was submitted to the extend firefox contest. This is a pretty good explanation of the things you can do with KwiClick.

I install the Gecko 1.9.1 SDK from developer.mozilla.org. I then install libidl using the following commands in MacPorts:

sudo port selfupdate
sudo port sync
sudo port install libidl

Now, when I run my build script I get the error:

     [exec] dyld: Library not loaded: /opt/local/lib/libIDL-2.0.dylib
     [exec]   Referenced from: /Developer/xulrunner-sdk-1.9.1/bin/xpidl
     [exec]   Reason: no suitable image found.  Did find:
     [exec] 	/opt/local/lib/libIDL-2.0.dylib: mach-o, but wrong architecture

Figuring that libidl is compiled as 64 bit and the gecko sdk is 32 bit, I go searching the web. This leads me to a forum post on compiling Camino on Snow Leopard.

Mac OS 10.6 is 64-bit as native, while Camino is far from 64-bit ready. So cross-compiling to 32-bit is required.
First hurdle was to cross-compile and install the required libIDL library, in 32-bit. Luckily MacPorts contain a universal libIDL, so after I got the hint about “versions” I got that going using the command – “sudo port install libIDL +universal”.

Alright, so now I’m trying to install the universal libIDL file and I hit another error.

Command output:       _IDL_inhibit_get in libIDL_2_la-parser.o
      _IDL_queue_new_ident_comment in libIDL_2_la-parser.o
      _IDL_file_set in libIDL_2_la-parser.o
      ___IDL_do_pragma in libIDL_2_la-parser.o
      _IDL_ns_scope_levels_from_here in libIDL_2_la-ns.o
      _IDL_tree_properties_copy in libIDL_2_la-util.o
      _IDL_tree_walk2 in libIDL_2_la-util.o
      _IDL_tree_to_IDL in libIDL_2_la-util.o
      _IDL_tree_get_scope in libIDL_2_la-util.o
      _IDL_tree_remove_inhibits in libIDL_2_la-util.o
      _IDL_tree_property_remove in libIDL_2_la-util.o
      _IDL_tree_property_get in libIDL_2_la-util.o
      _IDL_tree_property_set in libIDL_2_la-util.o
  "_g_log", referenced from:
      _IDL_check_type_cast in libIDL_2_la-util.o
      _IDL_tree_walk_real in libIDL_2_la-util.o
      _IDL_tree_walk_real in libIDL_2_la-util.o
      _IDL_emit_IDL_literal in libIDL_2_la-util.o
      _IDL_tree_get_node_info in libIDL_2_la-util.o
      _IDL_tree_get_scope in libIDL_2_la-util.o
      _IDL_tree_remove_empty_modules in libIDL_2_la-util.o
      _IDL_tree_remove_inhibits in libIDL_2_la-util.o
      _IDL_tree_process_forward_dcls in libIDL_2_la-util.o
      _load_inhibits in libIDL_2_la-util.o
      _IDL_tree_free in libIDL_2_la-util.o
ld: symbol(s) not found
collect2: ld returned 1 exit status
make[2]: *** [libIDL-2.la] Error 1
make[1]: *** [all-recursive] Error 1
make: *** [all] Error 2

Here is where I’m stuck. I have no idea what symbols are missing. Please, leave me a comment if you have any ideas on how to make this work.

** Update **
This is what I did to get this to work.

sudo port -f uninstall installed
sudo port install libIDL universal

• Mediacom is not available in my area.
• Qwest dial-up service is the only thing available.
• Verizon is not available in my area.
• Verizon mobile broadband is available for $59.99 a month with a maximum 5GB per month.
• Iowa Telecom needs a phone number to find out if it’s available.
• Hughes Net costs 7 times as much for a comparable package.
• Wild Blue offers a package for $79.95 that is 1/5th the speed and has a maximum 17GB per month.

View House Locations in a larger map

An interesting side note: I started working on this post over the weekend. OM Malik has two stories today about the state of broadband in the US.

• Broadband Growth Falls Sharply in the U.S.
• What My Daughter’s Broken Leg Taught Me About Broadband
• Update: Another great story about rural broadband.
  Rural broadband = more jobs, better salaries

Dogpiling occurs when an entry in the cache expires. If you get multiple requests for that cached item before it’s new value can be calculated, you end up with attempts from each of those requests to refresh the cache. To prevent this, we are going to work from the MintCache implementation that stores slightly stale data to pass on to requests while the first request for expired data calculates the new value to store in the cache.

The magic to make this happen is in two methods added to the CacheClass, pack_values and examine_values. The pack_values method is used to pack the necessary data so it can be stored in the cache and examine_value is used when data is retrieved from the cache to see if it is expired.

    def pack_values(self, value, timeout, refreshed=False):
        refresh_time = (timeout or self.default_timeout) + time.time()
        real_timeout = (timeout or self.default_timeout) + 30
        stored_value = value
        if isinstance(value, unicode):
            stored_value = value.encode('utf-8')
        return (real_timeout, (stored_value, refresh_time, refreshed))

    def examine_value(self, fixed_key, packed, default=None):
        if packed is None:
            return default

        value, refresh_time, refreshed = packed
        if (time.time() > refresh_time) and not refreshed:
            # Store the stale value while the cache revalidates for another
            # 30 seconds.
            real_timeout, packed = self.pack_values(value, 30, True)
            self._cache.set(fixed_key, packed, real_timeout)
            return None

        if isinstance(value, basestring):
            return smart_unicode(value)
        return value

Add calls to these methods from the base methods and your done.

    def add(self, key, value, timeout=0):
        fixed_key = self.fix_key(key)
        real_timeout, packed = self.pack_values(value, timeout)
        return self._cache.add(fixed_key, packed, real_timeout)

    def get(self, key, default=None):
        fixed_key = self.fix_key(key)
        packed = self._cache.get(fixed_key)
        return self.examine_value(fixed_key, packed, default)

    def set(self, key, value, timeout=0):
        fixed_key = self.fix_key(key)
        real_timeout, packed = self.pack_values(value, timeout)
        self._cache.set(fixed_key, packed, real_timeout)

    def delete(self, key):
        fixed_key = self.fix_key(key)
        self._cache.delete(fixed_key)

    def get_many(self, keys):
        fixed_keys = map(self.fix_key, keys)
        cache_dict = self._cache.get_multi(fixed_keys)
        final_dict = {}
        for fixed_key, packed_value in cache_dict.iteritems():
            key = keys[fixed_keys.index(fixed_key)]
            final_dict[key] = self.examine_value(fixed_key, packed_value)
        return final_dict

Memcached has a couple of limitations it sets on keys. Currently the length limit of a key is set at 250 characters and the key must not include control characters or whitespace. These limitations can be a problem when dealing with long permalinks or rendered template nodes. First thing we need to do is create a method that will fix keys.

def fix_key(self, key):
    from django.utils.encoding import smart_str
    import md5

    cache_key = re.sub(r'\s+', '-', key)
    cache_key = smart_str(cache_key)
    if len(cache_key) > 250:
        cache_key = cache_key[:200] + '-' + md5.new(cache_key).hexdigest()
        return cache_key

This method will replace whitespaces with dashes and limit the key length so that it never exceeds the 250 limit set by memcached. Now we just have to change the methods on CacheClass so that they call fix_key and pass the newly generated key into memcached calls.

The method get_many takes some special consideration. This method takes a list of keys and returns a dictionary of key value pairs. This means fix_key needs to be called on all keys passed into the list. Memcached will return a dict with the fixed keys so they must be translated back to the original keys.

def get_many(self, keys):
    fixed_keys = map(self.fix_key, keys)
    cache_dict = self._cache.get_multi(fixed_keys)
    final_dict = {}
    for fixed_key, value in cache_dict.iteritems():
        key = keys[fixed_keys.index(fixed_key)]
        final_dict[key] = value
    return final_dict

Now your shouldn’t have to worry about cache keys in your django application. Continue on to part III