Dotclear


Ignore:
Timestamp:
11/17/13 20:25:53 (12 years ago)
Author:
franck <carnet.franck.paul@…>
Branch:
2.6
Children:
2567:6c11245cbf04, 2568:61c67a7d17fa
Message:

Add some people in CREDITS, remove trailing spaces and tabs.

Location:
themes/default
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • themes/default/_define.php

    r2257 r2566  
    2121     ) 
    2222); 
    23 ?> 
  • themes/default/js/jquery.js

    r0 r2566  
    5555     // For matching the engine and version of the browser 
    5656     browserMatch, 
    57       
     57 
    5858     // Has the ready events already been bound? 
    5959     readyBound = false, 
    60       
     60 
    6161     // The functions to execute on DOM ready 
    6262     readyList = [], 
     
    8787               return this; 
    8888          } 
    89            
     89 
    9090          // The body element only exists once, optimize finding it 
    9191          if ( selector === "body" && !context ) { 
     
    126126                              selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes; 
    127127                         } 
    128                           
     128 
    129129                         return jQuery.merge( this, selector ); 
    130                           
     130 
    131131                    // HANDLE: $("#id") 
    132132                    } else { 
     
    219219          if ( jQuery.isArray( elems ) ) { 
    220220               push.apply( ret, elems ); 
    221            
     221 
    222222          } else { 
    223223               jQuery.merge( ret, elems ); 
     
    245245          return jQuery.each( this, callback, args ); 
    246246     }, 
    247       
     247 
    248248     ready: function( fn ) { 
    249249          // Attach the listeners 
     
    263263          return this; 
    264264     }, 
    265       
     265 
    266266     eq: function( i ) { 
    267267          return i === -1 ? 
     
    288288          })); 
    289289     }, 
    290       
     290 
    291291     end: function() { 
    292292          return this.prevObject || jQuery(null); 
     
    369369          return jQuery; 
    370370     }, 
    371       
     371 
    372372     // Is the DOM ready to be used? Set to true once it occurs. 
    373373     isReady: false, 
    374       
     374 
    375375     // Handle when the DOM is ready 
    376376     ready: function() { 
     
    403403          } 
    404404     }, 
    405       
     405 
    406406     bindReady: function() { 
    407407          if ( readyBound ) { 
     
    421421               // Use the handy event callback 
    422422               document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
    423                 
     423 
    424424               // A fallback to window.onload, that will always work 
    425425               window.addEventListener( "load", jQuery.ready, false ); 
     
    430430               // maybe late but safe also for iframes 
    431431               document.attachEvent("onreadystatechange", DOMContentLoaded); 
    432                 
     432 
    433433               // A fallback to window.onload, that will always work 
    434434               window.attachEvent( "onload", jQuery.ready ); 
     
    466466               return false; 
    467467          } 
    468            
     468 
    469469          // Not own constructor property must be Object 
    470470          if ( obj.constructor 
     
    473473               return false; 
    474474          } 
    475            
     475 
    476476          // Own properties are enumerated firstly, so to speed up, 
    477477          // if last one is own, then all properties are own. 
    478       
     478 
    479479          var key; 
    480480          for ( key in obj ) {} 
    481            
     481 
    482482          return key === undefined || hasOwnProperty.call( obj, key ); 
    483483     }, 
     
    489489          return true; 
    490490     }, 
    491       
     491 
    492492     error: function( msg ) { 
    493493          throw msg; 
    494494     }, 
    495       
     495 
    496496     parseJSON: function( data ) { 
    497497          if ( typeof data !== "string" || !data ) { 
     
    501501          // Make sure leading/trailing whitespace is removed (IE can't handle it) 
    502502          data = jQuery.trim( data ); 
    503            
     503 
    504504          // Make sure the incoming data is actual JSON 
    505505          // Logic borrowed from http://json.org/json2.js 
     
    628628                    first[ i++ ] = second[ j ]; 
    629629               } 
    630            
     630 
    631631          } else { 
    632632               while ( second[j] !== undefined ) { 
     
    795795function access( elems, key, value, exec, fn, pass ) { 
    796796     var length = elems.length; 
    797       
     797 
    798798     // Setting many attributes 
    799799     if ( typeof key === "object" ) { 
     
    803803          return elems; 
    804804     } 
    805       
     805 
    806806     // Setting one attribute 
    807807     if ( value !== undefined ) { 
    808808          // Optionally, function values get executed if exec is true 
    809809          exec = !pass && exec && jQuery.isFunction(value); 
    810            
     810 
    811811          for ( var i = 0; i < length; i++ ) { 
    812812               fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); 
    813813          } 
    814            
     814 
    815815          return elems; 
    816816     } 
    817       
     817 
    818818     // Getting an attribute 
    819819     return length ? fn( elems[0], key ) : undefined; 
     
    910910     try { 
    911911          delete script.test; 
    912       
     912 
    913913     } catch(e) { 
    914914          jQuery.support.deleteExpando = false; 
     
    951951     // Technique from Juriy Zaytsev 
    952952     // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/ 
    953      var eventSupported = function( eventName ) {  
    954           var el = document.createElement("div");  
    955           eventName = "on" + eventName;  
    956  
    957           var isSupported = (eventName in el);  
    958           if ( !isSupported ) {  
    959                el.setAttribute(eventName, "return;");  
    960                isSupported = typeof el[eventName] === "function";  
    961           }  
    962           el = null;  
    963  
    964           return isSupported;  
     953     var eventSupported = function( eventName ) { 
     954          var el = document.createElement("div"); 
     955          eventName = "on" + eventName; 
     956 
     957          var isSupported = (eventName in el); 
     958          if ( !isSupported ) { 
     959               el.setAttribute(eventName, "return;"); 
     960               isSupported = typeof el[eventName] === "function"; 
     961          } 
     962          el = null; 
     963 
     964          return isSupported; 
    965965     }; 
    966       
     966 
    967967     jQuery.support.submitBubbles = eventSupported("submit"); 
    968968     jQuery.support.changeBubbles = eventSupported("change"); 
     
    988988jQuery.extend({ 
    989989     cache: {}, 
    990       
     990 
    991991     expando:expando, 
    992992 
     
    10151015 
    10161016          // Compute a unique ID for the element 
    1017           if ( !id ) {  
     1017          if ( !id ) { 
    10181018               id = ++uuid; 
    10191019          } 
     
    13851385                         return elem.getAttribute("value") === null ? "on" : elem.value; 
    13861386                    } 
    1387                      
     1387 
    13881388 
    13891389                    // Everything else, we just grab the value 
     
    14461446          offset: true 
    14471447     }, 
    1448            
     1448 
    14491449     attr: function( elem, name, value, pass ) { 
    14501450          // don't set attributes on text and comment nodes 
     
    14751475                    if ( parent ) { 
    14761476                         parent.selectedIndex; 
    1477       
     1477 
    14781478                         // Make sure that it also works with optgroups, see #5701 
    14791479                         if ( parent.parentNode ) { 
     
    16521652                    } 
    16531653               } 
    1654                 
    1655                if ( special.add ) {  
    1656                     special.add.call( elem, handleObj );  
     1654 
     1655               if ( special.add ) { 
     1656                    special.add.call( elem, handleObj ); 
    16571657 
    16581658                    if ( !handleObj.handler.guid ) { 
     
    17211721                    type = namespaces.shift(); 
    17221722 
    1723                     namespace = new RegExp("(^|\\.)" +  
     1723                    namespace = new RegExp("(^|\\.)" + 
    17241724                         jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)") 
    17251725               } 
     
    18741874                    special = jQuery.event.special[ type ] || {}; 
    18751875 
    1876                if ( (!special._default || special._default.call( elem, event ) === false) &&  
     1876               if ( (!special._default || special._default.call( elem, event ) === false) && 
    18771877                    !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) { 
    18781878 
     
    19331933                         event.data = handleObj.data; 
    19341934                         event.handleObj = handleObj; 
    1935       
     1935 
    19361936                         var ret = handleObj.handler.apply( this, arguments ); 
    19371937 
     
    20272027          live: { 
    20282028               add: function( handleObj ) { 
    2029                     jQuery.event.add( this, handleObj.origType, jQuery.extend({}, handleObj, {handler: liveHandler}) );  
     2029                    jQuery.event.add( this, handleObj.origType, jQuery.extend({}, handleObj, {handler: liveHandler}) ); 
    20302030               }, 
    20312031 
     
    20332033                    var remove = true, 
    20342034                         type = handleObj.origType.replace(rnamespaces, ""); 
    2035                      
     2035 
    20362036                    jQuery.each( jQuery.data(this, "events").live || [], function() { 
    20372037                         if ( type === this.origType.replace(rnamespaces, "") ) { 
     
    20692069     function( elem, type, handle ) { 
    20702070          elem.removeEventListener( type, handle, false ); 
    2071      } :  
     2071     } : 
    20722072     function( elem, type, handle ) { 
    20732073          elem.detachEvent( "on" + type, handle ); 
     
    21142114               return; 
    21152115          } 
    2116            
     2116 
    21172117          // if preventDefault exists run it on the original event 
    21182118          if ( e.preventDefault ) { 
     
    22062206                         } 
    22072207                    }); 
    2208        
     2208 
    22092209                    jQuery.event.add(this, "keypress.specialSubmit", function( e ) { 
    22102210                         var elem = e.target, type = elem.type; 
     
    22682268               jQuery.data( elem, "_change_data", val ); 
    22692269          } 
    2270            
     2270 
    22712271          if ( data === undefined || val === data ) { 
    22722272               return; 
     
    22812281     jQuery.event.special.change = { 
    22822282          filters: { 
    2283                focusout: testChange,  
     2283               focusout: testChange, 
    22842284 
    22852285               click: function( e ) { 
     
    23452345               setup: function() { 
    23462346                    this.addEventListener( orig, handler, true ); 
    2347                },  
    2348                teardown: function() {  
     2347               }, 
     2348               teardown: function() { 
    23492349                    this.removeEventListener( orig, handler, true ); 
    23502350               } 
    23512351          }; 
    23522352 
    2353           function handler( e ) {  
     2353          function handler( e ) { 
    23542354               e = jQuery.event.fix( e ); 
    23552355               e.type = fix; 
     
    23682368               return this; 
    23692369          } 
    2370            
     2370 
    23712371          if ( jQuery.isFunction( data ) ) { 
    23722372               fn = data; 
     
    24082408          return this; 
    24092409     }, 
    2410       
     2410 
    24112411     delegate: function( selector, types, data, fn ) { 
    24122412          return this.live( types, data, fn, selector ); 
    24132413     }, 
    2414       
     2414 
    24152415     undelegate: function( selector, types, fn ) { 
    24162416          if ( arguments.length === 0 ) { 
    24172417                    return this.unbind( "live" ); 
    2418            
     2418 
    24192419          } else { 
    24202420               return this.die( types, null, fn, selector ); 
    24212421          } 
    24222422     }, 
    2423       
     2423 
    24242424     trigger: function( type, data ) { 
    24252425          return this.each(function() { 
     
    25212521               } 
    25222522          } 
    2523            
     2523 
    25242524          return this; 
    25252525     } 
     
    26522652          return []; 
    26532653     } 
    2654       
     2654 
    26552655     if ( !selector || typeof selector !== "string" ) { 
    26562656          return results; 
     
    26592659     var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context), 
    26602660          soFar = selector; 
    2661       
     2661 
    26622662     // Reset the position of the chunker regexp (start from head) 
    26632663     while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) { 
    26642664          soFar = m[3]; 
    2665            
     2665 
    26662666          parts.push( m[1] ); 
    2667            
     2667 
    26682668          if ( m[2] ) { 
    26692669               extra = m[3]; 
     
    26862686                         selector += parts.shift(); 
    26872687                    } 
    2688                      
     2688 
    26892689                    set = posProcess( selector, set ); 
    26902690               } 
     
    27972797     for ( var i = 0, l = Expr.order.length; i < l; i++ ) { 
    27982798          var type = Expr.order[i], match; 
    2799            
     2799 
    28002800          if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { 
    28012801               var left = match[1]; 
     
    30713071          ATTR: function(match, curLoop, inplace, result, not, isXML){ 
    30723072               var name = match[1].replace(/\\/g, ""); 
    3073                 
     3073 
    30743074               if ( !isXML && Expr.attrMap[name] ) { 
    30753075                    match[1] = Expr.attrMap[name]; 
     
    30973097                    return true; 
    30983098               } 
    3099                 
     3099 
    31003100               return match; 
    31013101          }, 
     
    32183218                    case 'first': 
    32193219                         while ( (node = node.previousSibling) )  { 
    3220                               if ( node.nodeType === 1 ) {  
    3221                                    return false;  
     3220                              if ( node.nodeType === 1 ) { 
     3221                                   return false; 
    32223222                              } 
    32233223                         } 
    3224                          if ( type === "first" ) {  
    3225                               return true;  
     3224                         if ( type === "first" ) { 
     3225                              return true; 
    32263226                         } 
    32273227                         node = elem; 
    32283228                    case 'last': 
    32293229                         while ( (node = node.nextSibling) )      { 
    3230                               if ( node.nodeType === 1 ) {  
    3231                                    return false;  
     3230                              if ( node.nodeType === 1 ) { 
     3231                                   return false; 
    32323232                              } 
    32333233                         } 
     
    32393239                              return true; 
    32403240                         } 
    3241                           
     3241 
    32423242                         var doneName = match[0], 
    32433243                              parent = elem.parentNode; 
    3244       
     3244 
    32453245                         if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { 
    32463246                              var count = 0; 
     
    32493249                                        node.nodeIndex = ++count; 
    32503250                                   } 
    3251                               }  
     3251                              } 
    32523252                              parent.sizcache = doneName; 
    32533253                         } 
    3254                           
     3254 
    32553255                         var diff = elem.nodeIndex - last; 
    32563256                         if ( first === 0 ) { 
     
    33283328          return results; 
    33293329     } 
    3330       
     3330 
    33313331     return array; 
    33323332}; 
     
    35203520               return; 
    35213521          } 
    3522       
     3522 
    35233523          Sizzle = function(query, context, extra, seed){ 
    35243524               context = context || document; 
     
    35313531                    } catch(e){} 
    35323532               } 
    3533            
     3533 
    35343534               return oldSizzle(query, context, extra, seed); 
    35353535          }; 
     
    35603560          return; 
    35613561     } 
    3562       
     3562 
    35633563     Expr.order.splice(1, 0, "CLASS"); 
    35643564     Expr.find.CLASS = function(match, context, isXML) { 
     
    36483648var isXML = function(elem){ 
    36493649     // documentElement is verified for cases where it doesn't yet exist 
    3650      // (such as loading iframes in IE - #4833)  
     3650     // (such as loading iframes in IE - #4833) 
    36513651     var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement; 
    36523652     return documentElement ? documentElement.nodeName !== "HTML" : false; 
     
    37643764          return this.pushStack( winnow(this, selector, true), "filter", selector ); 
    37653765     }, 
    3766       
     3766 
    37673767     is: function( selector ) { 
    37683768          return !!selector && jQuery.filter( selector, this ).length > 0; 
     
    37783778 
    37793779                         if ( !matches[selector] ) { 
    3780                               matches[selector] = jQuery.expr.match.POS.test( selector ) ?  
     3780                              matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
    37813781                                   jQuery( selector, context || this.context ) : 
    37823782                                   selector; 
     
    38003800          } 
    38013801 
    3802           var pos = jQuery.expr.match.POS.test( selectors ) ?  
     3802          var pos = jQuery.expr.match.POS.test( selectors ) ? 
    38033803               jQuery( selectors, context || this.context ) : null; 
    38043804 
     
    38133813          }); 
    38143814     }, 
    3815       
     3815 
    38163816     // Determine the position of an element within 
    38173817     // the matched set of elements 
     
    38943894     jQuery.fn[ name ] = function( until, selector ) { 
    38953895          var ret = jQuery.map( this, fn, until ); 
    3896            
     3896 
    38973897          if ( !runtil.test( name ) ) { 
    38983898               selector = until; 
     
    39213921          return jQuery.find.matches(expr, elems); 
    39223922     }, 
    3923       
     3923 
    39243924     dir: function( elem, dir, until ) { 
    39253925          var matched = [], cur = elem[dir]; 
     
    41094109          } 
    41104110     }, 
    4111       
     4111 
    41124112     // keepData is for internal use only--do not document 
    41134113     remove: function( selector, keepData ) { 
     
    41244124               } 
    41254125          } 
    4126            
     4126 
    41274127          return this; 
    41284128     }, 
     
    41404140               } 
    41414141          } 
    4142            
     4142 
    41434143          return this; 
    41444144     }, 
     
    42874287                    results = buildFragment( args, this, scripts ); 
    42884288               } 
    4289                 
     4289 
    42904290               fragment = results.fragment; 
    4291                 
     4291 
    42924292               if ( fragment.childNodes.length === 1 ) { 
    42934293                    first = fragment = fragment.firstChild; 
     
    43944394          var ret = [], insert = jQuery( selector ), 
    43954395               parent = this.length === 1 && this[0].parentNode; 
    4396            
     4396 
    43974397          if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) { 
    43984398               insert[ original ]( this[0] ); 
    43994399               return this; 
    4400                 
     4400 
    44014401          } else { 
    44024402               for ( var i = 0, l = insert.length; i < l; i++ ) { 
     
    44054405                    ret = ret.concat( elems ); 
    44064406               } 
    4407            
     4407 
    44084408               return this.pushStack( ret, name, insert.selector ); 
    44094409          } 
     
    44934493                    if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { 
    44944494                         scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] ); 
    4495                      
     4495 
    44964496                    } else { 
    44974497                         if ( ret[i].nodeType === 1 ) { 
     
    45054505          return ret; 
    45064506     }, 
    4507       
     4507 
    45084508     cleanData: function( elems ) { 
    45094509          var data, id, cache = jQuery.cache, 
    45104510               special = jQuery.event.special, 
    45114511               deleteExpando = jQuery.support.deleteExpando; 
    4512            
     4512 
    45134513          for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) { 
    45144514               id = elem[ jQuery.expando ]; 
    4515                 
     4515 
    45164516               if ( id ) { 
    45174517                    data = cache[ id ]; 
    4518                      
     4518 
    45194519                    if ( data.events ) { 
    45204520                         for ( var type in data.events ) { 
     
    45274527                         } 
    45284528                    } 
    4529                      
     4529 
    45304530                    if ( deleteExpando ) { 
    45314531                         delete elem[ jQuery.expando ]; 
     
    45344534                         elem.removeAttribute( jQuery.expando ); 
    45354535                    } 
    4536                      
     4536 
    45374537                    delete cache[ id ]; 
    45384538               } 
     
    45674567               return jQuery.curCSS( elem, name ); 
    45684568          } 
    4569            
     4569 
    45704570          if ( typeof value === "number" && !rexclude.test(name) ) { 
    45714571               value += "px"; 
     
    49754975     ajax: function( origSettings ) { 
    49764976          var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings); 
    4977            
     4977 
    49784978          var jsonp, status, data, 
    49794979               callbackContext = origSettings && origSettings.context || s, 
     
    52905290               } 
    52915291          } 
    5292            
     5292 
    52935293          function trigger(type, args) { 
    52945294               (s.context ? jQuery(s.context) : jQuery.event).trigger(type, args); 
     
    53785378     param: function( a, traditional ) { 
    53795379          var s = []; 
    5380            
     5380 
    53815381          // Set traditional to true for jQuery <= 1.3.2 behavior. 
    53825382          if ( traditional === undefined ) { 
    53835383               traditional = jQuery.ajaxSettings.traditional; 
    53845384          } 
    5385            
     5385 
    53865386          // If an array was passed in, assume that it is an array of form elements. 
    53875387          if ( jQuery.isArray(a) || a.jquery ) { 
     
    53905390                    add( this.name, this.value ); 
    53915391               }); 
    5392                 
     5392 
    53935393          } else { 
    53945394               // If traditional, encode the "old" way (the way 1.3.2 or older 
     
    54205420                         } 
    54215421                    }); 
    5422                           
     5422 
    54235423               } else if ( !traditional && obj != null && typeof obj === "object" ) { 
    54245424                    // Serialize object item. 
     
    54265426                         buildParams( prefix + "[" + k + "]", v ); 
    54275427                    }); 
    5428                           
     5428 
    54295429               } else { 
    54305430                    // Serialize scalar item. 
     
    58775877          } 
    58785878     }, 
    5879            
     5879 
    58805880     stop: function() { 
    58815881          clearInterval( timerId ); 
    58825882          timerId = null; 
    58835883     }, 
    5884       
     5884 
    58855885     speeds: { 
    58865886          slow: 600, 
     
    59265926          var elem = this[0]; 
    59275927 
    5928           if ( options ) {  
     5928          if ( options ) { 
    59295929               return this.each(function( i ) { 
    59305930                    jQuery.offset.setOffset( this, options, i ); 
     
    59525952          var elem = this[0]; 
    59535953 
    5954           if ( options ) {  
     5954          if ( options ) { 
    59555955               return this.each(function( i ) { 
    59565956                    jQuery.offset.setOffset( this, options, i ); 
     
    60606060          return { top: top, left: left }; 
    60616061     }, 
    6062       
     6062 
    60636063     setOffset: function( elem, options, i ) { 
    60646064          // set position first, in-case top/left are set even on static elem 
     
    60796079               left: (options.left - curOffset.left) + curLeft 
    60806080          }; 
    6081            
     6081 
    60826082          if ( "using" in options ) { 
    60836083               options.using.call( elem, props ); 
     
    61396139     jQuery.fn[ method ] = function(val) { 
    61406140          var elem = this[0], win; 
    6141            
     6141 
    61426142          if ( !elem ) { 
    61436143               return null; 
     
    62036203               return size == null ? null : this; 
    62046204          } 
    6205            
     6205 
    62066206          if ( jQuery.isFunction( size ) ) { 
    62076207               return this.each(function( i ) { 
  • themes/default/js/post.js

    r0 r2566  
    66               '</p>' 
    77          ); 
    8       
     8 
    99     var cookie = readCookie($.cookie('comment_info')); 
    10       
    11       
     10 
     11 
    1212     if (cookie != false) { 
    1313          $('#c_name').val(cookie[0]); 
     
    1616          $('#c_remember').attr('checked','checked'); 
    1717     } 
    18       
     18 
    1919     $('#c_remember').click(function() { 
    2020          if (this.checked) { 
     
    2424          } 
    2525     }); 
    26       
     26 
    2727     $('#c_name').change(function() { 
    2828          if ($('#c_remember').get(0).checked) { 
     
    3030          } 
    3131     }); 
    32       
     32 
    3333     $('#c_mail').change(function() { 
    3434          if ($('#c_remember').get(0).checked) { 
     
    3636          } 
    3737     }); 
    38       
     38 
    3939     $('#c_site').change(function() { 
    4040          if ($('#c_remember').get(0).checked) { 
     
    4242          } 
    4343     }); 
    44       
     44 
    4545     function setCookie() { 
    4646          var name = $('#c_name').val(); 
     
    5353               cpath = cpath.replace(/.*:\/\/[^\/]*([^?]*).*/g,"$1"); 
    5454          } 
    55            
     55 
    5656          $.cookie('comment_info', name + '\n' + mail + '\n' + site, {expires: 60, path: cpath}); 
    5757     } 
    58       
     58 
    5959     function dropCookie() { 
    6060          $.cookie('comment_info','',{expires: -30, path: '/'}); 
    6161     } 
    62       
     62 
    6363     function readCookie(c) { 
    6464          if (!c) { 
    6565               return false; 
    6666          } 
    67            
     67 
    6868          var s = c.split('\n'); 
    69            
     69 
    7070          if (s.length != 3) { 
    7171               dropCookie(); 
    7272               return false; 
    7373          } 
    74            
     74 
    7575          return s; 
    7676     } 
  • themes/default/style.css

    r1179 r2566  
    533533     color: #279ac4; 
    534534     border: 1px solid #cdcdcd; 
    535      padding: 1px 2px;    
     535     padding: 1px 2px; 
    536536     width: 68%; 
    537537} 
Note: See TracChangeset for help on using the changeset viewer.

Sites map