materio-base-d7/sites/all/modules/contrib/admin/cobalt/js/cobalt.js

(function($) {
  $(document).ready(function(){
    var match_count = 0, match_page_size=5, match_offset = 0,
        cobalt_visible = false, cobalt_out_visible = false,
        matches = [], match_idx = 0, handler_idx = 0,
        current_text, current_action_text='', handler, item, actions, match_count=0,
        plugins = {}, plugin_names=[], catalogs = {}, global_handlers = [], handlers = {},
        update_queue = [], required_updates = [];

    var log_error = function(message, err) {
       if (typeof(window.console) != 'undefined') {
         console.error(message);
         if(err) {
          console.log(err);
         }
       }
    };

    var log_msg = function(message) {
       if (typeof(window.console) != 'undefined') {
         console.log(message);
       }
    };

    var db = null;
    // Initialize database
    if (!db && typeof(openDatabase)=='function') {
      try {
        db = openDatabase('cobalt', '1.0', 'Cobalt Database', 204800);
      }
      catch (err) {
        if (err.name === 'SECURITY_ERR') {
          log_msg(Drupal.t('Failed to open database using the Web SQL Database API due to a security-related error.'));
        }
        else {
          log_msg(Drupal.t('Failed to open database using the Web SQL Database API.'));
        }
      }
    }

    if (!db) {
      log_error(Drupal.t('Could not open a client-side database. Cobalt requires a browser that implements the Web SQL Database API.'));
      return;
    }

    var nullDataHandler = function(transaction, results) { };

    var current_state = function() {
      if (typeof(Drupal.settings.cobalt) != 'undefined' &&
          typeof(Drupal.settings.cobalt.state) != 'undefined') {
        return Drupal.settings.cobalt.state;
      }
      else {
        return 0;
      }
    };

    // Initialize Cobalt
    var cobalt = {
      'dbErrorHandler': function(transaction, error)
      {
        $(document).trigger('cobalt-db-error');
        if (window.console) {
          console.error(error.message+' (Code: '+error.code+')');
        }
        return false;
      },
      'registerPlugin': function(name, plugin) {
        plugin_names.push(name);
        plugins[name] = plugin;

        if(typeof(plugin['catalogs'])!='undefined') {
          for(var c_name in plugin.catalogs) {
            catalogs[c_name] = plugin.catalogs[c_name];
          }
        }

        if(typeof(plugin['handlers'])!='undefined') {
          var h_len = plugin.handlers.length;
          for(var i=0; i<h_len; i++) {
            register_handler(plugin.handlers[i]);
          }
        }
      },
      'catalogUpdated': function(catalog, updated) {
        if (typeof(updated)=='undefined') {
          updated = new Date().getTime();
        }
        db.transaction(function (transaction) {
          transaction.executeSql("UPDATE catalogs SET updated=?, state=? WHERE name = ?;", [ updated, Drupal.settings.cobalt.state, catalog ], nullDataHandler,cobalt.dbErrorHandler);
        });
      },
      'emptyCatalog': function(name) {
        db.transaction(function (transaction) {
          transaction.executeSql("DELETE FROM entries WHERE catalog=?;", [ name ], nullDataHandler,cobalt.dbErrorHandler);
        });
      },
      'addKeyBinding': function(binding, catalog, id, handler, active, state) {
        if (typeof(state)=='undefined') {
          state = current_state();
        }
        if (typeof(active)=='undefined') {
          active = 1;
        }
        bind_key(binding, catalog, id, handler);
        db.transaction(function (transaction) {
          transaction.executeSql("INSERT OR REPLACE INTO key_bindings(binding, catalog, id, handler, active, state) VALUES(?,?,?,?,?,?);", [ binding, catalog, id, handler, active, state ], nullDataHandler,cobalt.dbErrorHandler);
        });
      },
      'loadEntry': function(catalog, id, callback) {
        var state = current_state();
        db.transaction(function (transaction) {
          transaction.executeSql("SELECT * FROM entries WHERE catalog=? AND id=? AND state=?;", [ catalog, id, state ], function(transaction, results) {
            var item = null;
            if (results.rows.length) {
              item = results.rows.item(0);
              item.information = JSON.parse(item.data);
            }
            callback(item);
          },cobalt.dbErrorHandler);
        });
      },
      'deleteEntry': function(catalog, id) {
        db.transaction(function (transaction) {
          transaction.executeSql("DELETE FROM entries WHERE catalog=? AND id=?;", [ catalog, id ], nullDataHandler,cobalt.dbErrorHandler);
        });
      },
      'addTemporaryEntry': function(id, name, information, classname) {
        cobalt.addEntry({id:id, name:name, information:information, catalog:'*temporary*', classname:classname, active:1, state:current_state()});
      },
      'addEntry': function(data) {
        if (typeof(data.state)=='undefined') {
          data.state = current_state();
        }
        if (typeof(data.active)=='undefined') {
          data.active = 1;
        }
        if (typeof(data.extra)=='undefined') {
          data.extra = '';
        }
        db.transaction(function (transaction) {
          transaction.executeSql("INSERT OR REPLACE INTO entries(id, name, extra, data, catalog, data_class, state, active) VALUES(?,?,?,?,?,?,?,?);", [data['id'], data['name'], data.extra, JSON.stringify(data.information), data.catalog, data.classname, data.state, data.active], nullDataHandler,cobalt.dbErrorHandler);
        });
      },
      'actionCandidates': function(item, callback) {
        action_candidates(item, callback);
      },
      'showHtml': function(html) {
        if (typeof(html) == 'string') {
          cobalt_output.html(html);
        }
        else {
          cobalt_output.empty().append(html);
        }

        if (!cobalt_out_visible) {
          toggle_output();
        }
      }
    };

    if (typeof(Drupal.settings.cobalt) != 'undefined' && typeof(Drupal.settings.cobalt.update) != 'undefined') {
     cobalt.updateVersion = function(transaction, name, version) {
        transaction.executeSql('UPDATE versions SET version=? WHERE name=?', [version, name], nullDataHandler,cobalt.dbErrorHandler);
      };
      $(document).trigger('cobalt-update', [cobalt, db, Drupal.settings.cobalt.update]);
      return;
    }

    var register_handler_use = function(handler, item, transaction) {
      transaction.executeSql("INSERT OR IGNORE INTO handler_usage_data(catalog, id, handler, weight) VALUES(?,?,?,?)",
        [item.catalog, item.id, handler.id, 0], nullDataHandler, cobalt.dbErrorHandler);
      transaction.executeSql("UPDATE handler_usage_data SET weight=weight+1 WHERE catalog=? AND id=? AND handler=?",
        [item.catalog, item.id, handler.id], nullDataHandler, cobalt.dbErrorHandler);
      if (item.id) {
        handler.weight++;
        register_handler_use(handler, {id:0, catalog: ''}, transaction);
      }
    };

    var register_use = function(text, item, handler) {
      db.transaction(function (transaction) {
        register_handler_use(handler, item, transaction);
        transaction.executeSql("UPDATE usage_data SET last=null WHERE last = 1", [], nullDataHandler, cobalt.dbErrorHandler);
        if (item.weight == null) {
          // IGNORE in the rare event a handler that don't refresh the page
          // (e.g "show") is used multiple times and the weight initially was null.
          transaction.executeSql("INSERT OR IGNORE INTO usage_data(catalog, id, weight, abbreviation, last) VALUES(?,?,?,?,?)",
            [item.catalog, item.id, 1, text, 1], nullDataHandler,cobalt.dbErrorHandler);
        }
        else {
          transaction.executeSql("UPDATE usage_data SET weight=weight+1, abbreviation=?, last=1 WHERE catalog=? AND id=?",
            [text, item.catalog, item.id], nullDataHandler,cobalt.dbErrorHandler);
        }
      });
    };

    var register_handler = function(handler) {
      if (typeof(handler['data_class'])=='undefined') {
        handler['data_class'] = null;
      }

      handler.weight = 0;
      handler.context_weight = 0;

      // Get the weight of the handler
      db.transaction(function (transaction) {
        transaction.executeSql("SELECT weight FROM handler_usage_data WHERE catalog='' AND handler=?",
          [handler.id], function(transaction, results) {
            if (results.rows.length) {
              handler.weight = results.rows.item(0).weight;
            }
        });
      });

      if (!handler['data_class']) {
        global_handlers.push(handler);
      }
      else {
        if (!handlers[handler.data_class]) {
          handlers[handler.data_class] = [];
        }
        handlers[handler.data_class].push(handler);
      }
    };

    $(document).trigger('cobalt-load', cobalt);

    cobalt.registerPlugin('cobalt', {
      'version': 1,
      'handlers': [
        {
          'id': 'cobalt_show',
          'name': Drupal.t('Show'),
          'handler': function(text, item) {
            cobalt.showHtml('<h2>' + item.name + '</h2>' +
              Drupal.t('text') + ': <i>' + text + '</i><br/>' +
              Drupal.t('id') + ': ' + item.id + '<br/>' +
              Drupal.t('catalog') + ': ' + item.catalog + '<br/>' +
              Drupal.t('class') + ': ' + item.data_class + '<br/>' +
              Drupal.t('data') + ': ' + item.data + '<br/>' +
              Drupal.t('weight') + ': ' + item.weight);
          }
        },
        {
          'id': 'cobalt_abbrev',
          'name': Drupal.t('Assign shortcut'),
          'handler': function(text, item) {
            cobalt.actionCandidates(item, function(cand) {
              var out = $('<div class="shortcut-add"><h2>' + item.name + '</h2>' +
                Drupal.t('The keys !input should trigger the action:', {'!input': '<input class="key-combo" type="text" value="Ctrl+"/>'}) +
                '<br/> <select class="action-select"></select>' +
                '<p><button class="ok">' + Drupal.t('Ok') + '</button></p></div>');
              var actions = $(out).find('.action-select');
              var key_combo = $(out).find('.key-combo').css('width',50);
              var cand_count = cand.length;
              for(var i=0; i<cand_count; i++) {
                actions.append('<option value="' + cand[i].id + '">' + cand[i].name + '</option>');
              }

              $(out).find('button.ok').bind('click',function(){
                toggle_output('hide');
               cobalt.addKeyBinding(key_combo.val(), item.catalog, item.id, actions.val());
              });

              cobalt.showHtml(out);
              key_combo.focus();
            });
          }
        }
      ]
    });

    db.transaction(function (transaction) {
      transaction.executeSql('CREATE TABLE IF NOT EXISTS versions(' +
        'name TEXT NOT NULL, version INTEGER NOT NULL DEFAULT 0, ' +
        'CONSTRAINT pk_versions PRIMARY KEY(name));', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE TABLE IF NOT EXISTS entries(' +
        'catalog TEXT NOT NULL, id TEXT NOT NULL, name TEXT NOT NULL, extra TEXT DEFAULT "", data TEXT NOT NULL DEFAULT "", data_class TEXT NOT NULL, ' +
        'state INTEGER NOT NULL DEFAULT 0, active INTEGER NOT NULL DEFAULT 1, ' +
        'CONSTRAINT pk_entries PRIMARY KEY(catalog, id));', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('DELETE FROM entries WHERE catalog=?', ['*temporary*'], nullDataHandler, cobalt.dbErrorHandler);
      transaction.executeSql('CREATE TABLE IF NOT EXISTS key_bindings(' +
        'binding TEXT NOT NULL, catalog TEXT NOT NULL, id TEXT NOT NULL, handler TEXT NOT NULL, ' +
        'state INTEGER NOT NULL DEFAULT 0, active INTEGER NOT NULL DEFAULT 1, ' +
        'CONSTRAINT pk_bindings PRIMARY KEY(binding, state));', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE TABLE IF NOT EXISTS usage_data(catalog TEXT NOT NULL, id TEXT NOT NULL, ' +
        'weight INTEGER NOT NULL DEFAULT 0, abbreviation TEXT NOT NULL DEFAULT "", last INTEGER, ' +
        'CONSTRAINT pk_usage_data PRIMARY KEY(catalog, id));', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE TABLE IF NOT EXISTS handler_usage_data(catalog TEXT NOT NULL, id TEXT NOT NULL, ' +
        'handler TEXT NOT NULL, weight INTEGER NOT NULL DEFAULT 0,' +
        'CONSTRAINT pk_handler_usage_data PRIMARY KEY(catalog, id, handler));', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE INDEX IF NOT EXISTS idx_entries_catalog ON entries(catalog);', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE INDEX IF NOT EXISTS idx_entries_abbreviation ON usage_data(abbreviation);', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE INDEX IF NOT EXISTS idx_entries_active ON entries(active DESC);', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE INDEX IF NOT EXISTS idx_entries_weight ON usage_data(weight DESC);', [], nullDataHandler,cobalt.dbErrorHandler);
      transaction.executeSql('CREATE TABLE IF NOT EXISTS catalogs(' +
        'name TEXT NOT NULL PRIMARY KEY, updated INTEGER NOT NULL DEFAULT 0, state INTEGER NOT NULL DEFAULT 0, active INTEGER NOT NULL DEFAULT 1, uninstall INTEGER NOT NULL DEFAULT 0);', [], nullDataHandler,cobalt.dbErrorHandler);
    });

    var cobalt_output = $('<div id="cobalt-out"></div>').appendTo('body').hide();

    var bind_key = function (binding, catalog, id, handler) {
      $(document).bind('keydown', binding, function(){
        cobalt.loadEntry(catalog, id, function(item) {
          if (item) {
            cobalt.actionCandidates(item, function(cand){
              var cand_count = cand.length;
              for(var i=0; i<cand_count; i++) {
                if (cand[i].id == handler) {
                  cand[i].handler(item.name, item);
                }
              }
            });
          }
        });
      });
    };

    var toggle_output = function(arg) {
      if (cobalt_out_visible) {
        cobalt_output.hide();
        cobalt_out_visible = false;
      }
      else if (arg!='hide') {
        cobalt_output.show();
        cobalt_out_visible = true;
      }
    };

    var keypress_reaction = function() {
      if(cobalt_input.val()==current_text) {
        return;
      }
      current_text = cobalt_input.val();

      if($.trim(current_text)!='') {
        lookup();
      }
    };

    var action_keypress_reaction = function() {
      if(cobalt_h_input.val()==current_action_text) {
        return;
      }
      current_action_text = cobalt_h_input.val();

      action_candidates(item, function(candidates) {
        actions = candidates;
        set_handler(0, true);
      });
    };

    var clear_ac = function() {
      match_idx = 0;
      matches = null;
      item = 0;
      $('#cobalt .inner').attr('class','inner');
      $('#cobalt .inner label').hide();
      cobalt_ac.hide().empty();
      cobalt_paging.hide().empty();
    };

    var lookup = function(preserve_offset) {
      if (!preserve_offset) {
        match_offset = 0;
      }
      var like_expr = '%' + current_text + '%';
      db.transaction(function (transaction) {
        transaction.executeSql("SELECT e.*, u.weight FROM entries AS e " +
          "LEFT OUTER JOIN usage_data AS u ON (e.catalog=u.catalog AND e.id=u.id) " +
          "WHERE e.active=1 AND (u.abbreviation = ? OR e.name LIKE ? OR e.extra LIKE ?) " +
          "ORDER BY nullif(?,u.abbreviation), nullif(?,e.name), u.weight DESC LIMIT ?,?;", [
          current_text, like_expr, like_expr, current_text, current_text, match_offset, match_page_size ], lookup_finished,cobalt.dbErrorHandler);
      });
    };

    var lookup_finished = function(transaction, results) {
      if (results.rows.length) {
        match_idx = 0;
        $('#cobalt .left label').hide();
        cobalt_ac.empty().hide();
        for (var i=0; i<results.rows.length; i++) {
          var item = results.rows.item(i);
          item.information = JSON.parse(item.data);
          if (typeof(catalogs[item.catalog]) !='undefined' && typeof(catalogs[item.catalog].item_formatter) == 'function'){
            var title = catalogs[item.catalog].item_formatter(item);
          }
          else {
            var title = item.name;
          }
          $('<li class="ac-opt-' + i + '"></li>').html(title).appendTo(cobalt_ac);
        }
        matches = results.rows;

        //Only count for paging when we're not already offsetting the result and
        //have a match count equal to the page size
        if (match_offset) {
          update_pager(match_count);
        }
        else if (matches.length==match_page_size) {
          var like_expr = '%' + current_text + '%';
          db.transaction(function (transaction) {
            transaction.executeSql("SELECT COUNT(*) as match_count FROM entries AS e " +
              "LEFT OUTER JOIN usage_data AS u ON (e.catalog=u.catalog AND e.id=u.id) " +
              "WHERE e.active=1 AND (u.abbreviation = ? OR e.name LIKE ? OR e.extra LIKE ?);", [
              current_text, like_expr, like_expr], function(transaction, results) {
                if (results.rows.length) {
                  match_count = results.rows.item(0).match_count;
                  update_pager(match_count);
                }
              },cobalt.dbErrorHandler);
          });
        }
        else {
          update_pager(matches.length);
        }
        cobalt_ac.show();
      }

      ac_select(0);
    };

    var update_pager = function(new_match_count) {
      match_count = new_match_count;
      cobalt_paging.hide().empty();

      var page_count = Math.min(Math.ceil(match_count/match_page_size),25);
      for (var i=0; i<page_count; i++ ) {
        var p = $('<li>&nbsp;</li>').appendTo(cobalt_paging);
        if (i==match_offset/match_page_size) {
          p.attr('class','current');
        }
      }

      cobalt_paging.show();
    };

    var ac_page = function(new_offset) {
      if (new_offset>=match_count || new_offset<0) {
        return;
      }
      match_offset = new_offset;
      lookup(true);
    };

    var ac_select = function(idx) {
      if (idx<0 || idx >= matches.length) {
        item = null;
        return;
      }

      item = matches.item(idx);
      item.information = JSON.parse(item.data);
      var old_item = matches.item(match_idx);

      $('#cobalt .ac-opt-' + match_idx).removeClass('active');
      match_idx = idx;
      // Generate path specific classes that can be used for icons.
      // Matches the classes used in the Rubik admin theme.
      var classes = '';
      if (item.data_class === 'url_data') {
        var path = JSON.parse(item.data);
        if (typeof(path) == 'object') {
          path = path.path;
        }
        classes = [];
        var args = path.split('/');
        while(args.length) {
          classes[args.length - 1] = 'path-' + args.join('-');
          args.pop();
        }
        classes = classes.join(' ');
      };
      $('#cobalt .left .inner').attr('class','inner cobalt-item-' + item.data_class + ' ' + classes);
      $('#cobalt .left label').text(item.name).show();
      $('#cobalt .ac-opt-' + match_idx).addClass('active');

      action_candidates(item, function(candidates){
        actions = candidates;
        set_handler(0, true);
      });
    };

    var action_candidates = function(item, callback) {
      var candidates = [], gcount, i, j, cls_count, rc, cc, item,
        add_applicable = function(handler) {
          // Check if the handler matches the current_action_text (from closure),
          // or run the handlers own applicability check if it has one.
          if ((current_action_text=='' || handler['name'].toLowerCase().indexOf(current_action_text)!=-1) &&
              (!handler['applicable'] || handler.applicable(current_text, item))) {
            candidates.push(handler);
          }
        };

      // Add handlers for the items data class that match the current_action_text
      if (typeof(handlers[item.data_class])!='undefined') {
        cls_count = handlers[item.data_class].length;
        for (i=0; i<cls_count; i++) {
          add_applicable(handlers[item.data_class][i]);
        }
      }

      // Add global handlers that match the current_action_text
      g_count = global_handlers.length;
      for (i=0; i<g_count; i++) {
        add_applicable(global_handlers[i]);
      }

      // Load the usage data for the candidates so that we may sort them
      db.transaction(function (transaction) {
        transaction.executeSql("SELECT handler, weight FROM handler_usage_data WHERE catalog=? AND id=?",
          [item.catalog, item.id], function(transaction, results) {
            rc = results.rows.length;
            cc = candidates.length;
            for (j=0; j<cc; j++) {
              candidates[j].context_weight = 0;
              for (i=0; i<rc; i++) {
                r = results.rows.item(i);
                if (r.handler == candidates[j].id) {
                  candidates[j].context_weight = r.weight;
                }
              }
            }
            // Sort the candidates after context_weight and weight
            candidates.sort(function(a, b){
              var cwd = b.context_weight-a.context_weight;
              if (cwd==0) {
                return b.weight-a.weight;
              }
              return cwd;
            });
            callback(candidates);
        });
      });
    };

    var handler_class = function() {
      if (handler) {
        return handler['class'] ? handler['class'] : 'default';
      }
    };

    var set_handler = function(idx, update) {
      if (update) {
        cobalt_actions.empty();
        var a_count = actions.length;
        for(var i=0; i<a_count; i++) {
          $('<li class="action-opt-' + i + '"></l i>').html(actions[i]['name']).appendTo(cobalt_actions);
        }
      }

      if (idx<0 || idx >= actions.length) {
        return;
      }

      $('#cobalt .action-opt-' + handler_idx).removeClass('active');
      $('#cobalt .action-opt-' + idx).addClass('active');
      handler_idx = idx;
      var new_handler = actions[idx];

      handler = new_handler;
      if (handler) {
        var newClass = handler_class();
        $('#cobalt .right .inner').attr('class','inner cobalt-action-' + newClass);
        $('#cobalt .right label').text(handler.name).show();
      }
    };

    var run_handler = function() {
      if (item && typeof(handler['handler']) == 'function') {
        var text = $.trim(cobalt_input.val());
        register_use(text, item, handler);
        try {
          handler.handler(text, item);
        }
        catch(err) {
          log_error(Drupal.t("The handler threw a exception"), err);
        }
      }
      hide();
    };

    var get_last_entry = function() {
      db.transaction(function (transaction) {
        transaction.executeSql("SELECT e.*, u.weight FROM entries AS e INNER JOIN usage_data AS u ON u.catalog = e.catalog AND u.id = e.id WHERE last = 1;", [], function(transaction, results) {
          lookup_finished(transaction, results);
        }, cobalt.dbErrorHandler);
      });
    };

    var toggle = function(arg) {
      if (cobalt_visible) {
        cb.hide();
        cobalt_visible = false;
      }
      else if (arg!='hide') {
        toggle_output('hide');
        cobalt_input.val($.trim(cobalt_input.val()));
        cb.show();
        cobalt_visible = true;
        setTimeout(function(){ cobalt_input.focus(); cobalt_input.select(); }, 100);
      }
    };

    var hide = function() {
      toggle('hide');
    };

    var init = function() {
      $(document).trigger('cobalt-init', cobalt);

      // Load key bindings
      db.transaction(function (transaction) {
        transaction.executeSql('SELECT binding, catalog, id, handler FROM key_bindings', [], function(transaction, results) {
          for (var i=0; i<results.rows.length; i++) {
            var b = results.rows.item(i);
            bind_key(b.binding, b.catalog, b.id, b.handler);
          }
        },cobalt.dbErrorHandler);
      });

      get_last_entry();

      db.transaction(function (transaction) {
        transaction.executeSql("SELECT * FROM catalogs ORDER BY updated;", [ ], function(transaction, results) {
          var info = {};
          var state = current_state();

          // Queue catalogs for update
          for (var i = 0; i < results.rows.length; i++) {
            var item = results.rows.item(i);
            info[item.name] = item;
            update_queue.push({'name': item.name, 'updated': (item.state==state?item.updated:0) });
          }

          // Install new catalogs and queue them for updates
          for (var key in catalogs) {
            (function(key) {
              if (!info[key]) {
                if (catalogs[key]['install']) {
                  catalogs[key].install();
                }
                db.transaction(function (transaction) {
                  transaction.executeSql("INSERT INTO catalogs(name) VALUES(?)", [key], nullDataHandler,cobalt.dbErrorHandler);
                });
                update_queue.unshift({'name': key, 'updated': 0 });
              }
            })(key);
          }

          // Update loop
          var update_counter = 0;
          var update_loop = function() {
            setTimeout(function() {
              if(update_queue.length) {
                var inf = update_queue.shift();
                var now = new Date().getTime();
                var catalog = catalogs[inf.name];

                if (typeof(catalog['update_rate'])!='undefined' && inf.updated + catalog.update_rate > now) {
                  update_queue.push(inf);
                  update_loop();
                }
                else {
                  if (catalog['update']) {
                    catalog.update(inf.updated, function(enqueue){
                      var now = new Date().getTime();
                     cobalt.catalogUpdated(inf.name);

                      if (enqueue) {
                        update_queue.push({'name': inf.name, 'updated': now });
                      }

                      update_counter++;
                      update_loop();
                    });
                  }
                  else {
                    update_loop();
                  }
                }
              }
            },update_counter?1000:100);
          };
          update_loop();
        },cobalt.dbErrorHandler);
      });

      $(document).trigger('cobalt-post-init', cobalt);

      cb.bind('click', function(e){ return false; });
      $([cobalt_input[0], cobalt_h_input[0]]).bind('keydown', 'esc', function(){ toggle('hide'); toggle_output('hide'); return false; }).
        bind('keydown', 'return', function(){ run_handler(); return false; });
      cobalt_input.bind('keydown', 'up', function(){ ac_select(match_idx-1); return false; }).
        bind('keydown', 'down', function(){ ac_select(match_idx+1); return false; }).
        bind('keydown', 'Alt+left', function(){ ac_page(match_offset-match_page_size); return false; }).
        bind('keydown', 'Alt+right', function(){ ac_page(match_offset+match_page_size); return false; }).
        bind('keyup', function(){ keypress_reaction(); return false; }).
        bind('focus', function() {
          if (matches && matches.length) {
            cobalt_ac.show();
            cobalt_paging.show();
          }
          cobalt_actions.hide();
        });
      cobalt_h_input.bind('keydown', 'up', function(){ set_handler(handler_idx-1); return false; }).
        bind('keydown', 'down', function(){ set_handler(handler_idx+1); return false; }).
        bind('keyup', function(){ action_keypress_reaction(); return false; }).
        bind('focus', function(){ cobalt_paging.hide(); cobalt_ac.hide(); cobalt_actions.show(); });
      cobalt_output.bind('click', function(e){ return false; });
      $('.cell.left', cb).bind('click', function(){ cobalt_input[0].focus(); });
      $('.cell.right', cb).bind('click', function(){ cobalt_h_input[0].focus(); });
      $(document).bind('click', function(){ toggle('hide'); toggle_output('hide'); });

      if (Drupal && Drupal.settings && Drupal.settings.cobalt) {
        var bindings = Drupal.settings.cobalt.bindings,
          bind_count = bindings.length, i;
        for (i=0; i<bind_count; i++) {
          $(document).bind('keydown', bindings[i], toggle);
        }
      }
      else {
        $(document).bind('keydown', 'Alt+space', toggle)
          .bind('keydown', 'Ctrl+space', toggle);
      }
    };

    // Initialize GUI
    var cb = $('<div id="cobalt">'+
      '<div class ="cells"><div class="cell left"><div class="inner"><span class="icon"></span><input type="text" id="cobalt-input" /><label></label></div></div>'+
      '<div class="cell right"><div class="inner"><input type="text" id="cobalt-handler-input" /><label></label></div></div></div>'+
      '<ol class="cobalt-paging"></ol><ul class="cobalt-autocomplete"></ul><ul class="cobalt-actions"></ul></div>').appendTo('body').hide();
    var cobalt_input = $('#cobalt-input');
    var cobalt_h_input = $('#cobalt-handler-input');
    var cobalt_ac = $('#cobalt .cobalt-autocomplete');
    var cobalt_actions = $('#cobalt .cobalt-actions');
    var cobalt_paging = $('#cobalt .cobalt-paging');
    $('#cobalt .right label').hide();

    // Check if we need to update anything before initializing
    db.transaction(function (transaction) {
      transaction.executeSql('SELECT name, version FROM versions', [], function(transaction, results) {
        var v = {};
        for (var i=0; i<results.rows.length; i++) {
          var vi = results.rows.item(i);
          v[vi.name] = vi.version;
        }

        db.transaction(function (transaction) {
          var plugin_count = plugin_names.length;
          for (var i=0; i<plugin_count; i++) {
            var n=plugin_names[i];
            if (typeof(v[n])=='undefined') {
              transaction.executeSql('INSERT INTO versions(name, version) VALUES(?,?)', [ n, plugins[n].version ], nullDataHandler,cobalt.dbErrorHandler);
            }
            else if (v[n]<plugins[n].version) {
              required_updates.push([n, v[n], plugins[n].version]);
            }
          }

          if (required_updates.length) {
            var update_notice = function () {
              var update_url = Drupal.settings.basePath + 'cobalt/update';
              for (var i=0; i<required_updates.length; i++) {
                var u = required_updates[i];
                update_url += '/' + u[0] + '/' + u[1] + '/' + u[2];
              }
             cobalt.showHtml('<h1>' + Drupal.t('Update required') + '</h1>' +
              '<p>' + Drupal.t('Cobalt must be updated before it can be used') + '</p>' +
              '<p><a class="cobalt-update-link" href="' + update_url + '">' + Drupal.t('Click here to update') + '</a></p>');
            };
            $(document).bind('click', function(){ toggle_output('hide'); });
            if (Drupal && Drupal.settings && Drupal.settings.cobalt) {
              var bindings = Drupal.settings.cobalt.bindings,
                bind_count = bindings.length, i;
              for (i=0; i<bind_count; i++) {
                $(document).bind('keydown', bindings[i], update_notice);
              }
            }
            else {
              $(document).bind('keydown', 'Alt+space', update_notice)
                .bind('keydown', 'Ctrl+space', update_notice);
            }
          }
          else {
            init();
          }
        });
      },cobalt.dbErrorHandler);
    });
  });
})(jQuery);