Changeset 62029 in spip-zone


Ignore:
Timestamp:
Jun 2, 2012, 4:03:13 PM (9 years ago)
Author:
cedric@…
Message:

mise a jour du multidatespicker.js

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/agenda/trunk/javascript/jquery-ui.multidatespicker.js

    r58758 r62029  
    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                                                                        addDate.call(this, dates[i], type, true);
     289                                                                sortDates.call(this, type);
     290                                                                break;
     291                                                        } // else does the same as 'string'
     292                                                case 'string':
     293                                                case 'number':
     294                                                        addDate.call(this, dates, type);
    251295                                                        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');
     296                                                default:
     297                                                        $.error('Date format "'+ typeof dates +'" not allowed on jQuery.multiDatesPicker');
     298                                        }
     299                                        $(this).datepicker('refresh');
     300                                } else {
     301                                        $.error('Empty array of dates received.');
     302                                }
     303                        },
     304                        removeDates : function( dates, type ) {
     305                                if(!type) type = 'picked';
     306                                var removed = [];
     307                                if (Object.prototype.toString.call(dates) === '[object Array]') {
     308                                        for(var i in dates.sort(function(a,b){return b-a})) {
     309                                                removed.push(removeDate.call(this, dates[i], type));
     310                                        }
     311                                } else {
     312                                        removed.push(removeDate.call(this, dates, type));
    258313                                }
    259314                                $(this).datepicker('refresh');
    260                         },
    261                         removeDates : function( indexes, type ) {
    262                                 if(!type) type = 'picked';
    263                                 if (Object.prototype.toString.call(indexes) === '[object Array]')
    264                                         for(var i in indexes) removeDate.call(this, i, type);
    265                                 else
    266                                         removeDate.call(this, indexes, type);
     315                                return removed;
     316                        },
     317                        removeIndexes : function( indexes, type ) {
     318                                if(!type) type = 'picked';
     319                                var removed = [];
     320                                if (Object.prototype.toString.call(indexes) === '[object Array]') {
     321                                        for(var i in indexes.sort(function(a,b){return b-a})) {
     322                                                removed.push(removeIndex.call(this, indexes[i], type));
     323                                        }
     324                                } else {
     325                                        removed.push(removeIndex.call(this, indexes, type));
     326                                }
    267327                                $(this).datepicker('refresh');
     328                                return removed;
    268329                        },
    269330                        resetDates : function ( type ) {
     
    274335                        toggleDate : function( date, type ) {
    275336                                if(!type) type = 'picked';
    276                                 var index = methods.gotDate.call(this, date);
    277                                 var mode = this.multiDatesPicker.mode;
    278                                
    279                                 switch(mode.modeName) {
     337                               
     338                                switch(this.multiDatesPicker.mode) {
    280339                                        case 'daysRange':
    281340                                                this.multiDatesPicker.dates[type] = []; // deletes all picked/disabled dates
    282                                                 var end = mode.options.autoselectRange[1];
    283                                                 var begin = mode.options.autoselectRange[0];
     341                                                var end = this.multiDatesPicker.autoselectRange[1];
     342                                                var begin = this.multiDatesPicker.autoselectRange[0];
    284343                                                if(end < begin) { // switch
    285                                                         end = mode.options.autoselectRange[0];
    286                                                         begin = mode.options.autoselectRange[1];
     344                                                        end = this.multiDatesPicker.autoselectRange[0];
     345                                                        begin = this.multiDatesPicker.autoselectRange[1];
    287346                                                }
    288347                                                for(var i = begin; i < end; i++)
     
    290349                                                break;
    291350                                        default:
    292                                                 if(index === false) // adds dates
     351                                                if(methods.gotDate.call(this, date) === false) // adds dates
    293352                                                        methods.addDates.call(this, date, type);
    294353                                                else // removes dates
    295                                                         methods.removeDates.call(this, index, type);
     354                                                        methods.removeDates.call(this, date, type);
    296355                                                break;
    297356                                }
    298357                        },
    299                         setMode : function( mode ) {
    300                                 this.multiDatesPicker.mode.modeName = mode.modeName;
    301                                 var option;
    302                                 switch(mode.modeName) {
     358                        setMode : function( options ) {
     359                                var $this = $(this);
     360                                if(options.mode) this.multiDatesPicker.mode = options.mode;
     361                               
     362                                switch(this.multiDatesPicker.mode) {
    303363                                        case 'normal':
    304                                                 for(option in mode.options)
     364                                                for(option in options)
    305365                                                        switch(option) {
    306366                                                                case 'maxPicks':
    307367                                                                case 'minPicks':
    308368                                                                case 'pickableRange':
    309                                                                 case 'pickableRangeDelay':
    310369                                                                case 'adjustRangeToDisabled':
    311                                                                         this.multiDatesPicker.mode.options[option] = mode.options[option];
     370                                                                        this.multiDatesPicker[option] = options[option];
    312371                                                                        break;
    313                                                                 default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
     372                                                                //default: $.error('Option ' + option + ' ignored for mode "'.options.mode.'".');
    314373                                                        }
    315374                                        break;
     
    317376                                        case 'weeksRange':
    318377                                                var mandatory = 1;
    319                                                 for(option in mode.options)
     378                                                for(option in options)
    320379                                                        switch(option) {
    321380                                                                case 'autoselectRange':
    322381                                                                        mandatory--;
    323382                                                                case 'pickableRange':
    324                                                                 case 'pickableRangeDelay':
    325383                                                                case 'adjustRangeToDisabled':
    326                                                                         this.multiDatesPicker.mode.options[option] = mode.options[option];
     384                                                                        this.multiDatesPicker[option] = options[option];
    327385                                                                        break;
    328                                                                 default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
     386                                                                //default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
    329387                                                        }
    330388                                                if(mandatory > 0) $.error('Some mandatory options not specified!');
     
    332390                                }
    333391                               
    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');
     392                                /*
     393                                if(options.pickableRange) {
     394                                        $this.datepicker("option", "maxDate", options.pickableRange);
     395                                        $this.datepicker("option", "minDate", this.multiDatesPicker.minDate);
     396                                }
     397                                */
     398                               
     399                                if(mdp_events.onSelect)
     400                                        mdp_events.onSelect();
     401                                $this.datepicker('refresh');
    341402                        }
    342403                };
    343404               
    344405                this.each(function() {
    345                         if (!this.multiDatesPicker)
     406                        if (!this.multiDatesPicker) {
    346407                                this.multiDatesPicker = {
    347408                                        dates: {
     
    349410                                                disabled: []
    350411                                        },
    351                                         mode: {
    352                                                 modeName: 'normal',
    353                                                 options: {
    354                                                         adjustRangeToDisabled: true
    355                                                 }
    356                                         }
     412                                        mode: 'normal',
     413                                        adjustRangeToDisabled: true
    357414                                };
     415                        }
    358416                       
    359417                        if(methods[method]) {
     
    361419                                switch(method) {
    362420                                        case 'getDates':
     421                                        case 'removeDates':
    363422                                        case 'gotDate':
    364423                                        case 'sumDays':
Note: See TracChangeset for help on using the changeset viewer.