Commit | Line | Data |
---|---|---|
3d80d622 CW |
1 | /** |
2 | +--------------------------------------------------------------------+ | |
81621fee | 3 | | CiviCRM version 4.7 | |
3d80d622 | 4 | +--------------------------------------------------------------------+ |
e7112fa7 | 5 | | Copyright CiviCRM LLC (c) 2004-2015 | |
3d80d622 CW |
6 | +--------------------------------------------------------------------+ |
7 | | This file is a part of CiviCRM. | | |
8 | | | | |
9 | | CiviCRM is free software; you can copy, modify, and distribute it | | |
10 | | under the terms of the GNU Affero General Public License | | |
11 | | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. | | |
12 | | | | |
13 | | CiviCRM is distributed in the hope that it will be useful, but | | |
14 | | WITHOUT ANY WARRANTY; without even the implied warranty of | | |
15 | | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | | |
16 | | See the GNU Affero General Public License for more details. | | |
17 | | | | |
18 | | You should have received a copy of the GNU Affero General Public | | |
19 | | License and the CiviCRM Licensing Exception along | | |
20 | | with this program; if not, contact CiviCRM LLC | | |
21 | | at info[AT]civicrm[DOT]org. If you have questions about the | | |
22 | | GNU Affero General Public License or the licensing of CiviCRM, | | |
23 | | see the CiviCRM license FAQ at http://civicrm.org/licensing | | |
24 | +--------------------------------------------------------------------+ | |
25 | * | |
26 | * Copyright (C) 2009 Bevan Rudge | |
27 | * Licensed to CiviCRM under the Academic Free License version 3.0. | |
28 | * | |
29 | * @file Defines the jQuery.dashboard() plugin. | |
30 | * | |
31 | * Uses jQuery 1.3, jQuery UI 1.6 and several jQuery UI extensions, most of all Sortable | |
32 | * http://visualjquery.com/ | |
33 | * http://docs.jquery.com/UI/Sortable | |
34 | * http://ui.jquery.com/download | |
35 | * Sortable | |
36 | * Draggable | |
37 | * UI Core | |
38 | * | |
980f3b14 TO |
39 | * NOTE: This file is viewed as "legacy" and shouldn't be used to |
40 | * develop new functionality. Its lint problems are grandfathered | |
41 | * (although if someone wants to cleanup+test, please feel welcome). | |
3d80d622 | 42 | */ |
980f3b14 | 43 | /* jshint ignore:start */ |
3d80d622 CW |
44 | (function($) { // Create closure. |
45 | // Constructor for dashboard object. | |
46 | $.fn.dashboard = function(options) { | |
47 | // Public properties of dashboard. | |
48 | var dashboard = {}; | |
49 | dashboard.element = this.empty(); | |
50 | dashboard.ready = false; | |
51 | dashboard.columns = Array(); | |
52 | dashboard.widgets = Array(); | |
53 | // End of public properties of dashboard. | |
54 | ||
55 | /** | |
56 | * Public methods of dashboard. | |
57 | */ | |
58 | ||
59 | // Saves the order of widgets for all columns including the widget.minimized status to options.ajaxCallbacks.saveColumns. | |
60 | dashboard.saveColumns = function() { | |
61 | // Update the display status of the empty placeholders. | |
62 | for (var c in dashboard.columns) { | |
63 | var col = dashboard.columns[c]; | |
64 | if ( typeof col == 'object' ) { | |
65 | // Are there any visible children of the column (excluding the empty placeholder)? | |
66 | if (col.element.children(':visible').not(col.emptyPlaceholder).length > 0) { | |
67 | col.emptyPlaceholder.hide(); | |
68 | } | |
69 | else { | |
70 | col.emptyPlaceholder.show(); | |
71 | } | |
72 | } | |
73 | } | |
74 | ||
75 | // Don't save any changes to the server unless the dashboard has finished initiating. | |
76 | if (!dashboard.ready) { | |
77 | return; | |
78 | } | |
79 | ||
80 | // Build a list of params to post to the server. | |
81 | var params = {}; | |
82 | ||
83 | // For each column... | |
ce7f4953 | 84 | for (var c2 in dashboard.columns) { |
3d80d622 CW |
85 | |
86 | // IDs of the sortable elements in this column. | |
f3ac8e2f | 87 | var ids = (typeof dashboard.columns[c2] == 'object') ? dashboard.columns[c2].element.sortable('toArray') : undefined; |
3d80d622 CW |
88 | |
89 | // For each id... | |
90 | for (var w in ids) { | |
91 | // Chop 'widget-' off of the front so that we have the real widget id. | |
f3ac8e2f | 92 | var id = (typeof ids[w] == 'string') ? ids[w].substring('widget-'.length) : undefined; |
3d80d622 CW |
93 | |
94 | // Add one flat property to the params object that will look like an array element to the PHP server. | |
95 | // Unfortunately jQuery doesn't do this for us. | |
ce7f4953 | 96 | if ( typeof dashboard.widgets[id] == 'object' ) params['columns[' + c2 + '][' + id + ']'] = (dashboard.widgets[id].minimized ? '1' : '0'); |
3d80d622 CW |
97 | } |
98 | } | |
99 | ||
100 | // The ajaxCallback settings overwrite any duplicate properties. | |
101 | $.extend(params, opts.ajaxCallbacks.saveColumns.data); | |
102 | $.post(opts.ajaxCallbacks.saveColumns.url, params, function(response, status) { | |
103 | invokeCallback(opts.callbacks.saveColumns, dashboard); | |
104 | }); | |
105 | }; | |
106 | ||
107 | // Puts the dashboard into full screen mode, saving element for when the user exits full-screen mode. | |
108 | // Does not add element to the DOM – this is the caller's responsibility. | |
109 | // Does show and hide element though. | |
110 | dashboard.enterFullscreen = function(element) { | |
111 | // Hide the columns. | |
112 | for (var c in dashboard.columns) { | |
113 | if ( typeof dashboard.columns[c] == 'object' ) dashboard.columns[c].element.hide(); | |
114 | } | |
115 | ||
116 | if (!dashboard.fullscreen) { | |
117 | // Initialize. | |
118 | var markup = '<a id="full-screen-header" class="full-screen-close-icon">' + opts.fullscreenHeaderInner + '</a>'; | |
119 | dashboard.fullscreen = { | |
120 | headerElement: $(markup).prependTo(dashboard.element).click(dashboard.exitFullscreen).hide() | |
121 | }; | |
122 | } | |
123 | ||
124 | dashboard.fullscreen.headerElement.slideDown(); | |
125 | dashboard.fullscreen.currentElement = element.show(); | |
126 | dashboard.fullscreen.displayed = true; | |
127 | invokeCallback(opts.callbacks.enterFullscreen, dashboard, dashboard.fullscreen.currentElement); | |
128 | }; | |
129 | ||
130 | // Takes the dashboard out of full screen mode, hiding the active fullscreen element. | |
131 | dashboard.exitFullscreen = function() { | |
132 | if (!dashboard.fullscreen.displayed) { | |
133 | return; | |
134 | } | |
135 | ||
136 | dashboard.fullscreen.headerElement.slideUp(); | |
137 | dashboard.fullscreen.currentElement.hide(); | |
138 | dashboard.fullscreen.displayed = false; | |
139 | ||
140 | // Show the columns. | |
141 | for (var c in dashboard.columns) { | |
142 | if ( typeof dashboard.columns[c] == 'object' ) dashboard.columns[c].element.show(); | |
143 | } | |
144 | ||
145 | invokeCallback(opts.callbacks.exitFullscreen, dashboard, dashboard.fullscreen.currentElement); | |
146 | }; | |
147 | // End of public methods of dashboard. | |
148 | ||
149 | /** | |
150 | * Private properties of dashboard. | |
151 | */ | |
31037a42 | 152 | |
3d80d622 CW |
153 | // Used to determine whether there are any incomplete ajax requests pending initialization of the dashboard. |
154 | var asynchronousRequestCounter = 0; | |
155 | ||
156 | // Used to determine whether two resort events are resulting from the same UI event. | |
157 | var currentReSortEvent = null; | |
158 | ||
159 | // Merge in the caller's options with the defaults. | |
160 | var opts = $.extend({}, $.fn.dashboard.defaults, options); | |
161 | ||
162 | // Execution 'forks' here and restarts in init(). Tell the user we're busy with a throbber. | |
163 | var throbber = $(opts.throbberMarkup).appendTo(dashboard.element); | |
164 | $.getJSON(opts.ajaxCallbacks.getWidgetsByColumn.url, opts.ajaxCallbacks.getWidgetsByColumn.data, init); | |
165 | asynchronousRequestCounter++; | |
166 | return dashboard; | |
167 | // End of constructor and private properties for dashboard object. | |
168 | ||
169 | /** | |
170 | * Private methods of dashboard. | |
171 | */ | |
172 | ||
173 | // Ajax callback for getWidgetsByColumn. | |
174 | function init(widgets, status) { | |
175 | asynchronousRequestCounter--; | |
176 | throbber.remove(); | |
177 | var markup = '<li class="empty-placeholder">' + opts.emptyPlaceholderInner + '</li>'; | |
178 | ||
179 | // Build the dashboard in the DOM. For each column... | |
180 | // (Don't iterate on widgets since this will break badly if the dataset has empty columns.) | |
181 | var emptyDashboard = true; | |
182 | for (var c = 0; c < opts.columns; c++) { | |
183 | // Save the column to both the public scope for external accessibility and the local scope for readability. | |
184 | var col = dashboard.columns[c] = { | |
185 | initialWidgets: Array(), | |
186 | element: $('<ul id="column-' + c + '" class="column column-' + c + '"></ul>').appendTo(dashboard.element) | |
187 | }; | |
31037a42 | 188 | |
3d80d622 CW |
189 | // Add the empty placeholder now, hide it and save it. |
190 | col.emptyPlaceholder = $(markup).appendTo(col.element).hide(); | |
191 | ||
192 | // For each widget in this column. | |
193 | for (var id in widgets[c]) { | |
194 | var widgetID = id.split('-'); | |
195 | // Build a new widget object and save it to various publicly accessible places. | |
196 | col.initialWidgets[id] = dashboard.widgets[widgetID[1]] = widget({ | |
197 | id: widgetID[1], | |
198 | element: $('<li class="widget"></li>').appendTo(col.element), | |
199 | initialColumn: col, | |
200 | minimized: ( widgets[c][widgetID[1]] > 0 ? true : false ) | |
201 | }); | |
31037a42 | 202 | |
3d80d622 CW |
203 | //set empty Dashboard to false |
204 | emptyDashboard = false; | |
205 | } | |
206 | } | |
207 | ||
208 | if ( emptyDashboard ) { | |
209 | emptyDashboardCondition( ); | |
210 | } | |
31037a42 | 211 | |
3d80d622 CW |
212 | invokeCallback(opts.callbacks.init, dashboard); |
213 | } | |
214 | ||
215 | // function that is called when dashboard is empty | |
216 | function emptyDashboardCondition( ) { | |
217 | cj(".show-refresh").hide( ); | |
218 | cj("#empty-message").show( ); | |
219 | } | |
31037a42 | 220 | |
3d80d622 CW |
221 | // Contructors for each widget call this when initialization has finished so that dashboard can complete it's intitialization. |
222 | function completeInit() { | |
223 | // Don't do anything if any widgets are waiting for ajax requests to complete in order to finish initialization. | |
224 | if (asynchronousRequestCounter > 0) { | |
225 | return; | |
226 | } | |
227 | ||
228 | // Make widgets sortable across columns. | |
229 | dashboard.sortableElement = $('.column').sortable({ | |
230 | connectWith: ['.column'], | |
231 | ||
232 | // The class of the element by which widgets are draggable. | |
233 | handle: '.widget-header', | |
234 | ||
235 | // The class of placeholder elements (the 'ghost' widget showing where the dragged item would land if released now.) | |
31037a42 EM |
236 | placeholder: 'placeholder', |
237 | activate: function(event, ui) { | |
238 | var h= cj(ui.item).height(); | |
3d80d622 | 239 | $('.placeholder').css('height', h +'px'); }, |
31037a42 | 240 | |
3d80d622 CW |
241 | opacity: 0.2, |
242 | ||
243 | // Maks sure that only widgets are sortable, and not empty placeholders. | |
244 | items: '> .widget', | |
31037a42 | 245 | |
3d80d622 | 246 | forcePlaceholderSize: true, |
31037a42 | 247 | |
3d80d622 CW |
248 | // Callback functions. |
249 | update: resorted, | |
250 | start: hideEmptyPlaceholders | |
251 | }); | |
252 | ||
253 | // Update empty placeholders. | |
254 | dashboard.saveColumns(); | |
255 | dashboard.ready = true; | |
256 | invokeCallback(opts.callbacks.ready, dashboard); | |
257 | } | |
258 | ||
259 | // Callback for when any list has changed (and the user has finished resorting). | |
260 | function resorted(e, ui) { | |
261 | // Only do anything if we haven't already handled resorts based on changes from this UI DOM event. | |
262 | // (resorted() gets invoked once for each list when an item is moved from one to another.) | |
263 | if (!currentReSortEvent || e.originalEvent != currentReSortEvent) { | |
264 | currentReSortEvent = e.originalEvent; | |
265 | dashboard.saveColumns(); | |
266 | } | |
267 | } | |
268 | ||
269 | // Callback for when a user starts resorting a list. Hides all the empty placeholders. | |
270 | function hideEmptyPlaceholders(e, ui) { | |
271 | for (var c in dashboard.columns) { | |
9e483b7f | 272 | if( (typeof dashboard.columns[c]) == 'object' ) dashboard.columns[c].emptyPlaceholder.hide(); |
3d80d622 CW |
273 | } |
274 | } | |
275 | ||
276 | // @todo use an event library to register, bind to and invoke events. | |
277 | // @param callback is a function. | |
278 | // @param theThis is the context given to that function when it executes. It becomes 'this' inside of that function. | |
279 | function invokeCallback(callback, theThis, parameterOne) { | |
280 | if (callback) { | |
281 | callback.call(theThis, parameterOne); | |
282 | } | |
283 | } | |
284 | ||
285 | /** | |
286 | * widget object | |
287 | * Private sub-class of dashboard | |
288 | * Constructor starts | |
289 | */ | |
290 | function widget(widget) { | |
291 | // Merge default options with the options defined for this widget. | |
292 | widget = $.extend({}, $.fn.dashboard.widget.defaults, widget); | |
293 | ||
294 | /** | |
295 | * Public methods of widget. | |
296 | */ | |
297 | ||
298 | // Toggles the minimize() & maximize() methods. | |
299 | widget.toggleMinimize = function() { | |
300 | if (widget.minimized) { | |
301 | widget.maximize(); | |
302 | } | |
303 | else { | |
304 | widget.minimize(); | |
305 | } | |
306 | ||
307 | widget.hideSettings(); | |
308 | dashboard.saveColumns(); | |
309 | }; | |
310 | widget.minimize = function() { | |
311 | $('.widget-content', widget.element).slideUp(opts.animationSpeed); | |
41ce1b88 AH |
312 | $(widget.controls.minimize.element).addClass( 'fa-caret-right' ); |
313 | $(widget.controls.minimize.element).removeClass( 'fa-caret-down' ); | |
3d80d622 CW |
314 | widget.minimized = true; |
315 | }; | |
316 | widget.maximize = function() { | |
317 | $('.widget-content', widget.element).slideDown(opts.animationSpeed); | |
41ce1b88 AH |
318 | $(widget.controls.minimize.element).removeClass( 'fa-caret-right' ); |
319 | $(widget.controls.minimize.element).addClass( 'fa-caret-down' ); | |
3d80d622 CW |
320 | widget.minimized = false; |
321 | }; | |
322 | ||
323 | // Toggles whether the widget is in settings-display mode or not. | |
324 | widget.toggleSettings = function() { | |
325 | if (widget.settings.displayed) { | |
326 | // Widgets always exit settings into maximized state. | |
327 | widget.maximize(); | |
328 | widget.hideSettings(); | |
329 | invokeCallback(opts.widgetCallbacks.hideSettings, widget); | |
330 | } | |
331 | else { | |
332 | widget.minimize(); | |
333 | widget.showSettings(); | |
334 | invokeCallback(opts.widgetCallbacks.showSettings, widget); | |
335 | } | |
336 | }; | |
337 | widget.showSettings = function() { | |
338 | if (widget.settings.element) { | |
339 | widget.settings.element.show(); | |
340 | ||
341 | // Settings are loaded via AJAX. Only execute the script if the settings have been loaded. | |
342 | if (widget.settings.ready) { | |
343 | getJavascript(widget.settings.script); | |
344 | } | |
345 | } | |
346 | else { | |
347 | // Settings have not been initialized. Do so now. | |
348 | initSettings(); | |
349 | } | |
350 | widget.settings.displayed = true; | |
351 | }; | |
352 | widget.hideSettings = function() { | |
353 | if (widget.settings.element) { | |
354 | widget.settings.element.hide(); | |
355 | } | |
356 | widget.settings.displayed = false; | |
357 | }; | |
358 | widget.saveSettings = function() { | |
359 | // Build list of parameters to POST to server. | |
360 | var params = {}; | |
361 | // serializeArray() returns an array of objects. Process it. | |
362 | var fields = widget.settings.element.serializeArray(); | |
363 | for (var i in fields) { | |
364 | var field = fields[i]; | |
365 | // Put the values into flat object properties that PHP will parse into an array server-side. | |
366 | // (Unfortunately jQuery doesn't do this) | |
367 | params['settings[' + field.name + ']'] = field.value; | |
368 | } | |
369 | ||
370 | // Things get messy here. | |
31037a42 EM |
371 | // @todo Refactor to use currentState and targetedState properties to determine what needs |
372 | // to be done to get to any desired state on any UI or AJAX event – since these don't always | |
373 | // match. | |
374 | // E.g. When a user starts a new UI event before the Ajax event handler from a previous | |
3d80d622 CW |
375 | // UI event gets invoked. |
376 | ||
377 | // Hide the settings first of all. | |
378 | widget.toggleSettings(); | |
379 | // Save the real settings element so that we can restore the reference later. | |
380 | var settingsElement = widget.settings.element; | |
381 | // Empty the settings form. | |
382 | widget.settings.innerElement.empty(); | |
383 | initThrobber(); | |
384 | // So that showSettings() and hideSettings() can do SOMETHING, without showing the empty settings form. | |
385 | widget.settings.element = widget.throbber.hide(); | |
386 | widget.settings.ready = false; | |
387 | ||
388 | // Save the settings to the server. | |
389 | $.extend(params, opts.ajaxCallbacks.widgetSettings.data, { id: widget.id }); | |
390 | $.post(opts.ajaxCallbacks.widgetSettings.url, params, function(response, status) { | |
391 | // Merge the response into widget.settings. | |
392 | $.extend(widget.settings, response); | |
393 | // Restore the reference to the real settings element. | |
394 | widget.settings.element = settingsElement; | |
395 | // Make sure the settings form is empty and add the updated settings form. | |
396 | widget.settings.innerElement.empty().append(widget.settings.markup); | |
397 | widget.settings.ready = true; | |
398 | ||
399 | // Did the user already jump back into settings-display mode before we could finish reloading the settings form? | |
400 | if (widget.settings.displayed) { | |
401 | // Ooops! We had better take care of hiding the throbber and showing the settings form then. | |
402 | widget.throbber.hide(); | |
403 | widget.showSettings(); | |
404 | invokeCallback(opts.widgetCallbacks.saveSettings, dashboard); | |
405 | } | |
406 | }, 'json'); | |
407 | ||
408 | // Don't let form submittal bubble up. | |
409 | return false; | |
410 | }; | |
411 | ||
412 | widget.enterFullscreen = function() { | |
413 | // Make sure the widget actually supports full screen mode. | |
414 | if (!widget.fullscreenUrl) { | |
415 | return; | |
416 | } | |
68f3f169 | 417 | CRM.loadPage(widget.fullscreenUrl); |
3d80d622 | 418 | }; |
31037a42 | 419 | |
3d80d622 CW |
420 | // Exit fullscreen mode. |
421 | widget.exitFullscreen = function() { | |
422 | // This is just a wrapper for dashboard.exitFullscreen() which does the heavy lifting. | |
423 | dashboard.exitFullscreen(); | |
424 | }; | |
425 | ||
426 | // Adds controls to a widget. id is for internal use and image file name in images/dashboard/ (a .gif). | |
427 | widget.addControl = function(id, control) { | |
41ce1b88 | 428 | var markup = '<a class="crm-i ' + control.icon + '" alt="' + control.description + '" title="' + control.description + '"></a>'; |
3d80d622 CW |
429 | control.element = $(markup).prependTo($('.widget-controls', widget.element)).click(control.callback); |
430 | }; | |
431 | ||
432 | // An external method used only by and from external scripts to reload content. Not invoked or used internally. | |
433 | // The widget must provide the script that executes this, as well as the script that invokes it. | |
434 | widget.reloadContent = function() { | |
435 | getJavascript(widget.reloadContentScript); | |
436 | invokeCallback(opts.widgetCallbacks.reloadContent, widget); | |
437 | }; | |
438 | ||
439 | // Removes the widget from the dashboard, and saves columns. | |
440 | widget.remove = function() { | |
31037a42 | 441 | if ( confirm( 'Are you sure you want to remove "' + widget.title + '"?') ) { |
3d80d622 CW |
442 | invokeCallback(opts.widgetCallbacks.remove, widget); |
443 | widget.element.fadeOut(opts.animationSpeed, function() { | |
444 | $(this).remove(); | |
445 | dashboard.saveColumns(); | |
446 | }); | |
447 | } | |
448 | }; | |
449 | // End public methods of widget. | |
450 | ||
451 | /** | |
452 | * Public properties of widget. | |
453 | */ | |
454 | ||
455 | // Default controls. External script can add more with widget.addControls() | |
456 | widget.controls = { | |
457 | settings: { | |
77a8d7f9 | 458 | description: ts('Configure this dashlet'), |
41ce1b88 AH |
459 | callback: widget.toggleSettings, |
460 | icon: 'fa-wrench' | |
3d80d622 CW |
461 | }, |
462 | minimize: { | |
77a8d7f9 | 463 | description: ts('Collapse or expand'), |
41ce1b88 AH |
464 | callback: widget.toggleMinimize, |
465 | icon: 'fa-caret-down', | |
3d80d622 CW |
466 | }, |
467 | fullscreen: { | |
77a8d7f9 | 468 | description: ts('View fullscreen'), |
41ce1b88 AH |
469 | callback: widget.enterFullscreen, |
470 | icon: 'fa-expand', | |
3d80d622 CW |
471 | }, |
472 | close: { | |
77a8d7f9 | 473 | description: ts('Remove from dashboard'), |
41ce1b88 AH |
474 | callback: widget.remove, |
475 | icon: 'fa-times' | |
3d80d622 CW |
476 | } |
477 | }; | |
478 | // End public properties of widget. | |
479 | ||
480 | /** | |
481 | * Private properties of widget. | |
482 | */ | |
483 | ||
484 | // We're gonna 'fork' execution again, so let's tell the user to hold with us till the AJAX callback gets invoked. | |
485 | var throbber = $(opts.throbberMarkup).appendTo(widget.element); | |
486 | var params = $.extend({}, opts.ajaxCallbacks.getWidget.data, {id: widget.id}); | |
487 | $.getJSON(opts.ajaxCallbacks.getWidget.url, params, init); | |
488 | ||
489 | // Help dashboard track whether we've got any outstanding requests on which initialization is pending. | |
490 | asynchronousRequestCounter++; | |
491 | return widget; | |
492 | // End of private properties of widget. | |
493 | ||
494 | /** | |
495 | * Private methods of widget. | |
496 | */ | |
497 | ||
498 | // Ajax callback for widget initialization. | |
499 | function init(data, status) { | |
500 | asynchronousRequestCounter--; | |
501 | $.extend(widget, data); | |
502 | ||
503 | // Delete controls that don't apply to this widget. | |
504 | if (!widget.settings) { | |
505 | delete widget.controls.settings; | |
506 | } | |
507 | if (!widget.fullscreenUrl) { | |
508 | delete widget.controls.fullscreen; | |
509 | } | |
510 | ||
511 | widget.element.attr('id', 'widget-' + widget.id).addClass(widget.classes); | |
512 | throbber.remove(); | |
513 | // Build and add the widget's DOM element. | |
514 | $(widget.element).append(widgetHTML()).trigger('crmLoad'); | |
515 | // Save the content element so that external scripts can reload it easily. | |
516 | widget.contentElement = $('.widget-content', widget.element); | |
517 | $.each(widget.controls, widget.addControl); | |
518 | ||
519 | // Switch the initial state so that it initializes to the correct state. | |
520 | widget.minimized = !widget.minimized; | |
521 | widget.toggleMinimize(); | |
522 | getJavascript(widget.initScript); | |
523 | invokeCallback(opts.widgetCallbacks.get, widget); | |
524 | ||
525 | // completeInit() is a private method of the dashboard. Let it complete initialization of the dashboard. | |
526 | completeInit(); | |
527 | } | |
528 | ||
529 | // Builds inner HTML for widgets. | |
530 | function widgetHTML() { | |
531 | var html = ''; | |
532 | html += '<div class="widget-wrapper">'; | |
533 | html += ' <div class="widget-controls"><h3 class="widget-header">' + widget.title + '</h3></div>'; | |
534 | html += ' <div class="widget-content crm-ajax-container">' + widget.content + '</div>'; | |
535 | html += '</div>'; | |
536 | return html; | |
537 | } | |
538 | ||
539 | // Initializes a widgets settings pane. | |
540 | function initSettings() { | |
541 | // Overwrite widget.settings (boolean). | |
542 | initThrobber(); | |
543 | widget.settings = { | |
544 | element: widget.throbber.show(), | |
545 | ready: false | |
546 | }; | |
547 | ||
548 | // Get the settings markup and script executables for this widget. | |
549 | var params = $.extend({}, opts.ajaxCallbacks.widgetSettings.data, { id: widget.id }); | |
550 | $.getJSON(opts.ajaxCallbacks.widgetSettings.url, params, function(response, status) { | |
551 | $.extend(widget.settings, response); | |
552 | // Build and add the settings form to the DOM. Bind the form's submit event handler/callback. | |
553 | widget.settings.element = $(widgetSettingsHTML()).appendTo($('.widget-wrapper', widget.element)).submit(widget.saveSettings); | |
554 | // Bind the cancel button's event handler too. | |
555 | widget.settings.cancelButton = $('.widget-settings-cancel', widget.settings.element).click(cancelEditSettings); | |
556 | // Build and add the inner form elements from the HTML markup provided in the AJAX data. | |
557 | widget.settings.innerElement = $('.widget-settings-inner', widget.settings.element).append(widget.settings.markup); | |
558 | widget.settings.ready = true; | |
559 | ||
560 | if (widget.settings.displayed) { | |
561 | // If the user hasn't clicked away from the settings pane, then display the form. | |
562 | widget.throbber.hide(); | |
563 | widget.showSettings(); | |
564 | } | |
565 | ||
566 | getJavascript(widget.settings.initScript); | |
567 | }); | |
568 | } | |
569 | ||
570 | // Builds HTML for widget settings forms. | |
571 | function widgetSettingsHTML() { | |
572 | var html = ''; | |
573 | html += '<form class="widget-settings">'; | |
574 | html += ' <div class="widget-settings-inner"></div>'; | |
575 | html += ' <div class="widget-settings-buttons">'; | |
576 | html += ' <input id="' + widget.id + '-settings-save" class="widget-settings-save" value="Save" type="submit" />'; | |
577 | html += ' <input id="' + widget.id + '-settings-cancel" class="widget-settings-cancel" value="Cancel" type="submit" />'; | |
578 | html += ' </div>'; | |
579 | html += '</form>'; | |
580 | return html; | |
581 | } | |
582 | ||
583 | // Initializes a generic widget content throbber, for use by settings form and external scripts. | |
584 | function initThrobber() { | |
585 | if (!widget.throbber) { | |
586 | widget.throbber = $(opts.throbberMarkup).appendTo($('.widget-wrapper', widget.element)); | |
587 | } | |
1a40fe56 | 588 | } |
3d80d622 CW |
589 | |
590 | // Event handler/callback for cancel button clicks. | |
591 | // @todo test this gets caught by all browsers when the cancel button is 'clicked' via the keyboard. | |
592 | function cancelEditSettings() { | |
593 | widget.toggleSettings(); | |
594 | return false; | |
1a40fe56 | 595 | } |
3d80d622 CW |
596 | |
597 | // Helper function to execute external script on the server. | |
598 | // @todo It would be nice to provide some context to the script. How? | |
599 | function getJavascript(url) { | |
600 | if (url) { | |
601 | $.getScript(url); | |
602 | } | |
603 | } | |
1a40fe56 | 604 | } |
3d80d622 CW |
605 | }; |
606 | ||
607 | // Public static properties of dashboard. Default settings. | |
608 | $.fn.dashboard.defaults = { | |
609 | columns: 2, | |
77a8d7f9 CW |
610 | emptyPlaceholderInner: ts('There are no dashlets in this column of your dashboard.'), |
611 | fullscreenHeaderInner: ts('Back to dashboard mode'), | |
612 | throbberMarkup: '<div class="crm-loading-element">' + ts('Loading') + '...</div>', | |
3d80d622 CW |
613 | animationSpeed: 200, |
614 | callbacks: {}, | |
615 | widgetCallbacks: {} | |
616 | }; | |
617 | ||
618 | // Default widget settings. | |
619 | $.fn.dashboard.widget = { | |
620 | defaults: { | |
621 | minimized: false, | |
622 | settings: false, | |
623 | fullscreen: false | |
624 | } | |
625 | }; | |
626 | })(jQuery); |