SSGames - Servidores online de qualidade - Inscreva-se Ja! é entre para nossa comunidade! - Ouça nossa web radio -Veja nossas novidades - Participe dos nossos setores de jogos online - Parcerias aberta fale já com um administrador.

Core de UI e Tabela UI ( Funciona somente em iOS )

FreddyVsJason
FreddyVsJason
--> Postador Fanático
--> Postador Fanático

Mensagens : 246
Moedas : 3921
Data de inscrição : 24/09/2012

Core de UI e Tabela UI ( Funciona somente em iOS ) Empty Core de UI e Tabela UI ( Funciona somente em iOS )

Mensagem por FreddyVsJason em Qua 7 Nov 2012 - 21:51

UI design, é um tipo de design para UI ( portateis e telefonia movel )

Irei passar os códigos do Core de UI e da tabela UI ( Não é para MYSQL é JS )
Ui.Core.js
Spoiler:
Código:
 /*
 * jQuery UI 1.7.3
 *
 * Copyright (c) 2012 FreddyVsJason - ScriptSamp
 * Licença dupla sobre MIT e GPL.
 *
 * http://docs.jquery.com/UI
 */
;jQuery.ui || (function($) {

var _remove = $.fn.remove,
   isFF2 = $.browser.mozilla && (parseFloat($.browser.version) < 1.9);

//Helper functions and ui object
$.ui = {
   version: "1.7.3",

   // $.ui.plugin is deprecated.  Use the proxy pattern instead.
   plugin: {
      add: function(module, option, set) {
         var proto = $.ui[module].prototype;
         for(var i in set) {
            proto.plugins[i] = proto.plugins[i] || [];
            proto.plugins[i].push([option, set[i]]);
         }
      },
      call: function(instance, name, args) {
         var set = instance.plugins[name];
         if(!set || !instance.element[0].parentNode) { return; }

         for (var i = 0; i < set.length; i++) {
            if (instance.options[set[i][0]]) {
               set[i][1].apply(instance.element, args);
            }
         }
      }
   },

   contains: function(a, b) {
      return document.compareDocumentPosition
         ? a.compareDocumentPosition(b) & 16
         : a !== b && a.contains(b);
   },

   hasScroll: function(el, a) {

      //If overflow is hidden, the element might have extra content, but the user wants to hide it
      if ($(el).css('overflow') == 'hidden') { return false; }

      var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop',
         has = false;

      if (el[scroll] > 0) { return true; }

      // TODO: determine which cases actually cause this to happen
      // if the element doesn't have the scroll set, see if it's possible to
      // set the scroll
      el[scroll] = 1;
      has = (el[scroll] > 0);
      el[scroll] = 0;
      return has;
   },

   isOverAxis: function(x, reference, size) {
      //Determines when x coordinate is over "b" element axis
      return (x > reference) && (x < (reference + size));
   },

   isOver: function(y, x, top, left, height, width) {
      //Determines when x, y coordinates is over "b" element
      return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);
   },

   keyCode: {
      BACKSPACE: 8,
      CAPS_LOCK: 20,
      COMMA: 188,
      CONTROL: 17,
      DELETE: 46,
      DOWN: 40,
      END: 35,
      ENTER: 13,
      ESCAPE: 27,
      HOME: 36,
      INSERT: 45,
      LEFT: 37,
      NUMPAD_ADD: 107,
      NUMPAD_DECIMAL: 110,
      NUMPAD_DIVIDE: 111,
      NUMPAD_ENTER: 108,
      NUMPAD_MULTIPLY: 106,
      NUMPAD_SUBTRACT: 109,
      PAGE_DOWN: 34,
      PAGE_UP: 33,
      PERIOD: 190,
      RIGHT: 39,
      SHIFT: 16,
      SPACE: 32,
      TAB: 9,
      UP: 38
   }
};

// WAI-ARIA normalization
if (isFF2) {
   var attr = $.attr,
      removeAttr = $.fn.removeAttr,
      ariaNS = "../../../www.w3.org/2005/07/aaa",
      ariaState = /^aria-/,
      ariaRole = /^wairole:/;

   $.attr = function(elem, name, value) {
      var set = value !== undefined;

      return (name == 'role'
         ? (set
            ? attr.call(this, elem, name, "wairole:" + value)
            : (attr.apply(this, arguments) || "").replace(ariaRole, ""))
         : (ariaState.test(name)
            ? (set
               ? elem.setAttributeNS(ariaNS,
                  name.replace(ariaState, "aaa:"), value)
               : attr.call(this, elem, name.replace(ariaState, "aaa:")))
            : attr.apply(this, arguments)));
   };

   $.fn.removeAttr = function(name) {
      return (ariaState.test(name)
         ? this.each(function() {
            this.removeAttributeNS(ariaNS, name.replace(ariaState, ""));
         }) : removeAttr.call(this, name));
   };
}

//jQuery plugins
$.fn.extend({
   remove: function(selector, keepData) {
      return this.each(function() {
         if ( !keepData ) {
            if ( !selector || $.filter( selector, [ this ] ).length ) {
               $( "*", this ).add( this ).each(function() {
                  $( this ).triggerHandler( "remove" );
               });
            }
         }
         return _remove.call( $(this), selector, keepData );
      });
   },

   enableSelection: function() {
      return this
         .attr('unselectable', 'off')
         .css('MozUserSelect', '')
         .unbind('selectstart.ui');
   },

   disableSelection: function() {
      return this
         .attr('unselectable', 'on')
         .css('MozUserSelect', 'none')
         .bind('selectstart.ui', function() { return false; });
   },

   scrollParent: function() {
      var scrollParent;
      if(($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
         scrollParent = this.parents().filter(function() {
            return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
         }).eq(0);
      } else {
         scrollParent = this.parents().filter(function() {
            return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
         }).eq(0);
      }

      return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
   }
});


//Additional selectors
$.extend($.expr[':'], {
   data: function(elem, i, match) {
      return !!$.data(elem, match[3]);
   },

   focusable: function(element) {
      var nodeName = element.nodeName.toLowerCase(),
         tabIndex = $.attr(element, 'tabindex');
      return (/input|select|textarea|button|object/.test(nodeName)
         ? !element.disabled
         : 'a' == nodeName || 'area' == nodeName
            ? element.href || !isNaN(tabIndex)
            : !isNaN(tabIndex))
         // the element and all of its ancestors must be visible
         // the browser may report that the area is hidden
         && !$(element)['area' == nodeName ? 'parents' : 'closest'](':hidden').length;
   },

   tabbable: function(element) {
      var tabIndex = $.attr(element, 'tabindex');
      return (isNaN(tabIndex) || tabIndex >= 0) && $(element).is(':focusable');
   }
});


// $.widget is a factory to create jQuery plugins
// taking some boilerplate code out of the plugin code
function getter(namespace, plugin, method, args) {
   function getMethods(type) {
      var methods = $[namespace][plugin][type] || [];
      return (typeof methods == 'string' ? methods.split(/,?\s+/) : methods);
   }

   var methods = getMethods('getter');
   if (args.length == 1 && typeof args[0] == 'string') {
      methods = methods.concat(getMethods('getterSetter'));
   }
   return ($.inArray(method, methods) != -1);
}

$.widget = function(name, prototype) {
   var namespace = name.split(".")[0];
   name = name.split(".")[1];

   // create plugin method
   $.fn[name] = function(options) {
      var isMethodCall = (typeof options == 'string'),
         args = Array.prototype.slice.call(arguments, 1);

      // prevent calls to internal methods
      if (isMethodCall && options.substring(0, 1) == '_') {
         return this;
      }

      // handle getter methods
      if (isMethodCall && getter(namespace, name, options, args)) {
         var instance = $.data(this[0], name);
         return (instance ? instance[options].apply(instance, args)
            : undefined);
      }

      // handle initialization and non-getter methods
      return this.each(function() {
         var instance = $.data(this, name);

         // constructor
         (!instance && !isMethodCall &&
            $.data(this, name, new $[namespace][name](this, options))._init());

         // method call
         (instance && isMethodCall && $.isFunction(instance[options]) &&
            instance[options].apply(instance, args));
      });
   };

   // create widget constructor
   $[namespace] = $[namespace] || {};
   $[namespace][name] = function(element, options) {
      var self = this;

      this.namespace = namespace;
      this.widgetName = name;
      this.widgetEventPrefix = $[namespace][name].eventPrefix || name;
      this.widgetBaseClass = namespace + '-' + name;

      this.options = $.extend({},
         $.widget.defaults,
         $[namespace][name].defaults,
         $.metadata && $.metadata.get(element)[name],
         options);

      this.element = $(element)
         .bind('setData.' + name, function(event, key, value) {
            if (event.target == element) {
               return self._setData(key, value);
            }
         })
         .bind('getData.' + name, function(event, key) {
            if (event.target == element) {
               return self._getData(key);
            }
         })
         .bind('remove', function() {
            return self.destroy();
         });
   };

   // add widget prototype
   $[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);

   // TODO: merge getter and getterSetter properties from widget prototype
   // and plugin prototype
   $[namespace][name].getterSetter = 'option';
};

$.widget.prototype = {
   _init: function() {},
   destroy: function() {
      this.element.removeData(this.widgetName)
         .removeClass(this.widgetBaseClass + '-disabled' + ' ' + this.namespace + '-state-disabled')
         .removeAttr('aria-disabled');
   },

   option: function(key, value) {
      var options = key,
         self = this;

      if (typeof key == "string") {
         if (value === undefined) {
            return this._getData(key);
         }
         options = {};
         options[key] = value;
      }

      $.each(options, function(key, value) {
         self._setData(key, value);
      });
   },
   _getData: function(key) {
      return this.options[key];
   },
   _setData: function(key, value) {
      this.options[key] = value;

      if (key == 'disabled') {
         this.element
            [value ? 'addClass' : 'removeClass'](
               this.widgetBaseClass + '-disabled' + ' ' +
               this.namespace + '-state-disabled')
            .attr("aria-disabled", value);
      }
   },

   enable: function() {
      this._setData('disabled', false);
   },
   disable: function() {
      this._setData('disabled', true);
   },

   _trigger: function(type, event, data) {
      var callback = this.options[type],
         eventName = (type == this.widgetEventPrefix
            ? type : this.widgetEventPrefix + type);

      event = $.Event(event);
      event.type = eventName;

      // copy original event properties over to the new event
      // this would happen if we could call $.event.fix instead of $.Event
      // but we don't have a way to force an event to be fixed multiple times
      if (event.originalEvent) {
         for (var i = $.event.props.length, prop; i;) {
            prop = $.event.props[--i];
            event[prop] = event.originalEvent[prop];
         }
      }

      this.element.trigger(event, data);

      return !($.isFunction(callback) && callback.call(this.element[0], event, data) === false
         || event.isDefaultPrevented());
   }
};

$.widget.defaults = {
   disabled: false
};


/** Mouse Interaction Plugin **/

$.ui.mouse = {
   _mouseInit: function() {
      var self = this;

      this.element
         .bind('mousedown.'+this.widgetName, function(event) {
            return self._mouseDown(event);
         })
         .bind('click.'+this.widgetName, function(event) {
            if(self._preventClickEvent) {
               self._preventClickEvent = false;
               event.stopImmediatePropagation();
               return false;
            }
         });

      // Prevent text selection in IE
      if ($.browser.msie) {
         this._mouseUnselectable = this.element.attr('unselectable');
         this.element.attr('unselectable', 'on');
      }

      this.started = false;
   },

   // TODO: make sure destroying one instance of mouse doesn't mess with
   // other instances of mouse
   _mouseDestroy: function() {
      this.element.unbind('.'+this.widgetName);

      // Restore text selection in IE
      ($.browser.msie
         && this.element.attr('unselectable', this._mouseUnselectable));
   },

   _mouseDown: function(event) {
      // don't let more than one widget handle mouseStart
      // TODO: figure out why we have to use originalEvent
      event.originalEvent = event.originalEvent || {};
      if (event.originalEvent.mouseHandled) { return; }

      // we may have missed mouseup (out of window)
      (this._mouseStarted && this._mouseUp(event));

      this._mouseDownEvent = event;

      var self = this,
         btnIsLeft = (event.which == 1),
         elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
      if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
         return true;
      }

      this.mouseDelayMet = !this.options.delay;
      if (!this.mouseDelayMet) {
         this._mouseDelayTimer = setTimeout(function() {
            self.mouseDelayMet = true;
         }, this.options.delay);
      }

      if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
         this._mouseStarted = (this._mouseStart(event) !== false);
         if (!this._mouseStarted) {
            event.preventDefault();
            return true;
         }
      }

      // these delegates are required to keep context
      this._mouseMoveDelegate = function(event) {
         return self._mouseMove(event);
      };
      this._mouseUpDelegate = function(event) {
         return self._mouseUp(event);
      };
      $(document)
         .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
         .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);

      // preventDefault() is used to prevent the selection of text here -
      // however, in Safari, this causes select boxes not to be selectable
      // anymore, so this fix is needed
      ($.browser.safari || event.preventDefault());

      event.originalEvent.mouseHandled = true;
      return true;
   },

   _mouseMove: function(event) {
      // IE mouseup check - mouseup happened when mouse was out of window
      if ($.browser.msie && !event.button) {
         return this._mouseUp(event);
      }

      if (this._mouseStarted) {
         this._mouseDrag(event);
         return event.preventDefault();
      }

      if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
         this._mouseStarted =
            (this._mouseStart(this._mouseDownEvent, event) !== false);
         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
      }

      return !this._mouseStarted;
   },

   _mouseUp: function(event) {
      $(document)
         .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
         .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);

      if (this._mouseStarted) {
         this._mouseStarted = false;
         this._preventClickEvent = (event.target == this._mouseDownEvent.target);
         this._mouseStop(event);
      }

      return false;
   },

   _mouseDistanceMet: function(event) {
      return (Math.max(
            Math.abs(this._mouseDownEvent.pageX - event.pageX),
            Math.abs(this._mouseDownEvent.pageY - event.pageY)
         ) >= this.options.distance
      );
   },

   _mouseDelayMet: function(event) {
      return this.mouseDelayMet;
   },

   // These are placeholder methods, to be overriden by extending plugin
   _mouseStart: function(event) {},
   _mouseDrag: function(event) {},
   _mouseStop: function(event) {},
   _mouseCapture: function(event) { return true; }
};

