WP Maintenance Mode - Version 1.8.6

Version Description

(02/22/2013) = * Remove log inside console for JS * Add support for time inside the countdown * Add filter hook wm_meta_authorfor the meta data author * Add filter hook wm_meta_description for custom description * Add filter hook wm_meta_keywordsfor custom meta keys

Download this release

Release Info

Developer Bueltge
Plugin Icon 128x128 WP Maintenance Mode
Version 1.8.6
Comparing to
See all releases

Code changes from version 1.8.5 to 1.8.6

Files changed (8) hide show
  1. js/jquery-ui-timepicker-addon.js +1919 -0
  2. js/wp-maintenance-mode.js +2 -1
  3. languages/wp-maintenance-mode-de_DE.mo +0 -0
  4. languages/wp-maintenance-mode-de_DE.po +0 -0
  5. readme.md +0 -71
  6. readme.txt +8 -1
  7. site.php +24 -10
  8. wp-maintenance-mode.php +18 -2
js/jquery-ui-timepicker-addon.js ADDED
@@ -0,0 +1,1919 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /*
2
+ * jQuery timepicker addon
3
+ * By: Trent Richardson [http://trentrichardson.com]
4
+ * Version 1.2
5
+ * Last Modified: 02/02/2013
6
+ *
7
+ * Copyright 2013 Trent Richardson
8
+ * You may use this project under MIT or GPL licenses.
9
+ * http://trentrichardson.com/Impromptu/GPL-LICENSE.txt
10
+ * http://trentrichardson.com/Impromptu/MIT-LICENSE.txt
11
+ */
12
+
13
+ /*jslint evil: true, white: false, undef: false, nomen: false */
14
+
15
+ (function($) {
16
+
17
+ /*
18
+ * Lets not redefine timepicker, Prevent "Uncaught RangeError: Maximum call stack size exceeded"
19
+ */
20
+ $.ui.timepicker = $.ui.timepicker || {};
21
+ if ($.ui.timepicker.version) {
22
+ return;
23
+ }
24
+
25
+ /*
26
+ * Extend jQueryUI, get it started with our version number
27
+ */
28
+ $.extend($.ui, {
29
+ timepicker: {
30
+ version: "1.2"
31
+ }
32
+ });
33
+
34
+ /*
35
+ * Timepicker manager.
36
+ * Use the singleton instance of this class, $.timepicker, to interact with the time picker.
37
+ * Settings for (groups of) time pickers are maintained in an instance object,
38
+ * allowing multiple different settings on the same page.
39
+ */
40
+ var Timepicker = function() {
41
+ this.regional = []; // Available regional settings, indexed by language code
42
+ this.regional[''] = { // Default regional settings
43
+ currentText: 'Now',
44
+ closeText: 'Done',
45
+ amNames: ['AM', 'A'],
46
+ pmNames: ['PM', 'P'],
47
+ timeFormat: 'HH:mm',
48
+ timeSuffix: '',
49
+ timeOnlyTitle: 'Choose Time',
50
+ timeText: 'Time',
51
+ hourText: 'Hour',
52
+ minuteText: 'Minute',
53
+ secondText: 'Second',
54
+ millisecText: 'Millisecond',
55
+ timezoneText: 'Time Zone',
56
+ isRTL: false
57
+ };
58
+ this._defaults = { // Global defaults for all the datetime picker instances
59
+ showButtonPanel: true,
60
+ timeOnly: false,
61
+ showHour: true,
62
+ showMinute: true,
63
+ showSecond: false,
64
+ showMillisec: false,
65
+ showTimezone: false,
66
+ showTime: true,
67
+ stepHour: 1,
68
+ stepMinute: 1,
69
+ stepSecond: 1,
70
+ stepMillisec: 1,
71
+ hour: 0,
72
+ minute: 0,
73
+ second: 0,
74
+ millisec: 0,
75
+ timezone: null,
76
+ useLocalTimezone: false,
77
+ defaultTimezone: "+0000",
78
+ hourMin: 0,
79
+ minuteMin: 0,
80
+ secondMin: 0,
81
+ millisecMin: 0,
82
+ hourMax: 23,
83
+ minuteMax: 59,
84
+ secondMax: 59,
85
+ millisecMax: 999,
86
+ minDateTime: null,
87
+ maxDateTime: null,
88
+ onSelect: null,
89
+ hourGrid: 0,
90
+ minuteGrid: 0,
91
+ secondGrid: 0,
92
+ millisecGrid: 0,
93
+ alwaysSetTime: true,
94
+ separator: ' ',
95
+ altFieldTimeOnly: true,
96
+ altTimeFormat: null,
97
+ altSeparator: null,
98
+ altTimeSuffix: null,
99
+ pickerTimeFormat: null,
100
+ pickerTimeSuffix: null,
101
+ showTimepicker: true,
102
+ timezoneIso8601: false,
103
+ timezoneList: null,
104
+ addSliderAccess: false,
105
+ sliderAccessArgs: null,
106
+ controlType: 'slider',
107
+ defaultValue: null,
108
+ parse: 'strict'
109
+ };
110
+ $.extend(this._defaults, this.regional['']);
111
+ };
112
+
113
+ $.extend(Timepicker.prototype, {
114
+ $input: null,
115
+ $altInput: null,
116
+ $timeObj: null,
117
+ inst: null,
118
+ hour_slider: null,
119
+ minute_slider: null,
120
+ second_slider: null,
121
+ millisec_slider: null,
122
+ timezone_select: null,
123
+ hour: 0,
124
+ minute: 0,
125
+ second: 0,
126
+ millisec: 0,
127
+ timezone: null,
128
+ defaultTimezone: "+0000",
129
+ hourMinOriginal: null,
130
+ minuteMinOriginal: null,
131
+ secondMinOriginal: null,
132
+ millisecMinOriginal: null,
133
+ hourMaxOriginal: null,
134
+ minuteMaxOriginal: null,
135
+ secondMaxOriginal: null,
136
+ millisecMaxOriginal: null,
137
+ ampm: '',
138
+ formattedDate: '',
139
+ formattedTime: '',
140
+ formattedDateTime: '',
141
+ timezoneList: null,
142
+ units: ['hour','minute','second','millisec'],
143
+ control: null,
144
+
145
+ /*
146
+ * Override the default settings for all instances of the time picker.
147
+ * @param settings object - the new settings to use as defaults (anonymous object)
148
+ * @return the manager object
149
+ */
150
+ setDefaults: function(settings) {
151
+ extendRemove(this._defaults, settings || {});
152
+ return this;
153
+ },
154
+
155
+ /*
156
+ * Create a new Timepicker instance
157
+ */
158
+ _newInst: function($input, o) {
159
+ var tp_inst = new Timepicker(),
160
+ inlineSettings = {},
161
+ fns = {},
162
+ overrides, i;
163
+
164
+ for (var attrName in this._defaults) {
165
+ if(this._defaults.hasOwnProperty(attrName)){
166
+ var attrValue = $input.attr('time:' + attrName);
167
+ if (attrValue) {
168
+ try {
169
+ inlineSettings[attrName] = eval(attrValue);
170
+ } catch (err) {
171
+ inlineSettings[attrName] = attrValue;
172
+ }
173
+ }
174
+ }
175
+ }
176
+ overrides = {
177
+ beforeShow: function (input, dp_inst) {
178
+ if ($.isFunction(tp_inst._defaults.evnts.beforeShow)) {
179
+ return tp_inst._defaults.evnts.beforeShow.call($input[0], input, dp_inst, tp_inst);
180
+ }
181
+ },
182
+ onChangeMonthYear: function (year, month, dp_inst) {
183
+ // Update the time as well : this prevents the time from disappearing from the $input field.
184
+ tp_inst._updateDateTime(dp_inst);
185
+ if ($.isFunction(tp_inst._defaults.evnts.onChangeMonthYear)) {
186
+ tp_inst._defaults.evnts.onChangeMonthYear.call($input[0], year, month, dp_inst, tp_inst);
187
+ }
188
+ },
189
+ onClose: function (dateText, dp_inst) {
190
+ if (tp_inst.timeDefined === true && $input.val() !== '') {
191
+ tp_inst._updateDateTime(dp_inst);
192
+ }
193
+ if ($.isFunction(tp_inst._defaults.evnts.onClose)) {
194
+ tp_inst._defaults.evnts.onClose.call($input[0], dateText, dp_inst, tp_inst);
195
+ }
196
+ }
197
+ };
198
+ for (i in overrides) {
199
+ if (overrides.hasOwnProperty(i)) {
200
+ fns[i] = o[i] || null;
201
+ }
202
+ }
203
+ tp_inst._defaults = $.extend({}, this._defaults, inlineSettings, o, overrides, {
204
+ evnts:fns,
205
+ timepicker: tp_inst // add timepicker as a property of datepicker: $.datepicker._get(dp_inst, 'timepicker');
206
+ });
207
+ tp_inst.amNames = $.map(tp_inst._defaults.amNames, function(val) {
208
+ return val.toUpperCase();
209
+ });
210
+ tp_inst.pmNames = $.map(tp_inst._defaults.pmNames, function(val) {
211
+ return val.toUpperCase();
212
+ });
213
+
214
+ // controlType is string - key to our this._controls
215
+ if(typeof(tp_inst._defaults.controlType) === 'string'){
216
+ if($.fn[tp_inst._defaults.controlType] === undefined){
217
+ tp_inst._defaults.controlType = 'select';
218
+ }
219
+ tp_inst.control = tp_inst._controls[tp_inst._defaults.controlType];
220
+ }
221
+ // controlType is an object and must implement create, options, value methods
222
+ else{
223
+ tp_inst.control = tp_inst._defaults.controlType;
224
+ }
225
+
226
+ if (tp_inst._defaults.timezoneList === null) {
227
+ var timezoneList = ['-1200', '-1100', '-1000', '-0930', '-0900', '-0800', '-0700', '-0600', '-0500', '-0430', '-0400', '-0330', '-0300', '-0200', '-0100', '+0000',
228
+ '+0100', '+0200', '+0300', '+0330', '+0400', '+0430', '+0500', '+0530', '+0545', '+0600', '+0630', '+0700', '+0800', '+0845', '+0900', '+0930',
229
+ '+1000', '+1030', '+1100', '+1130', '+1200', '+1245', '+1300', '+1400'];
230
+
231
+ if (tp_inst._defaults.timezoneIso8601) {
232
+ timezoneList = $.map(timezoneList, function(val) {
233
+ return val == '+0000' ? 'Z' : (val.substring(0, 3) + ':' + val.substring(3));
234
+ });
235
+ }
236
+ tp_inst._defaults.timezoneList = timezoneList;
237
+ }
238
+
239
+ tp_inst.timezone = tp_inst._defaults.timezone;
240
+ tp_inst.hour = tp_inst._defaults.hour < tp_inst._defaults.hourMin? tp_inst._defaults.hourMin :
241
+ tp_inst._defaults.hour > tp_inst._defaults.hourMax? tp_inst._defaults.hourMax : tp_inst._defaults.hour;
242
+ tp_inst.minute = tp_inst._defaults.minute < tp_inst._defaults.minuteMin? tp_inst._defaults.minuteMin :
243
+ tp_inst._defaults.minute > tp_inst._defaults.minuteMax? tp_inst._defaults.minuteMax : tp_inst._defaults.minute;
244
+ tp_inst.second = tp_inst._defaults.second < tp_inst._defaults.secondMin? tp_inst._defaults.secondMin :
245
+ tp_inst._defaults.second > tp_inst._defaults.secondMax? tp_inst._defaults.secondMax : tp_inst._defaults.second;
246
+ tp_inst.millisec = tp_inst._defaults.millisec < tp_inst._defaults.millisecMin? tp_inst._defaults.millisecMin :
247
+ tp_inst._defaults.millisec > tp_inst._defaults.millisecMax? tp_inst._defaults.millisecMax : tp_inst._defaults.millisec;
248
+ tp_inst.ampm = '';
249
+ tp_inst.$input = $input;
250
+
251
+ if (o.altField) {
252
+ tp_inst.$altInput = $(o.altField).css({
253
+ cursor: 'pointer'
254
+ }).focus(function() {
255
+ $input.trigger("focus");
256
+ });
257
+ }
258
+
259
+ if (tp_inst._defaults.minDate === 0 || tp_inst._defaults.minDateTime === 0) {
260
+ tp_inst._defaults.minDate = new Date();
261
+ }
262
+ if (tp_inst._defaults.maxDate === 0 || tp_inst._defaults.maxDateTime === 0) {
263
+ tp_inst._defaults.maxDate = new Date();
264
+ }
265
+
266
+ // datepicker needs minDate/maxDate, timepicker needs minDateTime/maxDateTime..
267
+ if (tp_inst._defaults.minDate !== undefined && tp_inst._defaults.minDate instanceof Date) {
268
+ tp_inst._defaults.minDateTime = new Date(tp_inst._defaults.minDate.getTime());
269
+ }
270
+ if (tp_inst._defaults.minDateTime !== undefined && tp_inst._defaults.minDateTime instanceof Date) {
271
+ tp_inst._defaults.minDate = new Date(tp_inst._defaults.minDateTime.getTime());
272
+ }
273
+ if (tp_inst._defaults.maxDate !== undefined && tp_inst._defaults.maxDate instanceof Date) {
274
+ tp_inst._defaults.maxDateTime = new Date(tp_inst._defaults.maxDate.getTime());
275
+ }
276
+ if (tp_inst._defaults.maxDateTime !== undefined && tp_inst._defaults.maxDateTime instanceof Date) {
277
+ tp_inst._defaults.maxDate = new Date(tp_inst._defaults.maxDateTime.getTime());
278
+ }
279
+ tp_inst.$input.bind('focus', function() {
280
+ tp_inst._onFocus();
281
+ });
282
+
283
+ return tp_inst;
284
+ },
285
+
286
+ /*
287
+ * add our sliders to the calendar
288
+ */
289
+ _addTimePicker: function(dp_inst) {
290
+ var currDT = (this.$altInput && this._defaults.altFieldTimeOnly) ? this.$input.val() + ' ' + this.$altInput.val() : this.$input.val();
291
+
292
+ this.timeDefined = this._parseTime(currDT);
293
+ this._limitMinMaxDateTime(dp_inst, false);
294
+ this._injectTimePicker();
295
+ },
296
+
297
+ /*
298
+ * parse the time string from input value or _setTime
299
+ */
300
+ _parseTime: function(timeString, withDate) {
301
+ if (!this.inst) {
302
+ this.inst = $.datepicker._getInst(this.$input[0]);
303
+ }
304
+
305
+ if (withDate || !this._defaults.timeOnly) {
306
+ var dp_dateFormat = $.datepicker._get(this.inst, 'dateFormat');
307
+ try {
308
+ var parseRes = parseDateTimeInternal(dp_dateFormat, this._defaults.timeFormat, timeString, $.datepicker._getFormatConfig(this.inst), this._defaults);
309
+ if (!parseRes.timeObj) {
310
+ return false;
311
+ }
312
+ $.extend(this, parseRes.timeObj);
313
+ } catch (err) {
314
+ $.timepicker.log("Error parsing the date/time string: " + err +
315
+ "\ndate/time string = " + timeString +
316
+ "\ntimeFormat = " + this._defaults.timeFormat +
317
+ "\ndateFormat = " + dp_dateFormat);
318
+ return false;
319
+ }
320
+ return true;
321
+ } else {
322
+ var timeObj = $.datepicker.parseTime(this._defaults.timeFormat, timeString, this._defaults);
323
+ if (!timeObj) {
324
+ return false;
325
+ }
326
+ $.extend(this, timeObj);
327
+ return true;
328
+ }
329
+ },
330
+
331
+ /*
332
+ * generate and inject html for timepicker into ui datepicker
333
+ */
334
+ _injectTimePicker: function() {
335
+ var $dp = this.inst.dpDiv,
336
+ o = this.inst.settings,
337
+ tp_inst = this,
338
+ litem = '',
339
+ uitem = '',
340
+ max = {},
341
+ gridSize = {},
342
+ size = null;
343
+
344
+ // Prevent displaying twice
345
+ if ($dp.find("div.ui-timepicker-div").length === 0 && o.showTimepicker) {
346
+ var noDisplay = ' style="display:none;"',
347
+ html = '<div class="ui-timepicker-div'+ (o.isRTL? ' ui-timepicker-rtl' : '') +'"><dl>' + '<dt class="ui_tpicker_time_label"' + ((o.showTime) ? '' : noDisplay) + '>' + o.timeText + '</dt>' +
348
+ '<dd class="ui_tpicker_time"' + ((o.showTime) ? '' : noDisplay) + '></dd>';
349
+
350
+ // Create the markup
351
+ for(var i=0,l=this.units.length; i<l; i++){
352
+ litem = this.units[i];
353
+ uitem = litem.substr(0,1).toUpperCase() + litem.substr(1);
354
+ // Added by Peter Medeiros:
355
+ // - Figure out what the hour/minute/second max should be based on the step values.
356
+ // - Example: if stepMinute is 15, then minMax is 45.
357
+ max[litem] = parseInt((o[litem+'Max'] - ((o[litem+'Max'] - o[litem+'Min']) % o['step'+uitem])), 10);
358
+ gridSize[litem] = 0;
359
+
360
+ html += '<dt class="ui_tpicker_'+ litem +'_label"' + ((o['show'+uitem]) ? '' : noDisplay) + '>' + o[litem +'Text'] + '</dt>' +
361
+ '<dd class="ui_tpicker_'+ litem +'"><div class="ui_tpicker_'+ litem +'_slider"' + ((o['show'+uitem]) ? '' : noDisplay) + '></div>';
362
+
363
+ if (o['show'+uitem] && o[litem+'Grid'] > 0) {
364
+ html += '<div style="padding-left: 1px"><table class="ui-tpicker-grid-label"><tr>';
365
+
366
+ if(litem == 'hour'){
367
+ for (var h = o[litem+'Min']; h <= max[litem]; h += parseInt(o[litem+'Grid'], 10)) {
368
+ gridSize[litem]++;
369
+ var tmph = $.datepicker.formatTime(useAmpm(o.pickerTimeFormat || o.timeFormat)? 'hht':'HH', {hour:h}, o);
370
+ html += '<td data-for="'+litem+'">' + tmph + '</td>';
371
+ }
372
+ }
373
+ else{
374
+ for (var m = o[litem+'Min']; m <= max[litem]; m += parseInt(o[litem+'Grid'], 10)) {
375
+ gridSize[litem]++;
376
+ html += '<td data-for="'+litem+'">' + ((m < 10) ? '0' : '') + m + '</td>';
377
+ }
378
+ }
379
+
380
+ html += '</tr></table></div>';
381
+ }
382
+ html += '</dd>';
383
+ }
384
+
385
+ // Timezone
386
+ html += '<dt class="ui_tpicker_timezone_label"' + ((o.showTimezone) ? '' : noDisplay) + '>' + o.timezoneText + '</dt>';
387
+ html += '<dd class="ui_tpicker_timezone" ' + ((o.showTimezone) ? '' : noDisplay) + '></dd>';
388
+
389
+ // Create the elements from string
390
+ html += '</dl></div>';
391
+ var $tp = $(html);
392
+
393
+ // if we only want time picker...
394
+ if (o.timeOnly === true) {
395
+ $tp.prepend('<div class="ui-widget-header ui-helper-clearfix ui-corner-all">' + '<div class="ui-datepicker-title">' + o.timeOnlyTitle + '</div>' + '</div>');
396
+ $dp.find('.ui-datepicker-header, .ui-datepicker-calendar').hide();
397
+ }
398
+
399
+ // add sliders, adjust grids, add events
400
+ for(var i=0,l=tp_inst.units.length; i<l; i++){
401
+ litem = tp_inst.units[i];
402
+ uitem = litem.substr(0,1).toUpperCase() + litem.substr(1);
403
+
404
+ // add the slider
405
+ tp_inst[litem+'_slider'] = tp_inst.control.create(tp_inst, $tp.find('.ui_tpicker_'+litem+'_slider'), litem, tp_inst[litem], o[litem+'Min'], max[litem], o['step'+uitem]);
406
+
407
+ // adjust the grid and add click event
408
+ if (o['show'+uitem] && o[litem+'Grid'] > 0) {
409
+ size = 100 * gridSize[litem] * o[litem+'Grid'] / (max[litem] - o[litem+'Min']);
410
+ $tp.find('.ui_tpicker_'+litem+' table').css({
411
+ width: size + "%",
412
+ marginLeft: o.isRTL? '0' : ((size / (-2 * gridSize[litem])) + "%"),
413
+ marginRight: o.isRTL? ((size / (-2 * gridSize[litem])) + "%") : '0',
414
+ borderCollapse: 'collapse'
415
+ }).find("td").click(function(e){
416
+ var $t = $(this),
417
+ h = $t.html(),
418
+ n = parseInt(h.replace(/[^0-9]/g),10),
419
+ ap = h.replace(/[^apm]/ig),
420
+ f = $t.data('for'); // loses scope, so we use data-for
421
+
422
+ if(f == 'hour'){
423
+ if(ap.indexOf('p') !== -1 && n < 12){
424
+ n += 12;
425
+ }
426
+ else{
427
+ if(ap.indexOf('a') !== -1 && n === 12){
428
+ n = 0;
429
+ }
430
+ }
431
+ }
432
+
433
+ tp_inst.control.value(tp_inst, tp_inst[f+'_slider'], litem, n);
434
+
435
+ tp_inst._onTimeChange();
436
+ tp_inst._onSelectHandler();
437
+ })
438
+ .css({
439
+ cursor: 'pointer',
440
+ width: (100 / gridSize[litem]) + '%',
441
+ textAlign: 'center',
442
+ overflow: 'hidden'
443
+ });
444
+ } // end if grid > 0
445
+ } // end for loop
446
+
447
+ // Add timezone options
448
+ this.timezone_select = $tp.find('.ui_tpicker_timezone').append('<select></select>').find("select");
449
+ $.fn.append.apply(this.timezone_select,
450
+ $.map(o.timezoneList, function(val, idx) {
451
+ return $("<option />").val(typeof val == "object" ? val.value : val).text(typeof val == "object" ? val.label : val);
452
+ }));
453
+ if (typeof(this.timezone) != "undefined" && this.timezone !== null && this.timezone !== "") {
454
+ var local_date = new Date(this.inst.selectedYear, this.inst.selectedMonth, this.inst.selectedDay, 12);
455
+ var local_timezone = $.timepicker.timeZoneOffsetString(local_date);
456
+ if (local_timezone == this.timezone) {
457
+ selectLocalTimeZone(tp_inst);
458
+ } else {
459
+ this.timezone_select.val(this.timezone);
460
+ }
461
+ } else {
462
+ if (typeof(this.hour) != "undefined" && this.hour !== null && this.hour !== "") {
463
+ this.timezone_select.val(o.defaultTimezone);
464
+ } else {
465
+ selectLocalTimeZone(tp_inst);
466
+ }
467
+ }
468
+ this.timezone_select.change(function() {
469
+ tp_inst._defaults.useLocalTimezone = false;
470
+ tp_inst._onTimeChange();
471
+ tp_inst._onSelectHandler();
472
+ });
473
+ // End timezone options
474
+
475
+ // inject timepicker into datepicker
476
+ var $buttonPanel = $dp.find('.ui-datepicker-buttonpane');
477
+ if ($buttonPanel.length) {
478
+ $buttonPanel.before($tp);
479
+ } else {
480
+ $dp.append($tp);
481
+ }
482
+
483
+ this.$timeObj = $tp.find('.ui_tpicker_time');
484
+
485
+ if (this.inst !== null) {
486
+ var timeDefined = this.timeDefined;
487
+ this._onTimeChange();
488
+ this.timeDefined = timeDefined;
489
+ }
490
+
491
+ // slideAccess integration: http://trentrichardson.com/2011/11/11/jquery-ui-sliders-and-touch-accessibility/
492
+ if (this._defaults.addSliderAccess) {
493
+ var sliderAccessArgs = this._defaults.sliderAccessArgs,
494
+ rtl = this._defaults.isRTL;
495
+ sliderAccessArgs.isRTL = rtl;
496
+
497
+ setTimeout(function() { // fix for inline mode
498
+ if ($tp.find('.ui-slider-access').length === 0) {
499
+ $tp.find('.ui-slider:visible').sliderAccess(sliderAccessArgs);
500
+
501
+ // fix any grids since sliders are shorter
502
+ var sliderAccessWidth = $tp.find('.ui-slider-access:eq(0)').outerWidth(true);
503
+ if (sliderAccessWidth) {
504
+ $tp.find('table:visible').each(function() {
505
+ var $g = $(this),
506
+ oldWidth = $g.outerWidth(),
507
+ oldMarginLeft = $g.css(rtl? 'marginRight':'marginLeft').toString().replace('%', ''),
508
+ newWidth = oldWidth - sliderAccessWidth,
509
+ newMarginLeft = ((oldMarginLeft * newWidth) / oldWidth) + '%',
510
+ css = { width: newWidth, marginRight: 0, marginLeft: 0 };
511
+ css[rtl? 'marginRight':'marginLeft'] = newMarginLeft;
512
+ $g.css(css);
513
+ });
514
+ }
515
+ }
516
+ }, 10);
517
+ }
518
+ // end slideAccess integration
519
+
520
+ }
521
+ },
522
+
523
+ /*
524
+ * This function tries to limit the ability to go outside the
525
+ * min/max date range
526
+ */
527
+ _limitMinMaxDateTime: function(dp_inst, adjustSliders) {
528
+ var o = this._defaults,
529
+ dp_date = new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay);
530
+
531
+ if (!this._defaults.showTimepicker) {
532
+ return;
533
+ } // No time so nothing to check here
534
+
535
+ if ($.datepicker._get(dp_inst, 'minDateTime') !== null && $.datepicker._get(dp_inst, 'minDateTime') !== undefined && dp_date) {
536
+ var minDateTime = $.datepicker._get(dp_inst, 'minDateTime'),
537
+ minDateTimeDate = new Date(minDateTime.getFullYear(), minDateTime.getMonth(), minDateTime.getDate(), 0, 0, 0, 0);
538
+
539
+ if (this.hourMinOriginal === null || this.minuteMinOriginal === null || this.secondMinOriginal === null || this.millisecMinOriginal === null) {
540
+ this.hourMinOriginal = o.hourMin;
541
+ this.minuteMinOriginal = o.minuteMin;
542
+ this.secondMinOriginal = o.secondMin;
543
+ this.millisecMinOriginal = o.millisecMin;
544
+ }
545
+
546
+ if (dp_inst.settings.timeOnly || minDateTimeDate.getTime() == dp_date.getTime()) {
547
+ this._defaults.hourMin = minDateTime.getHours();
548
+ if (this.hour <= this._defaults.hourMin) {
549
+ this.hour = this._defaults.hourMin;
550
+ this._defaults.minuteMin = minDateTime.getMinutes();
551
+ if (this.minute <= this._defaults.minuteMin) {
552
+ this.minute = this._defaults.minuteMin;
553
+ this._defaults.secondMin = minDateTime.getSeconds();
554
+ if (this.second <= this._defaults.secondMin) {
555
+ this.second = this._defaults.secondMin;
556
+ this._defaults.millisecMin = minDateTime.getMilliseconds();
557
+ } else {
558
+ if (this.millisec < this._defaults.millisecMin) {
559
+ this.millisec = this._defaults.millisecMin;
560
+ }
561
+ this._defaults.millisecMin = this.millisecMinOriginal;
562
+ }
563
+ } else {
564
+ this._defaults.secondMin = this.secondMinOriginal;
565
+ this._defaults.millisecMin = this.millisecMinOriginal;
566
+ }
567
+ } else {
568
+ this._defaults.minuteMin = this.minuteMinOriginal;
569
+ this._defaults.secondMin = this.secondMinOriginal;
570
+ this._defaults.millisecMin = this.millisecMinOriginal;
571
+ }
572
+ } else {
573
+ this._defaults.hourMin = this.hourMinOriginal;
574
+ this._defaults.minuteMin = this.minuteMinOriginal;
575
+ this._defaults.secondMin = this.secondMinOriginal;
576
+ this._defaults.millisecMin = this.millisecMinOriginal;
577
+ }
578
+ }
579
+
580
+ if ($.datepicker._get(dp_inst, 'maxDateTime') !== null && $.datepicker._get(dp_inst, 'maxDateTime') !== undefined && dp_date) {
581
+ var maxDateTime = $.datepicker._get(dp_inst, 'maxDateTime'),
582
+ maxDateTimeDate = new Date(maxDateTime.getFullYear(), maxDateTime.getMonth(), maxDateTime.getDate(), 0, 0, 0, 0);
583
+
584
+ if (this.hourMaxOriginal === null || this.minuteMaxOriginal === null || this.secondMaxOriginal === null) {
585
+ this.hourMaxOriginal = o.hourMax;
586
+ this.minuteMaxOriginal = o.minuteMax;
587
+ this.secondMaxOriginal = o.secondMax;
588
+ this.millisecMaxOriginal = o.millisecMax;
589
+ }
590
+
591
+ if (dp_inst.settings.timeOnly || maxDateTimeDate.getTime() == dp_date.getTime()) {
592
+ this._defaults.hourMax = maxDateTime.getHours();
593
+ if (this.hour >= this._defaults.hourMax) {
594
+ this.hour = this._defaults.hourMax;
595
+ this._defaults.minuteMax = maxDateTime.getMinutes();
596
+ if (this.minute >= this._defaults.minuteMax) {
597
+ this.minute = this._defaults.minuteMax;
598
+ this._defaults.secondMax = maxDateTime.getSeconds();
599
+ if (this.second >= this._defaults.secondMax) {
600
+ this.second = this._defaults.secondMax;
601
+ this._defaults.millisecMax = maxDateTime.getMilliseconds();
602
+ } else {
603
+ if (this.millisec > this._defaults.millisecMax) {
604
+ this.millisec = this._defaults.millisecMax;
605
+ }
606
+ this._defaults.millisecMax = this.millisecMaxOriginal;
607
+ }
608
+ } else {
609
+ this._defaults.secondMax = this.secondMaxOriginal;
610
+ this._defaults.millisecMax = this.millisecMaxOriginal;
611
+ }
612
+ } else {
613
+ this._defaults.minuteMax = this.minuteMaxOriginal;
614
+ this._defaults.secondMax = this.secondMaxOriginal;
615
+ this._defaults.millisecMax = this.millisecMaxOriginal;
616
+ }
617
+ } else {
618
+ this._defaults.hourMax = this.hourMaxOriginal;
619
+ this._defaults.minuteMax = this.minuteMaxOriginal;
620
+ this._defaults.secondMax = this.secondMaxOriginal;
621
+ this._defaults.millisecMax = this.millisecMaxOriginal;
622
+ }
623
+ }
624
+
625
+ if (adjustSliders !== undefined && adjustSliders === true) {
626
+ var hourMax = parseInt((this._defaults.hourMax - ((this._defaults.hourMax - this._defaults.hourMin) % this._defaults.stepHour)), 10),
627
+ minMax = parseInt((this._defaults.minuteMax - ((this._defaults.minuteMax - this._defaults.minuteMin) % this._defaults.stepMinute)), 10),
628
+ secMax = parseInt((this._defaults.secondMax - ((this._defaults.secondMax - this._defaults.secondMin) % this._defaults.stepSecond)), 10),
629
+ millisecMax = parseInt((this._defaults.millisecMax - ((this._defaults.millisecMax - this._defaults.millisecMin) % this._defaults.stepMillisec)), 10);
630
+
631
+ if (this.hour_slider) {
632
+ this.control.options(this, this.hour_slider, 'hour', { min: this._defaults.hourMin, max: hourMax });
633
+ this.control.value(this, this.hour_slider, 'hour', this.hour - (this.hour % this._defaults.stepHour));
634
+ }
635
+ if (this.minute_slider) {
636
+ this.control.options(this, this.minute_slider, 'minute', { min: this._defaults.minuteMin, max: minMax });
637
+ this.control.value(this, this.minute_slider, 'minute', this.minute - (this.minute % this._defaults.stepMinute));
638
+ }
639
+ if (this.second_slider) {
640
+ this.control.options(this, this.second_slider, 'second', { min: this._defaults.secondMin, max: secMax });
641
+ this.control.value(this, this.second_slider, 'second', this.second - (this.second % this._defaults.stepSecond));
642
+ }
643
+ if (this.millisec_slider) {
644
+ this.control.options(this, this.millisec_slider, 'millisec', { min: this._defaults.millisecMin, max: millisecMax });
645
+ this.control.value(this, this.millisec_slider, 'millisec', this.millisec - (this.millisec % this._defaults.stepMillisec));
646
+ }
647
+ }
648
+
649
+ },
650
+
651
+ /*
652
+ * when a slider moves, set the internal time...
653
+ * on time change is also called when the time is updated in the text field
654
+ */
655
+ _onTimeChange: function() {
656
+ var hour = (this.hour_slider) ? this.control.value(this, this.hour_slider, 'hour') : false,
657
+ minute = (this.minute_slider) ? this.control.value(this, this.minute_slider, 'minute') : false,
658
+ second = (this.second_slider) ? this.control.value(this, this.second_slider, 'second') : false,
659
+ millisec = (this.millisec_slider) ? this.control.value(this, this.millisec_slider, 'millisec') : false,
660
+ timezone = (this.timezone_select) ? this.timezone_select.val() : false,
661
+ o = this._defaults,
662
+ pickerTimeFormat = o.pickerTimeFormat || o.timeFormat,
663
+ pickerTimeSuffix = o.pickerTimeSuffix || o.timeSuffix;
664
+
665
+ if (typeof(hour) == 'object') {
666
+ hour = false;
667
+ }
668
+ if (typeof(minute) == 'object') {
669
+ minute = false;
670
+ }
671
+ if (typeof(second) == 'object') {
672
+ second = false;
673
+ }
674
+ if (typeof(millisec) == 'object') {
675
+ millisec = false;
676
+ }
677
+ if (typeof(timezone) == 'object') {
678
+ timezone = false;
679
+ }
680
+
681
+ if (hour !== false) {
682
+ hour = parseInt(hour, 10);
683
+ }
684
+ if (minute !== false) {
685
+ minute = parseInt(minute, 10);
686
+ }
687
+ if (second !== false) {
688
+ second = parseInt(second, 10);
689
+ }
690
+ if (millisec !== false) {
691
+ millisec = parseInt(millisec, 10);
692
+ }
693
+
694
+ var ampm = o[hour < 12 ? 'amNames' : 'pmNames'][0];
695
+
696
+ // If the update was done in the input field, the input field should not be updated.
697
+ // If the update was done using the sliders, update the input field.
698
+ var hasChanged = (hour != this.hour || minute != this.minute || second != this.second || millisec != this.millisec
699
+ || (this.ampm.length > 0 && (hour < 12) != ($.inArray(this.ampm.toUpperCase(), this.amNames) !== -1))
700
+ || ((this.timezone === null && timezone != this.defaultTimezone) || (this.timezone !== null && timezone != this.timezone)));
701
+
702
+ if (hasChanged) {
703
+
704
+ if (hour !== false) {
705
+ this.hour = hour;
706
+ }
707
+ if (minute !== false) {
708
+ this.minute = minute;
709
+ }
710
+ if (second !== false) {
711
+ this.second = second;
712
+ }
713
+ if (millisec !== false) {
714
+ this.millisec = millisec;
715
+ }
716
+ if (timezone !== false) {
717
+ this.timezone = timezone;
718
+ }
719
+
720
+ if (!this.inst) {
721
+ this.inst = $.datepicker._getInst(this.$input[0]);
722
+ }
723
+
724
+ this._limitMinMaxDateTime(this.inst, true);
725
+ }
726
+ if (useAmpm(o.timeFormat)) {
727
+ this.ampm = ampm;
728
+ }
729
+
730
+ // Updates the time within the timepicker
731
+ this.formattedTime = $.datepicker.formatTime(o.timeFormat, this, o);
732
+ if (this.$timeObj) {
733
+ if(pickerTimeFormat === o.timeFormat){
734
+ this.$timeObj.text(this.formattedTime + pickerTimeSuffix);
735
+ }
736
+ else{
737
+ this.$timeObj.text($.datepicker.formatTime(pickerTimeFormat, this, o) + pickerTimeSuffix);
738
+ }
739
+ }
740
+
741
+ this.timeDefined = true;
742
+ if (hasChanged) {
743
+ this._updateDateTime();
744
+ }
745
+ },
746
+
747
+ /*
748
+ * call custom onSelect.
749
+ * bind to sliders slidestop, and grid click.
750
+ */
751
+ _onSelectHandler: function() {
752
+ var onSelect = this._defaults.onSelect || this.inst.settings.onSelect;
753
+ var inputEl = this.$input ? this.$input[0] : null;
754
+ if (onSelect && inputEl) {
755
+ onSelect.apply(inputEl, [this.formattedDateTime, this]);
756
+ }
757
+ },
758
+
759
+ /*
760
+ * update our input with the new date time..
761
+ */
762
+ _updateDateTime: function(dp_inst) {
763
+ dp_inst = this.inst || dp_inst;
764
+ var dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
765
+ dateFmt = $.datepicker._get(dp_inst, 'dateFormat'),
766
+ formatCfg = $.datepicker._getFormatConfig(dp_inst),
767
+ timeAvailable = dt !== null && this.timeDefined;
768
+ this.formattedDate = $.datepicker.formatDate(dateFmt, (dt === null ? new Date() : dt), formatCfg);
769
+ var formattedDateTime = this.formattedDate;
770
+
771
+ // if a slider was changed but datepicker doesn't have a value yet, set it
772
+ if(dp_inst.lastVal==""){
773
+ dp_inst.currentYear=dp_inst.selectedYear;
774
+ dp_inst.currentMonth=dp_inst.selectedMonth;
775
+ dp_inst.currentDay=dp_inst.selectedDay;
776
+ }
777
+
778
+ /*
779
+ * remove following lines to force every changes in date picker to change the input value
780
+ * Bug descriptions: when an input field has a default value, and click on the field to pop up the date picker.
781
+ * If the user manually empty the value in the input field, the date picker will never change selected value.
782
+ */
783
+ //if (dp_inst.lastVal !== undefined && (dp_inst.lastVal.length > 0 && this.$input.val().length === 0)) {
784
+ // return;
785
+ //}
786
+
787
+ if (this._defaults.timeOnly === true) {
788
+ formattedDateTime = this.formattedTime;
789
+ } else if (this._defaults.timeOnly !== true && (this._defaults.alwaysSetTime || timeAvailable)) {
790
+ formattedDateTime += this._defaults.separator + this.formattedTime + this._defaults.timeSuffix;
791
+ }
792
+
793
+ this.formattedDateTime = formattedDateTime;
794
+
795
+ if (!this._defaults.showTimepicker) {
796
+ this.$input.val(this.formattedDate);
797
+ } else if (this.$altInput && this._defaults.altFieldTimeOnly === true) {
798
+ this.$altInput.val(this.formattedTime);
799
+ this.$input.val(this.formattedDate);
800
+ } else if (this.$altInput) {
801
+ this.$input.val(formattedDateTime);
802
+ var altFormattedDateTime = '',
803
+ altSeparator = this._defaults.altSeparator ? this._defaults.altSeparator : this._defaults.separator,
804
+ altTimeSuffix = this._defaults.altTimeSuffix ? this._defaults.altTimeSuffix : this._defaults.timeSuffix;
805
+
806
+ if (this._defaults.altFormat) altFormattedDateTime = $.datepicker.formatDate(this._defaults.altFormat, (dt === null ? new Date() : dt), formatCfg);
807
+ else altFormattedDateTime = this.formattedDate;
808
+ if (altFormattedDateTime) altFormattedDateTime += altSeparator;
809
+ if (this._defaults.altTimeFormat) altFormattedDateTime += $.datepicker.formatTime(this._defaults.altTimeFormat, this, this._defaults) + altTimeSuffix;
810
+ else altFormattedDateTime += this.formattedTime + altTimeSuffix;
811
+ this.$altInput.val(altFormattedDateTime);
812
+ } else {
813
+ this.$input.val(formattedDateTime);
814
+ }
815
+
816
+ this.$input.trigger("change");
817
+ },
818
+
819
+ _onFocus: function() {
820
+ if (!this.$input.val() && this._defaults.defaultValue) {