Changeset 62031 in spip-zone


Ignore:
Timestamp:
Jun 2, 2012, 4:09:29 PM (7 years ago)
Author:
cedric@…
Message:

Maj de jquery-ui.multidatespicker.js issu de http://zone.spip.org/trac/spip-zone/changeset/62030 et correction du meme bug dans l'autre js (compat safari)

Location:
_plugins_/calendrier_mini/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/calendrier_mini/trunk/javascript/calendrier_mini.js.html

    r60369 r62031  
    4343                if (data.length){
    4444                        var d,datebegin,dateend;
    45                         for(var j in data){
     45                        for(var j=0;j<data.length;j++){
    4646                                d = data[j].start.split(" ");
    4747                                d = d[0].split("-");
     
    5353                                        d = d[0].split("-");
    5454                                        d = new Date(d[0],d[1]-1,d[2]);
    55                                         dates.push(d);
    5655                                        dateend = d.getTime();
    57                                         datebegin = datebegin+(3600*24*1000);
    58                                         while(datebegin < dateend){
    59                                                 d = new Date(datebegin);
     56                                        if (dateend>datebegin){
    6057                                                dates.push(d);
    6158                                                datebegin = datebegin+(3600*24*1000);
     59                                                while(datebegin < dateend){
     60                                                        d = new Date(datebegin);
     61                                                        dates.push(d);
     62                                                        datebegin = datebegin+(3600*24*1000);
     63                                                }
    6264                                        }
    6365                                }
  • _plugins_/calendrier_mini/trunk/javascript/jquery-ui.multidatespicker.js

    r60044 r62031  
    11/*
    2  * MultiDatesPicker v1.5.2
     2 * MultiDatesPicker v1.6.1
    33 * http://multidatespickr.sourceforge.net/
    44 *
     
    77 */
    88(function( $ ){
    9         $.extend($.ui, { multiDatesPicker: { version: "1.5.2" } });
     9        $.extend($.ui, { multiDatesPicker: { version: "1.6.1" } });
    1010       
    1111        $.fn.multiDatesPicker = function(method) {
     
    1616                var mdp_events = {};
    1717               
    18                 function removeDate(index, type) {
     18                function removeDate(date, type) {
    1919                        if(!type) type = 'picked';
    20                         this.multiDatesPicker.dates[type].splice(index, 1);
     20                        date = dateConvert.call(this, date);
     21                        for(var i in this.multiDatesPicker.dates[type])
     22                                if(!methods.compareDates(this.multiDatesPicker.dates[type][i], date))
     23                                        return this.multiDatesPicker.dates[type].splice(i, 1).pop();
     24                }
     25                function removeIndex(index, type) {
     26                        if(!type) type = 'picked';
     27                        return this.multiDatesPicker.dates[type].splice(index, 1).pop();
    2128                }
    2229                function addDate(date, type, no_sort) {
    2330                        if(!type) type = 'picked';
     31                        date = dateConvert.call(this, date);
     32                       
     33                        // @todo: use jQuery UI datepicker method instead
     34                        date.setHours(0);
     35                        date.setMinutes(0);
     36                        date.setSeconds(0);
     37                        date.setMilliseconds(0);
     38                       
    2439                        if (methods.gotDate.call(this, date, type) === false) {
    25                                 this.multiDatesPicker.dates[type].push(dateConvert.call(this, date));
     40                                this.multiDatesPicker.dates[type].push(date);
    2641                                if(!no_sort) this.multiDatesPicker.dates[type].sort(methods.compareDates);
    2742                        }
     
    3247                }
    3348                function dateConvert(date, desired_type, date_format) {
    34                         if(!desired_type) desired_type = 'object';
     49                        if(!desired_type) desired_type = 'object';/*
    3550                        if(!date_format && (typeof date == 'string')) {
    3651                                date_format = $(this).datepicker('option', 'dateFormat');
    3752                                if(!date_format) date_format = $.datepicker._defaults.dateFormat;
    3853                        }
    39                        
     54                        */
    4055                        return methods.dateConvert.call(this, date, desired_type, date_format);
    4156                }
     
    4964                                        beforeShow: function(input, inst) {
    5065                                                this.multiDatesPicker.changed = false;
    51                                                 if(this.multiDatesPicker.originalBeforeShow) this.multiDatesPicker.originalBeforeShow.call(this, input, inst);
     66                                                if(this.multiDatesPicker.originalBeforeShow)
     67                                                        this.multiDatesPicker.originalBeforeShow.call(this, input, inst);
    5268                                        },
    5369                                        onSelect : function(dateText, inst) {
     
    5773                                                if (dateText) {
    5874                                                        $this.multiDatesPicker('toggleDate', dateText);
    59                                                         var current_date = dateConvert.call(this, dateText);
    60                                                 }
    61                                                 var dates_picked = $this.multiDatesPicker('getDates');
    62                                                 var datos = this.multiDatesPicker.mode.options;
    63                                                
    64                                                 if (dates_picked.length > 0) {
    65                                                         if (this.multiDatesPicker.mode.modeName == 'normal') {
    66                                                                 if (datos.pickableRange) {
    67                                                                         var min_date = methods.compareDates(dateConvert.call(this, this.multiDatesPicker.minDate, 'object'), today_date);
    68                                                                         var max_date = min_date + datos.pickableRangeDelay + pickableRange;
    69                                                                        
    70                                                                         // min
    71                                                                         var n_min_date = methods.compareDates(dateConvert.call(this, dates_picked[0], 'object'), dateConvert.call(this, min_date, 'object'));
    72                                                                        
    73                                                                         // max
    74                                                                         var n_max_date = n_min_date + datos.pickableRange;
    75                                                                        
    76                                                                         // adjust
    77                                                                         if (n_max_date > max_date) min_date = max_date - datos.pickableRange + 1;
    78                                                                         else {
    79                                                                                 max_date = n_max_date;
    80                                                                                 min_date = n_min_date;
     75                                                }
     76                                               
     77                                                if (this.multiDatesPicker.mode == 'normal' && this.multiDatesPicker.dates.picked.length > 0 && this.multiDatesPicker.pickableRange) {
     78                                                        var min_date = this.multiDatesPicker.dates.picked[0],
     79                                                                max_date = new Date(min_date.getTime());
     80                                                       
     81                                                        methods.sumDays(max_date, this.multiDatesPicker.pickableRange-1);
     82                                                               
     83                                                        // counts the number of disabled dates in the range
     84                                                        if(this.multiDatesPicker.adjustRangeToDisabled) {
     85                                                                var c_disabled,
     86                                                                        disabled = this.multiDatesPicker.dates.disabled.slice(0);
     87                                                                do {
     88                                                                        c_disabled = 0;
     89                                                                        for(var i = 0; i < disabled.length; i++) {
     90                                                                                if(disabled[i].getTime() <= max_date.getTime()) {
     91                                                                                        if((min_date.getTime() <= disabled[i].getTime()) && (disabled[i].getTime() <= max_date.getTime()) ) {
     92                                                                                                c_disabled++;
     93                                                                                        }
     94                                                                                        disabled.splice(i, 1);
     95                                                                                        i--;
     96                                                                                }
    8197                                                                        }
    82                                                                                
    83                                                                         // counts the number of disabled dates in the range
    84                                                                         var c_disabled;
    85                                                                         do {
    86                                                                                 c_disabled = 0;
    87                                                                                 for(var i in this.multiDatesPicker.dates.disabled) {
    88                                                                                         var avdatei = dateConvert.call(this, this.multiDatesPicker.dates.disabled[i], 'object');
    89                                                                                         if(methods.compareDates(avdatei, min_date) >= 0 &&
    90                                                                                                         methods.compareDates(avdatei, max_date) <= 0)
    91                                                                                                 c_disabled++;
    92                                                                                 }
    93                                                                                 max_date = max_date + c_disabled;
    94                                                                         } while(c_disabled != 0);
    95                                                                        
    96                                                                         $this.datepicker("option", "minDate", min_date);
    97                                                                         $this.datepicker("option", "maxDate", max_date);
    98                                                                 }
     98                                                                        max_date.setDate(max_date.getDate() + c_disabled);
     99                                                                } while(c_disabled != 0);
    99100                                                        }
     101                                                       
     102                                                        if(this.multiDatesPicker.maxDate && (max_date > this.multiDatesPicker.maxDate))
     103                                                                max_date = this.multiDatesPicker.maxDate;
     104                                                       
     105                                                        $this
     106                                                                .datepicker("option", "minDate", min_date)
     107                                                                .datepicker("option", "maxDate", max_date);
     108                                                } else {
     109                                                        $this
     110                                                                .datepicker("option", "minDate", this.multiDatesPicker.minDate)
     111                                                                .datepicker("option", "maxDate", this.multiDatesPicker.maxDate);
    100112                                                }
    101113                                               
     
    117129                                        },
    118130                                        beforeShowDay : function(date) {
    119                                                 var $this = $(this);
    120                                                 var gotThisDate = $this.multiDatesPicker('gotDate', date) !== false;
    121                                                 var highlight_class = gotThisDate
    122                                                         ? 'ui-state-highlight'
    123                                                         : '';
    124                                                        
    125                                                 var isDisabledDate = $this.multiDatesPicker('gotDate', date, 'disabled') !== false;
    126                                                 var allSelected = this.multiDatesPicker.mode.options.maxPicks == $this.multiDatesPicker('getDates').length;
    127                                                 var selectable_date = (isDisabledDate || (allSelected && !highlight_class))
    128                                                         ? false
    129                                                         : true;
    130                                                        
    131                                                 if(this.multiDatesPicker.originalBeforeShowDay) this.multiDatesPicker.originalBeforeShowDay.call(this, date);
    132                                                
    133                                                 return [selectable_date, highlight_class];
     131                                                var $this = $(this),
     132                                                        gotThisDate = $this.multiDatesPicker('gotDate', date) !== false,
     133                                                        isDisabledCalendar = $this.datepicker('option', 'disabled'),
     134                                                        isDisabledDate = $this.multiDatesPicker('gotDate', date, 'disabled') !== false,
     135                                                        areAllSelected = this.multiDatesPicker.maxPicks == this.multiDatesPicker.dates.picked.length;
     136                                               
     137                                                var custom = [true, ''];
     138                                                if(this.multiDatesPicker.originalBeforeShowDay)
     139                                                        custom = this.multiDatesPicker.originalBeforeShowDay.call(this, date);
     140                                               
     141                                                var highlight_class = gotThisDate ? 'ui-state-highlight' : custom[1];
     142                                                var selectable_date = !(isDisabledCalendar || isDisabledDate || (areAllSelected && !highlight_class));
     143                                                return [selectable_date && custom[0], highlight_class];
    134144                                        },
    135145                                        onClose: function(dateText, inst) {
     
    150160                                        $this.datepicker(options);
    151161                                       
    152                                         this.multiDatesPicker.minDate = $.datepicker._determineDate(this, options.minDate, day_zero);
    153                                         this.multiDatesPicker.firstAvailableDay = methods.compareDates(this.multiDatesPicker.minDate, day_zero);
     162                                        this.multiDatesPicker.minDate = $.datepicker._determineDate(this, options.minDate, null);
     163                                        this.multiDatesPicker.maxDate = $.datepicker._determineDate(this, options.maxDate, null);
    154164                                       
    155165                                        if(options.addDates) methods.addDates.call(this, options.addDates);
     
    157167                                                methods.addDates.call(this, options.addDisabledDates, 'disabled');
    158168                                       
    159                                         if(options.mode)
    160                                                 methods.setMode.call(this, options.mode);
     169                                        methods.setMode.call(this, options);
    161170                                } else {
    162171                                        $this.datepicker();
     
    172181                        },
    173182                        compareDates : function(date1, date2) {
    174                                 var one_day = 1000*60*60*24;
     183                                date1 = dateConvert.call(this, date1);
     184                                date2 = dateConvert.call(this, date2);
    175185                                // return > 0 means date1 is later than date2
    176186                                // return == 0 means date1 is the same day as date2
    177187                                // return < 0 means date1 is earlier than date2
    178                                 return Math.ceil(date1.getTime()/one_day) - Math.ceil(date2.getTime()/one_day);
     188                                var diff = date1.getFullYear() - date2.getFullYear();
     189                                if(!diff) {
     190                                        diff = date1.getMonth() - date2.getMonth();
     191                                        if(!diff)
     192                                                diff = date1.getDate() - date2.getDate();
     193                                }
     194                                return diff;
    179195                        },
    180196                        sumDays : function( date, n_days ) {
     
    185201                        },
    186202                        dateConvert : function( date, desired_format, dateFormat ) {
    187                                 if(typeof date == desired_format) return date;
     203                                var from_format = typeof date;
     204                               
     205                                if(from_format == desired_format) {
     206                                        if(from_format == 'object') {
     207                                                try {
     208                                                        date.getTime();
     209                                                } catch (e) {
     210                                                        $.error('Received date is in a non supported format!');
     211                                                        return false;
     212                                                }
     213                                        }
     214                                        return date;
     215                                }
    188216                               
    189217                                var $this = $(this);
    190218                                if(typeof date == 'undefined') date = new Date(0);
    191219                               
    192                                 if(desired_format != 'string' && desired_format != 'object')
    193                                         $.error('Date format "'+ desired_format +'" not supported on jQuery.multiDatesPicker');
    194                                
    195                                 var conversion = typeof date + '->' + desired_format;
     220                                if(desired_format != 'string' && desired_format != 'object' && desired_format != 'number')
     221                                        $.error('Date format "'+ desired_format +'" not supported!');
     222                               
    196223                                if(!dateFormat) {
    197224                                        dateFormat = $.datepicker._defaults.dateFormat;
     
    203230                                        }
    204231                                }
    205                                 switch(conversion) {
    206                                         case 'object->string':
    207                                                 return $.datepicker.formatDate(dateFormat, date);
    208                                         case 'string->object':
    209                                                 return $.datepicker.parseDate(dateFormat, date);
    210                                         default:
    211                                                 $.error('Conversion "'+ conversion +'" not allowed on jQuery.multiDatesPicker');
     232                               
     233                                // converts to object as a neutral format
     234                                switch(from_format) {
     235                                        case 'object': break;
     236                                        case 'string': date = $.datepicker.parseDate(dateFormat, date); break;
     237                                        case 'number': date = new Date(date); break;
     238                                        default: $.error('Conversion from "'+ desired_format +'" format not allowed on jQuery.multiDatesPicker');
     239                                }
     240                                // then converts to the desired format
     241                                switch(desired_format) {
     242                                        case 'object': return date;
     243                                        case 'string': return $.datepicker.formatDate(dateFormat, date);
     244                                        case 'number': return date.getTime();
     245                                        default: $.error('Conversion to "'+ desired_format +'" format not allowed on jQuery.multiDatesPicker');
    212246                                }
    213247                                return false;
     
    216250                                if(!type) type = 'picked';
    217251                                for(var i = 0; i < this.multiDatesPicker.dates[type].length; i++) {
    218                                         if(methods.compareDates(dateConvert.call(this, this.multiDatesPicker.dates[type][i]), dateConvert.call(this, date)) == 0) {
     252                                        if(methods.compareDates.call(this, this.multiDatesPicker.dates[type][i], date) === 0) {
    219253                                                return i;
    220254                                        }
     
    223257                        },
    224258                        getDates : function( format, type ) {
     259                                if(!format) format = 'string';
    225260                                if(!type) type = 'picked';
    226261                                switch (format) {
    227262                                        case 'object':
    228263                                                return this.multiDatesPicker.dates[type];
    229                                         default:
     264                                        case 'string':
     265                                        case 'number':
    230266                                                var o_dates = new Array();
    231267                                                for(var i in this.multiDatesPicker.dates[type])
     
    234270                                                                        this,
    235271                                                                        this.multiDatesPicker.dates[type][i],
    236                                                                         'string'
     272                                                                        format
    237273                                                                )
    238274                                                        );
    239275                                                return o_dates;
     276                                       
     277                                        default: $.error('Format "'+format+'" not supported!');
    240278                                }
    241279                        },
    242280                        addDates : function( dates, type ) {
    243                                 if(!type) type = 'picked';
    244                                 switch(typeof dates) {
    245                                         case 'object':
    246                                         case 'array':
    247                                                 if(dates.length) {
    248                                                         for(var i in dates)
    249                                                                 addDate.call(this, dates[i], type, true);
    250                                                         sortDates.call(this, type);
     281                                if(dates.length > 0) {
     282                                        if(!type) type = 'picked';
     283                                        switch(typeof dates) {
     284                                                case 'object':
     285                                                case 'array':
     286                                                        if(dates.length) {
     287                                                                for(var i in dates)
     288                                                                        if (typeof dates[i] != "function")
     289                                                                                addDate.call(this, dates[i], type, true);
     290                                                                sortDates.call(this, type);
     291                                                                break;
     292                                                        } // else does the same as 'string'
     293                                                case 'string':
     294                                                case 'number':
     295                                                        addDate.call(this, dates, type);
    251296                                                        break;
    252                                                 } // else does the same as 'string'
    253                                         case 'string':
    254                                                 addDate.call(this, dates, type);
    255                                                 break;
    256                                         default:
    257                                                 $.error('Date format "'+ typeof dates +'" not allowed on jQuery.multiDatesPicker');
     297                                                default:
     298                                                        $.error('Date format "'+ typeof dates +'" not allowed on jQuery.multiDatesPicker');
     299                                        }
     300                                        $(this).datepicker('refresh');
     301                                } else {
     302                                        $.error('Empty array of dates received.');
     303                                }
     304                        },
     305                        removeDates : function( dates, type ) {
     306                                if(!type) type = 'picked';
     307                                var removed = [];
     308                                if (Object.prototype.toString.call(dates) === '[object Array]') {
     309                                        for(var i in dates.sort(function(a,b){return b-a})) {
     310                                                removed.push(removeDate.call(this, dates[i], type));
     311                                        }
     312                                } else {
     313                                        removed.push(removeDate.call(this, dates, type));
    258314                                }
    259315                                $(this).datepicker('refresh');
    260                         },
    261                         removeDates : function( indexes, type ) {
    262                                 if(!type) type = 'picked';
    263                                 if(typeof indexes == 'array')
    264                                         for(var i in indexes) removeDate.call(this, i, type);
    265                                 else
    266                                         removeDate.call(this, indexes, type);
     316                                return removed;
     317                        },
     318                        removeIndexes : function( indexes, type ) {
     319                                if(!type) type = 'picked';
     320                                var removed = [];
     321                                if (Object.prototype.toString.call(indexes) === '[object Array]') {
     322                                        for(var i in indexes.sort(function(a,b){return b-a})) {
     323                                                removed.push(removeIndex.call(this, indexes[i], type));
     324                                        }
     325                                } else {
     326                                        removed.push(removeIndex.call(this, indexes, type));
     327                                }
    267328                                $(this).datepicker('refresh');
     329                                return removed;
    268330                        },
    269331                        resetDates : function ( type ) {
     
    274336                        toggleDate : function( date, type ) {
    275337                                if(!type) type = 'picked';
    276                                 var index = methods.gotDate.call(this, date);
    277                                 var mode = this.multiDatesPicker.mode;
    278                                
    279                                 switch(mode.modeName) {
     338                               
     339                                switch(this.multiDatesPicker.mode) {
    280340                                        case 'daysRange':
    281341                                                this.multiDatesPicker.dates[type] = []; // deletes all picked/disabled dates
    282                                                 var end = mode.options.autoselectRange[1];
    283                                                 var begin = mode.options.autoselectRange[0];
     342                                                var end = this.multiDatesPicker.autoselectRange[1];
     343                                                var begin = this.multiDatesPicker.autoselectRange[0];
    284344                                                if(end < begin) { // switch
    285                                                         end = mode.options.autoselectRange[0];
    286                                                         begin = mode.options.autoselectRange[1];
     345                                                        end = this.multiDatesPicker.autoselectRange[0];
     346                                                        begin = this.multiDatesPicker.autoselectRange[1];
    287347                                                }
    288348                                                for(var i = begin; i < end; i++)
     
    290350                                                break;
    291351                                        default:
    292                                                 if(index === false) // adds dates
     352                                                if(methods.gotDate.call(this, date) === false) // adds dates
    293353                                                        methods.addDates.call(this, date, type);
    294354                                                else // removes dates
    295                                                         methods.removeDates.call(this, index, type);
     355                                                        methods.removeDates.call(this, date, type);
    296356                                                break;
    297357                                }
    298358                        },
    299                         setMode : function( mode ) {
    300                                 this.multiDatesPicker.mode.modeName = mode.modeName;
    301                                 var option;
    302                                 switch(mode.modeName) {
     359                        setMode : function( options ) {
     360                                var $this = $(this);
     361                                if(options.mode) this.multiDatesPicker.mode = options.mode;
     362                               
     363                                switch(this.multiDatesPicker.mode) {
    303364                                        case 'normal':
    304                                                 for(option in mode.options)
     365                                                for(option in options)
    305366                                                        switch(option) {
    306367                                                                case 'maxPicks':
    307368                                                                case 'minPicks':
    308369                                                                case 'pickableRange':
    309                                                                 case 'pickableRangeDelay':
    310370                                                                case 'adjustRangeToDisabled':
    311                                                                         this.multiDatesPicker.mode.options[option] = mode.options[option];
     371                                                                        this.multiDatesPicker[option] = options[option];
    312372                                                                        break;
    313                                                                 default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
     373                                                                //default: $.error('Option ' + option + ' ignored for mode "'.options.mode.'".');
    314374                                                        }
    315375                                        break;
     
    317377                                        case 'weeksRange':
    318378                                                var mandatory = 1;
    319                                                 for(option in mode.options)
     379                                                for(option in options)
    320380                                                        switch(option) {
    321381                                                                case 'autoselectRange':
    322382                                                                        mandatory--;
    323383                                                                case 'pickableRange':
    324                                                                 case 'pickableRangeDelay':
    325384                                                                case 'adjustRangeToDisabled':
    326                                                                         this.multiDatesPicker.mode.options[option] = mode.options[option];
     385                                                                        this.multiDatesPicker[option] = options[option];
    327386                                                                        break;
    328                                                                 default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
     387                                                                //default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
    329388                                                        }
    330389                                                if(mandatory > 0) $.error('Some mandatory options not specified!');
     
    332391                                }
    333392                               
    334                                 if(mode.options.pickableRange) {
    335                                         $(this).datepicker("option", "maxDate", mode.options.pickableRange + (mode.options.pickableRangeDelay || 0));
    336                                         $(this).datepicker("option", "minDate", this.multiDatesPicker.minDate);
    337                                 }
    338                                
    339                                 if(mdp_events.onSelect) mdp_events.onSelect();
    340                                 $(this).datepicker('refresh');
     393                                /*
     394                                if(options.pickableRange) {
     395                                        $this.datepicker("option", "maxDate", options.pickableRange);
     396                                        $this.datepicker("option", "minDate", this.multiDatesPicker.minDate);
     397                                }
     398                                */
     399                               
     400                                if(mdp_events.onSelect)
     401                                        mdp_events.onSelect();
     402                                $this.datepicker('refresh');
    341403                        }
    342404                };
    343405               
    344406                this.each(function() {
    345                         if (!this.multiDatesPicker)
     407                        if (!this.multiDatesPicker) {
    346408                                this.multiDatesPicker = {
    347409                                        dates: {
     
    349411                                                disabled: []
    350412                                        },
    351                                         mode: {
    352                                                 modeName: 'normal',
    353                                                 options: {
    354                                                         adjustRangeToDisabled: true
    355                                                 }
    356                                         }
     413                                        mode: 'normal',
     414                                        adjustRangeToDisabled: true
    357415                                };
     416                        }
    358417                       
    359418                        if(methods[method]) {
     
    361420                                switch(method) {
    362421                                        case 'getDates':
     422                                        case 'removeDates':
    363423                                        case 'gotDate':
    364424                                        case 'sumDays':
  • _plugins_/calendrier_mini/trunk/paquet.xml

    r60511 r62031  
    22        prefix="calendriermini"
    33        categorie="date"
    4         version="2.1.0"
     4        version="2.1.1"
    55        etat="test"
    66        compatibilite="[3.0.0-beta;3.0.99]"
Note: See TracChangeset for help on using the changeset viewer.