home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / plugins / twitter / res / smoothOperator.js < prev    next >
Encoding:
Text File  |  2009-09-20  |  11.3 KB  |  331 lines
  1. var SmoothOperator = function(doc) {
  2.     // prepare a template node for "in reply to..." links
  3.     this.inReplyTo = document.createElement('span');
  4.     this.inReplyTo.className = 'in_reply_to';
  5.     this.inReplyTo.innerHTML = ' <a href="" onclick="javascript:tweetActions.inReplyTo(this); return false;">in reply to...</a>';
  6.  
  7.     this._directTargetNode = document.createElement('span');
  8.     this._directTargetNode.className = 'directTarget';
  9. };
  10.  
  11. function onProfileImageError(evt) {
  12.     this.onerror = null;
  13.     this.setAttribute('src', SmoothOperator.prototype.emptyImageUrl);
  14. }
  15.  
  16. var deleteSrc = 'img/delete.gif';
  17.  
  18. var controls = {
  19.     reply:    '<a href="" title="Reply" onclick="tweetActions.reply(this); return false;"><img src="img/reply.png" width="16" height="16" /></a>',
  20.     retweet:  '<a href="" title="Retweet" onclick="tweetActions.retweet(this); return false;"><img src="img/retweet.gif" width="16" height="16" /></a>',
  21.     direct:   '<a href="" title="Direct" onclick="tweetActions.direct(this); return false;"><img src="img/direct.gif" width="16" height="16" /></a>',
  22.     favorite: '<a href="" title="Favorite" onclick="tweetActions.favorite(this); return false;"><img class="favoriteButton" src="img/star_off.gif" width="18" height="16" /></a>',
  23.     trash:    '<a href="" title="Delete" onclick="tweetActions.trash(this); return false;"><img class="deleteButton" src="' + deleteSrc + '" width="16" height="16" /></a>'
  24. };
  25.  
  26. with (controls) var controlTypeHTML = {
  27.     timeline: reply + retweet + direct + favorite,
  28.     mention:  reply + retweet + direct + favorite,
  29.     sent:     trash + favorite,
  30.     direct:   direct,
  31.     search:   reply + retweet + favorite
  32. };
  33.  
  34. SmoothOperator.prototype = {
  35.     preload: function() {
  36.         var images = ['top_left', 'top_center', 'top_right',
  37.                       'middle_left', 'middle_right', 'bottom_left',
  38.                       'bottom_right', 'bottom_center', 'middle_center'];
  39.         arrayExtend(images, $.map(images, function (e) { return 'context_'+e; }));
  40.         $.preload(images, {
  41.             base: 'images/',
  42.             ext: '.png'
  43.         });
  44.     },
  45.     emptyImageUrl:  'img/twitter_no_icon.png',
  46.     loadedLazy: {},
  47.     controlTemplates: {},
  48.     controlTemplate: function(doc, type) {
  49.         if (type in this.controlTemplates)
  50.             return this.controlTemplates[type];
  51.  
  52.         var node = doc.createElement('span');
  53.         node.className = 'control';
  54.         var html = controlTypeHTML[type];
  55.         if (html)
  56.             node.innerHTML = html;
  57.         else
  58.             console.log('ERROR: no controlTypeHTML for ' + type);
  59.         this.controlTemplates[type] = node;
  60.         return node;
  61.     },
  62.  
  63.     directTargetNode: function(name) {
  64.         var node = this._directTargetNode.cloneNode(true);
  65.         node.innerHTML = name;
  66.         return node;
  67.     },
  68.  
  69.     /**
  70.      * returns a template node from which we clone new ones
  71.      */
  72.     createTemplateItem: function(doc) {
  73.         var node = doc.createElement('div');
  74.         node.className = 'container';
  75.  
  76.         node.innerHTML =
  77.             '<div class="top_left"></div>' +
  78.             '<div class="top_center"></div>' +
  79.             '<div class="top_right"></div>' +
  80.             '<div class="middle_left"></div>' +
  81.             '<div class="middle_right"></div>' +
  82.             '<div class="bottom_left"></div>' +
  83.             '<div class="bottom_center"></div>' +
  84.             '<div class="bottom_right"></div>' +
  85.             '<div class="middle_center"></div>' +
  86.             '<div class="sender incoming">' +
  87.                 '<span class="senderstring">' +
  88.                 '</span>' +
  89.             '</div>' +
  90.             '<div class="time_initial">' +
  91.                   /* twitter control buttons 
  92.                   '<span class="control">' +
  93.                     // stuff
  94.                   '</span>' +
  95.                   */
  96.             '</div>' +
  97.             '<div class="buddyicon">' +
  98.                 '<img class="feedImage" src="' + this.emptyImageUrl + '" />' +
  99.             '</div>' +
  100.             '<div class="message">' +
  101.                 '<p></p>' +
  102.             '</div>';
  103.  
  104.         return node;
  105.     },
  106.  
  107.     createItem: function(doc, attrs) {
  108.         if (this.templateItem === undefined)
  109.             this.templateItem = this.createTemplateItem(doc);
  110.         
  111.         var node = this.templateItem.cloneNode(true);
  112.         var children = node.childNodes;
  113.  
  114.         if (attrs.classNames)
  115.             node.className += ' ' + attrs.classNames;
  116.  
  117.         // id
  118.         if (attrs.id)
  119.             node.setAttribute('id', attrs.id);
  120.  
  121.         // sender
  122.         var senderDiv = children[9];
  123.         if (attrs.sender)
  124.             senderDiv.firstChild.innerHTML = attrs.sender;
  125.  
  126.         if (attrs.reply)
  127.             senderDiv.firstChild.appendChild(this.inReplyTo.cloneNode(true));
  128.         else if (attrs.directTarget)
  129.             senderDiv.firstChild.appendChild(this.directTargetNode(attrs.directTarget));
  130.  
  131.         // controls
  132.         var timeNode = children[10];
  133.         timeNode.appendChild(this.controlTemplate(doc, attrs.type).cloneNode(true));
  134.  
  135.         // favorite
  136.         if (attrs.favorited)
  137.             this.setFavorite(node, true);
  138.         
  139.         if (attrs.time) {
  140.             var timeSpan = doc.createElement('span');
  141.             timeSpan.className = 'timeDescription';
  142.             timeSpan.innerHTML = attrs.time;
  143.             if (attrs.timeToolTip)
  144.                 timeSpan.setAttribute('title', attrs.timeToolTip);
  145.  
  146.             timeNode.appendChild(timeSpan);
  147.         }
  148.  
  149.         // Set "lazy_src" attribute on the <img> tag, unless we have already
  150.         // lazily loaded the href before.
  151.         var lazy_image = attrs.lazy_image;
  152.         var imageNode = children[11].firstChild;
  153.         if (lazy_image)
  154.             imageNode.setAttribute(
  155.                 lazy_image in this.loadedLazy ? 'src' : 'lazy_src',
  156.                 lazy_image);
  157.         imageNode.onerror = onProfileImageError;
  158.         
  159.         if (attrs.message) {
  160.             var messagePara = children[12].firstChild;
  161.             messagePara.innerHTML = attrs.message;
  162.             if (0 && attrs.source) {
  163.                 var source = doc.createElement('span');
  164.                 source.className = 'source';
  165.                 source.innerHTML = ' from ' + attrs.source;
  166.                 messagePara.appendChild(source);
  167.             }
  168.         }
  169.  
  170.         return node;
  171.     },
  172.  
  173.     getMessage: function(node) {
  174.         return node.childNodes[12].firstChild.innerHTML;
  175.     },
  176.  
  177.     // image manipulation
  178.     getImage: function(node) { return node.childNodes[11].firstChild; },
  179.     isEmptyImage: function(node) { return this.getImage(node).getAttribute('src') === this.emptyImageUrl; },
  180.  
  181.     loadAllLazy: function(node) {
  182.         var image = this.getImage(node);
  183.         if (image === undefined) return;
  184.  
  185.         var src = image.getAttribute('lazy_src');
  186.         if (src === undefined) return;
  187.  
  188.         // loop over all images manually--jquery was slow
  189.         var images = document.getElementsByClassName('feedImage');
  190.         for (var i = images.length-1; i >= 0; --i) {
  191.             var img = images[i];
  192.             var lazy_src = img.getAttribute('lazy_src');
  193.             if (lazy_src && lazy_src === src) {
  194.                 img.setAttribute('src', lazy_src);
  195.                 this.loadedLazy[lazy_src] = true;
  196.                 img.removeAttribute('lazy_src');
  197.             }
  198.         }
  199.     },
  200.  
  201.     makeReplyArrow: function() {
  202.         if (this.replyArrowTemplate === undefined) {
  203.             var img = document.createElement('img');
  204.             img.className = 'replyArrow';
  205.             img.setAttribute('src', 'img/inreply.png');
  206.             img.setAttribute('width', 16);
  207.             img.setAttribute('height', 20);
  208.  
  209.             this.replyArrowTemplate = img;
  210.         }
  211.         return this.replyArrowTemplate.cloneNode(true);
  212.     },
  213.  
  214.     /*
  215.      * favorites
  216.      */
  217.  
  218.     pendingSrc: 'img/pending.png',
  219.  
  220.     favoritedSrc: 'img/star_on.gif',
  221.     notFavoritedSrc: 'img/star_off.gif',
  222.  
  223.     getFavoriteButton: function(node) {
  224.         return node.childNodes[10].firstChild.getElementsByClassName('favoriteButton')[0];
  225.     },
  226.  
  227.     getDeleteButton: function(node) {
  228.         return node.childNodes[10].firstChild.getElementsByClassName('deleteButton')[0];
  229.     },
  230.  
  231.     getFavorite: function(node) {
  232.         var src = this.getFavoriteButton(node).src;
  233.         if (src === this.pendingSrc)
  234.             return 'pending';
  235.         else if (src === this.favoritedSrc)
  236.             return true;
  237.         else
  238.             return false;
  239.     },
  240.  
  241.     setFavorite: function(node, state) {
  242.         var src;
  243.         if (state === 'pending') src = this.pendingSrc;
  244.         else if (state)          src = this.favoritedSrc;
  245.         else                     src = this.notFavoritedSrc;
  246.  
  247.         this.getFavoriteButton(node).src = src;
  248.     },
  249.  
  250.     setDelete: function(node, state) {
  251.         var src;
  252.         if (state === 'pending') src = this.pendingSrc;
  253.         else                     src = deleteSrc;
  254.         this.getDeleteButton(node).src = src;
  255.     },
  256.  
  257.     hiddenClassname: 'hiddenFeedItem',
  258.  
  259.     setHidden: function(node, hidden) {
  260.         if (hidden)
  261.             $(node).addClass(this.hiddenClassname);
  262.         else
  263.             $(node).removeClass(this.hiddenClassname);
  264.     },
  265.  
  266.     visualReadClass: 'context',    
  267.  
  268.     isMarkedAsRead: function(node) { return $(node).hasClass(this.visualReadClass); },
  269.  
  270.     markAsRead: function(node, read) {
  271.         node = $(node);
  272.         if (read)
  273.             node.addClass(this.visualReadClass);
  274.         else
  275.             node.removeClass(this.visualReadClass);
  276.     },
  277.  
  278.     FOOTER_CLASS: 'statusFooter',
  279.  
  280.     clearFooter: function() {
  281.         var nodes = document.getElementsByClassName(this.FOOTER_CLASS);
  282.         while(nodes.length) {
  283.             var node = nodes[0];
  284.             node.parentNode.removeChild(node);
  285.             nodes = document.getElementsByClassName(this.FOOTER_CLASS);
  286.         }
  287.     },
  288.  
  289.     setFooter: function(footer) {
  290.         var self = this;
  291.         this.clearFooter();
  292.         if (!footer)
  293.             return;
  294.  
  295.         function makeDiv() {
  296.             div = document.createElement('div');
  297.             div.className = 'status_container ' + self.FOOTER_CLASS;
  298.  
  299.             dodiv('status_message', 0);
  300.             dodiv('status_time', 1);
  301.  
  302.             function dolink(onclick, text) {
  303.                 var link = document.createElement('a');
  304.                 link.setAttribute('href', '');
  305.                 link.innerHTML = text;
  306.                 link.onclick = function() {
  307.                     guard(function() { onclick.call(this); });
  308.                     return false;
  309.                 };
  310.                 return link;
  311.             }
  312.  
  313.             function dodiv(classname, index) {
  314.                 var innerdiv = document.createElement('div');
  315.                 innerdiv.className = classname;
  316.                 var footerItem = footer[index];
  317.                 innerdiv.appendChild(dolink(footerItem[0], footerItem[1]));
  318.  
  319.                 div.appendChild(innerdiv);
  320.             }
  321.             
  322.             return div;
  323.         }
  324.  
  325.         var container = document.getElementById(CONTAINER_ID);
  326.         container.parentNode.insertBefore(makeDiv(), container.nextSibling);
  327.         container.parentNode.insertBefore(makeDiv(), container);
  328.     }
  329. };
  330.  
  331.