$.ui.mouse.defaults = {
   cancel: null,
   distance: 1,
   delay: 0
};

})(jQ[/spoiler]uery);
ui.tabs.js
Spoiler:
Código:
/*
 * jQuery UI Tabs 1.7.3
 *
 * Copyright (c) 2012 FreddyVsJason - ScriptSamp
 * Licença dupla sobre MIT e GPL
 * http://docs.jquery.com/UI/Tabs
 *
 * Depends:
 *   ui.core.js
 */
(function($) {

var tabId = 0,
   listId = 0;

$.widget("ui.tabs", {

   _init: function() {
      if (this.options.deselectable !== undefined) {
         this.options.collapsible = this.options.deselectable;
      }
      this._tabify(true);
   },

   _setData: function(key, value) {
      if (key == 'selected') {
         if (this.options.collapsible && value == this.options.selected) {
            return;
         }
         this.select(value);
      }
      else {
         this.options[key] = value;
         if (key == 'deselectable') {
            this.options.collapsible = value;
         }
         this._tabify();
      }
   },

   _tabId: function(a) {
      return a.title && a.title.replace(/\s/g, '_').replace(/[^A-Za-z0-9\-_:\.]/g, '') ||
         this.options.idPrefix + (++tabId);
   },

   _sanitizeSelector: function(hash) {
      return hash.replace(/:../../g, '\\:'); // we need this because an id may contain a ":"
   },

   _cookie: function() {
      var cookie = this.cookie || (this.cookie = this.options.cookie.name || 'ui-tabs-' + (++listId));
      return $.cookie.apply(null, [cookie].concat($.makeArray(arguments)));
   },

   _ui: function(tab, panel) {
      return {
         tab: tab,
         panel: panel,
         index: this.anchors.index(tab)
      };
   },

   _cleanup: function() {
      // restore all former loading tabs labels
      this.lis.filter('.ui-state-processing').removeClass('ui-state-processing')
            .find('span:data(label.tabs)')
            .each(function() {
               var el = $(this);
               el.html(el.data('label.tabs')).removeData('label.tabs');
            });
   },

   _tabify: function(init) {

      this.list = this.element.children('ul:first');
      this.lis = $('li:has(a[href])', this.list);
      this.anchors = this.lis.map(function() { return $('a', this)[0]; });
      this.panels = $([]);

      var self = this, o = this.options;

      var fragmentId = /^#.+/; // Safari 2 reports '#' for an empty hash
      this.anchors.each(function(i, a) {
         var href = $(a).attr('href');

         // For dynamically created HTML that contains a hash as href IE < 8 expands
         // such href to the full page url with hash and then misinterprets tab as ajax.
         // Same consideration applies for an added tab with a fragment identifier
         // since a[href=#fragment-identifier] does unexpectedly not match.
         // Thus normalize href attribute...
         var hrefBase = href.split('#')[0], baseEl;
         if (hrefBase && (hrefBase === location.toString().split('#')[0] ||
               (baseEl = $('base')[0]) && hrefBase === baseEl.href)) {
            href = a.hash;
            a.href = href;
         }

         // inline tab
         if (fragmentId.test(href)) {
            self.panels = self.panels.add(self._sanitizeSelector(href));
         }

         // remote tab
         else if (href != '#') { // prevent loading the page itself if href is just "#"
            $.data(a, 'href.tabs', href); // required for restore on destroy

            // TODO until #3808 is fixed strip fragment identifier from url
            // (IE fails to load from such url)
            $.data(a, 'load.tabs', href.replace(/#.*$/, '')); // mutable data

            var id = self._tabId(a);
            a.href = '#' + id;
            var $panel = $('#' + id);
            if (!$panel.length) {
               $panel = $(o.panelTemplate).attr('id', id).addClass('ui-tabs-panel ui-widget-content ui-corner-bottom')
                  .insertAfter(self.panels[i - 1] || self.list);
               $panel.data('destroy.tabs', true);
            }
            self.panels = self.panels.add($panel);
         }

         // invalid tab href
         else {
            o.disabled.push(i);
         }
      });

      // initialization from scratch
      if (init) {

         // attach necessary classes for styling
         this.element.addClass('ui-tabs ui-widget ui-widget-content ui-corner-all');
         this.list.addClass('ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all');
         this.lis.addClass('ui-state-default ui-corner-top');
         this.panels.addClass('ui-tabs-panel ui-widget-content ui-corner-bottom');

         // Selected tab
         // use "selected" option or try to retrieve:
         // 1. from fragment identifier in url
         // 2. from cookie
         // 3. from selected class attribute on <li>
         if (o.selected === undefined) {
            if (location.hash) {
               this.anchors.each(function(i, a) {
                  if (a.hash == location.hash) {
                     o.selected = i;
                     return false; // break
                  }
               });
            }
            if (typeof o.selected != 'number' && o.cookie) {
               o.selected = parseInt(self._cookie(), 10);
            }
            if (typeof o.selected != 'number' && this.lis.filter('.ui-tabs-selected').length) {
               o.selected = this.lis.index(this.lis.filter('.ui-tabs-selected'));
            }
            o.selected = o.selected || 0;
         }
         else if (o.selected === null) { // usage of null is deprecated, TODO remove in next release
            o.selected = -1;
         }

         // sanity check - default to first tab...
         o.selected = ((o.selected >= 0 && this.anchors[o.selected]) || o.selected < 0) ? o.selected : 0;

         // Take disabling tabs via class attribute from HTML
         // into account and update option properly.
         // A selected tab cannot become disabled.
         o.disabled = $.unique(o.disabled.concat(
            $.map(this.lis.filter('.ui-state-disabled'),
               function(n, i) { return self.lis.index(n); } )
         )).sort();

         if ($.inArray(o.selected, o.disabled) != -1) {
            o.disabled.splice($.inArray(o.selected, o.disabled), 1);
         }

         // highlight selected tab
         this.panels.addClass('ui-tabs-hide');
         this.lis.removeClass('ui-tabs-selected ui-state-active');
         if (o.selected >= 0 && this.anchors.length) { // check for length avoids error when initializing empty list
            this.panels.eq(o.selected).removeClass('ui-tabs-hide');
            this.lis.eq(o.selected).addClass('ui-tabs-selected ui-state-active');

            // seems to be expected behavior that the show callback is fired
            self.element.queue("tabs", function() {
               self._trigger('show', null, self._ui(self.anchors[o.selected], self.panels[o.selected]));
            });
            
            this.load(o.selected);
         }

         // clean up to avoid memory leaks in certain versions of IE 6
         $(window).bind('unload', function() {
            self.lis.add(self.anchors).unbind('.tabs');
            self.lis = self.anchors = self.panels = null;
         });

      }
      // update selected after add/remove
      else {
         o.selected = this.lis.index(this.lis.filter('.ui-tabs-selected'));
      }

      // update collapsible
      this.element[o.collapsible ? 'addClass' : 'removeClass']('ui-tabs-collapsible');

      // set or update cookie after init and add/remove respectively
      if (o.cookie) {
         this._cookie(o.selected, o.cookie);
      }

      // disable tabs
      for (var i = 0, li; (li = this.lis[i]); i++) {
         $(li)[$.inArray(i, o.disabled) != -1 &&
            !$(li).hasClass('ui-tabs-selected') ? 'addClass' : 'removeClass']('ui-state-disabled');
      }

      // reset cache if switching from cached to not cached
      if (o.cache === false) {
         this.anchors.removeData('cache.tabs');
      }

      // remove all handlers before, tabify may run on existing tabs after add or option change
      this.lis.add(this.anchors).unbind('.tabs');

      if (o.event != 'mouseover') {
         var addState = function(state, el) {
            if (el.is(':not(.ui-state-disabled)')) {
               el.addClass('ui-state-' + state);
            }
         };
         var removeState = function(state, el) {
            el.removeClass('ui-state-' + state);
         };
         this.lis.bind('mouseover.tabs', function() {
            addState('hover', $(this));
         });
         this.lis.bind('mouseout.tabs', function() {
            removeState('hover', $(this));
         });
         this.anchors.bind('focus.tabs', function() {
            addState('focus', $(this).closest('li'));
         });
         this.anchors.bind('blur.tabs', function() {
            removeState('focus', $(this).closest('li'));
         });
      }

      // set up animations
      var hideFx, showFx;
      if (o.fx) {
         if ($.isArray(o.fx)) {
            hideFx = o.fx[0];
            showFx = o.fx[1];
         }
         else {
            hideFx = showFx = o.fx;
         }
      }

      // Reset certain styles left over from animation
      // and prevent IE's ClearType bug...
      function resetStyle($el, fx) {
         $el.css({ display: '' });
         if ($.browser.msie && fx.opacity) {
            $el[0].style.removeAttribute('filter');
         }
      }

      // Show a tab...
      var showTab = showFx ?
         function(clicked, $show) {
            $(clicked).closest('li').removeClass('ui-state-default').addClass('ui-tabs-selected ui-state-active');
            $show.hide().removeClass('ui-tabs-hide') // avoid flicker that way
               .animate(showFx, showFx.duration || 'normal', function() {
                  resetStyle($show, showFx);
                  self._trigger('show', null, self._ui(clicked, $show[0]));
               });
         } :
         function(clicked, $show) {
            $(clicked).closest('li').removeClass('ui-state-default').addClass('ui-tabs-selected ui-state-active');
            $show.removeClass('ui-tabs-hide');
            self._trigger('show', null, self._ui(clicked, $show[0]));
         };

      // Hide a tab, $show is optional...
      var hideTab = hideFx ?
         function(clicked, $hide) {
            $hide.animate(hideFx, hideFx.duration || 'normal', function() {
               self.lis.removeClass('ui-tabs-selected ui-state-active').addClass('ui-state-default');
               $hide.addClass('ui-tabs-hide');
               resetStyle($hide, hideFx);
               self.element.dequeue("tabs");
            });
         } :
         function(clicked, $hide, $show) {
            self.lis.removeClass('ui-tabs-selected ui-state-active').addClass('ui-state-default');
            $hide.addClass('ui-tabs-hide');
            self.element.dequeue("tabs");
         };

      // attach tab event handler, unbind to avoid duplicates from former tabifying...
      this.anchors.bind(o.event + '.tabs', function() {
         var el = this, $li = $(this).closest('li'), $hide = self.panels.filter(':not(.ui-tabs-hide)'),
               $show = $(self._sanitizeSelector(this.hash));

         // If tab is already selected and not collapsible or tab disabled or
         // or is already loading or click callback returns false stop here.
         // Check if click handler returns false last so that it is not executed
         // for a disabled or loading tab!
         if (($li.hasClass('ui-tabs-selected') && !o.collapsible) ||
            $li.hasClass('ui-state-disabled') ||
            $li.hasClass('ui-state-processing') ||
            self._trigger('select', null, self._ui(this, $show[0])) === false) {
            this.blur();
            return false;
         }

         o.selected = self.anchors.index(this);

         self.abort();

         // if tab may be closed
         if (o.collapsible) {
            if ($li.hasClass('ui-tabs-selected')) {
               o.selected = -1;

               if (o.cookie) {
                  self._cookie(o.selected, o.cookie);
               }

               self.element.queue("tabs", function() {
                  hideTab(el, $hide);
               }).dequeue("tabs");
               
               this.blur();
               return false;
            }
            else if (!$hide.length) {
               if (o.cookie) {
                  self._cookie(o.selected, o.cookie);
               }
               
               self.element.queue("tabs", function() {
                  showTab(el, $show);
               });

               self.load(self.anchors.index(this)); // TODO make passing in node possible, see also http://dev.jqueryui.com/ticket/3171
               
               this.blur();
               return false;
            }
         }

         if (o.cookie) {
            self._cookie(o.selected, o.cookie);
         }

         // show new tab
         if ($show.length) {
            if ($hide.length) {
               self.element.queue("tabs", function() {
                  hideTab(el, $hide);
               });
            }
            self.element.queue("tabs", function() {
               showTab(el, $show);
            });
            
            self.load(self.anchors.index(this));
         }
         else {
            throw 'jQuery UI Tabs: Mismatching fragment identifier.';
         }

         // Prevent IE from keeping other link focussed when using the back button
         // and remove dotted border from clicked link. This is controlled via CSS
         // in modern browsers; blur() removes focus from address bar in Firefox
         // which can become a usability and annoying problem with tabs('rotate').
         if ($.browser.msie) {
            this.blur();
         }

      });

      // disable click in any case
      this.anchors.bind('click.tabs', function(){return false;});

   },

   destroy: function() {
      var o = this.options;

      this.abort();
      
      this.element.unbind('.tabs')
         .removeClass('ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible')
         .removeData('tabs');

      this.list.removeClass('ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all');

      this.anchors.each(function() {
         var href = $.data(this, 'href.tabs');
         if (href) {
            this.href = href;
         }
         var $this = $(this).unbind('.tabs');
         $.each(['href', 'load', 'cache'], function(i, prefix) {
            $this.removeData(prefix + '.tabs');
         });
      });

      this.lis.unbind('.tabs').add(this.panels).each(function() {
         if ($.data(this, 'destroy.tabs')) {
            $(this).remove();
         }
         else {
            $(this).removeClass([
               'ui-state-default',
               'ui-corner-top',
               'ui-tabs-selected',
               'ui-state-active',
               'ui-state-hover',
               'ui-state-focus',
               'ui-state-disabled',
               'ui-tabs-panel',
               'ui-widget-content',
               'ui-corner-bottom',
               'ui-tabs-hide'
            ].join(' '));
         }
      });

      if (o.cookie) {
         this._cookie(null, o.cookie);
      }
   },

   add: function(url, label, index) {
      if (index === undefined) {
         index = this.anchors.length; // append by default
      }

      var self = this, o = this.options,
         $li = $(o.tabTemplate.replace(/#\{href\}/g, url).replace(/#\{label\}/g, label)),
         id = !url.indexOf('#') ? url.replace('#', '') : this._tabId($('a', $li)[0]);

      $li.addClass('ui-state-default ui-corner-top').data('destroy.tabs', true);

      // try to find an existing element before creating a new one
      var $panel = $('#' + id);
      if (!$panel.length) {
         $panel = $(o.panelTemplate).attr('id', id).data('destroy.tabs', true);
      }
      $panel.addClass('ui-tabs-panel ui-widget-content ui-corner-bottom ui-tabs-hide');

      if (index >= this.lis.length) {
         $li.appendTo(this.list);
         $panel.appendTo(this.list[0].parentNode);
      }
      else {
         $li.insertBefore(this.lis[index]);
         $panel.insertBefore(this.panels[index]);
      }

      o.disabled = $.map(o.disabled,
         function(n, i) { return n >= index ? ++n : n; });

      this._tabify();

      if (this.anchors.length == 1) { // after tabify
         $li.addClass('ui-tabs-selected ui-state-active');
         $panel.removeClass('ui-tabs-hide');
         this.element.queue("tabs", function() {
            self._trigger('show', null, self._ui(self.anchors[0], self.panels[0]));
         });
            
         this.load(0);
      }

      // callback
      this._trigger('add', null, this._ui(this.anchors[index], this.panels[index]));
   },

   remove: function(index) {
      var o = this.options, $li = this.lis.eq(index).remove(),
         $panel = this.panels.eq(index).remove();

      // If selected tab was removed focus tab to the right or
      // in case the last tab was removed the tab to the left.
      if ($li.hasClass('ui-tabs-selected') && this.anchors.length > 1) {
         this.select(index + (index + 1 < this.anchors.length ? 1 : -1));
      }

      o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
         function(n, i) { return n >= index ? --n : n; });

      this._tabify();

      // callback
      this._trigger('remove', null, this._ui($li.find('a')[0], $panel[0]));
   },

   enable: function(index) {
      var o = this.options;
      if ($.inArray(index, o.disabled) == -1) {
         return;
      }

      this.lis.eq(index).removeClass('ui-state-disabled');
      o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });

      // callback
      this._trigger('enable', null, this._ui(this.anchors[index], this.panels[index]));
   },

   disable: function(index) {
      var self = this, o = this.options;
      if (index != o.selected) { // cannot disable already selected tab
         this.lis.eq(index).addClass('ui-state-disabled');

         o.disabled.push(index);
         o.disabled.sort();

         // callback
         this._trigger('disable', null, this._ui(this.anchors[index], this.panels[index]));
      }
   },

   select: function(index) {
      if (typeof index == 'string') {
         index = this.anchors.index(this.anchors.filter('[href$=' + index + ']'));
      }
      else if (index === null) { // usage of null is deprecated, TODO remove in next release
         index = -1;
      }
      if (index == -1 && this.options.collapsible) {
         index = this.options.selected;
      }

      this.anchors.eq(index).trigger(this.options.event + '.tabs');
   },

   load: function(index) {
      var self = this, o = this.options, a = this.anchors.eq(index)[0], url = $.data(a, 'load.tabs');

      this.abort();

      // not remote or from cache
      if (!url || this.element.queue("tabs").length !== 0 && $.data(a, 'cache.tabs')) {
         this.element.dequeue("tabs");
         return;
      }

      // load remote from here on
      this.lis.eq(index).addClass('ui-state-processing');

      if (o.spinner) {
         var span = $('span', a);
         span.data('label.tabs', span.html()).html(o.spinner);
      }

      this.xhr = $.ajax($.extend({}, o.ajaxOptions, {
         url: url,
         success: function(r, s) {
            $(self._sanitizeSelector(a.hash)).html(r);

            // take care of tab labels
            self._cleanup();

            if (o.cache) {
               $.data(a, 'cache.tabs', true); // if loaded once do not load them again
            }

            // callbacks
            self._trigger('load', null, self._ui(self.anchors[index], self.panels[index]));
            try {
               o.ajaxOptions.success(r, s);
            }
            catch (e) {}

            // last, so that load event is fired before show...
            self.element.dequeue("tabs");
         }
      }));
   },

   abort: function() {
      // stop possibly running animations
      this.element.queue([]);
      this.panels.stop(false, true);

      // terminate pending requests from other tabs
      if (this.xhr) {
         this.xhr.abort();
         delete this.xhr;
      }

      // take care of tab labels
      this._cleanup();

   },

   url: function(index, url) {
      this.anchors.eq(index).removeData('cache.tabs').data('load.tabs', url);
   },

   length: function() {
      return this.anchors.length;
   }

});

$.extend($.ui.tabs, {
   version: '1.7.3',
   getter: 'length',
   defaults: {
      ajaxOptions: null,
      cache: false,
      cookie: null, // e.g. { expires: 7, path: '../../default.htm', domain: 'jquery.com', secure: true }
      collapsible: false,
      disabled: [],
      event: 'click',
      fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
      idPrefix: 'ui-tabs-',
      panelTemplate: '<div></div>',
      spinner: '<em>Loading…</em>',
      tabTemplate: '<li><a href="#{href}"><span>#{label}</span></a></li>'
   }
});

/*
 * Tabs Extensions
 */

/*
 * Rotate
 */
$.extend($.ui.tabs.prototype, {
   rotation: null,
   rotate: function(ms, continuing) {

      var self = this, o = this.options;
      
      var rotate = self._rotate || (self._rotate = function(e) {
         clearTimeout(self.rotation);
         self.rotation = setTimeout(function() {
            var t = o.selected;
            self.select( ++t < self.anchors.length ? t : 0 );
         }, ms);
         
         if (e) {
            e.stopPropagation();
         }
      });
      
      var stop = self._unrotate || (self._unrotate = !continuing ?
         function(e) {
            if (e.clientX) { // in case of a true click
               self.rotate(null);
            }
         } :
         function(e) {
            t = o.selected;
            rotate();
         });

      // start rotation
      if (ms) {
         this.element.bind('tabsshow', rotate);
         this.anchors.bind(o.event + '.tabs', stop);
         rotate();
      }
      // stop rotation
      else {
         clearTimeout(self.rotation);
         this.element.unbind('tabsshow', rotate);
         this.anchors.unbind(o.event + '.tabs', stop);
         delete this._rotate;
         delete this._unrotate;
      }
   }
});

})(jQuery);
É para desenvolver um tipo de aplicação ui não muito adaptavel para iPhone 2 e 3GS agora é ótimo para 4s e 5



Core de UI e Tabela UI ( Funciona somente em iOS ) Q87CR
• FreddyVsJason sugere:
- Respeite as regras do fórum.

- Fique alerta sempre aos anúncios do fórum.


Core de UI e Tabela UI ( Funciona somente em iOS ) Suppor10

    Data/hora atual: Dom 26 Maio 2019 - 11:07

    Copyright © SSGamers 2011/2018 - DIREITOS RESERVADOS PARA COMUNIDADE SSGAMERS S.A.