ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-04-26 05:49:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Code Style] Use prototypes in Dialog bundle

Browse Source 
WTD-1482.
This commit is contained in:
Victor Woeltjen 2015-08-10 12:53:55 -07:00
parent f8a0ddb484
commit efc42aa8f2
2 changed files with 157 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
platform/commonUI/dialog/src/DialogService.js
View File

@ -38,127 +38,126 @@ define(
* @constructor * @constructor
*/ */
function DialogService(overlayService, $q, $log) { function DialogService(overlayService, $q, $log) {
var overlay, this.overlayService = overlayService;
dialogVisible = false; this.$q = $q;
this.$log = $log;
// Stop showing whatever overlay is currently active this.overlay = undefined;
// (e.g. because the user hit cancel) this.dialogVisible = false;
function dismiss() {
if (overlay) {
overlay.dismiss();
}
dialogVisible = false;
}
function getDialogResponse(key, model, resultGetter) {
// We will return this result as a promise, because user
// input is asynchronous.
var deferred = $q.defer(),
overlayModel;
// Confirm function; this will be passed in to the
// overlay-dialog template and associated with a
// OK button click
function confirm(value) {
// Pass along the result
deferred.resolve(resultGetter ? resultGetter() : value);
// Stop showing the dialog
dismiss();
}
// Cancel function; this will be passed in to the
// overlay-dialog template and associated with a
// Cancel or X button click
function cancel() {
deferred.reject();
dismiss();
}
// Add confirm/cancel callbacks
model.confirm = confirm;
model.cancel = cancel;
if (dialogVisible) {
// Only one dialog should be shown at a time.
// The application design should be such that
// we never even try to do this.
$log.warn([
"Dialog already showing; ",
"unable to show ",
model.name
].join(""));
deferred.reject();
} else {
// Add the overlay using the OverlayService, which
// will handle actual insertion into the DOM
overlay = overlayService.createOverlay(
key,
model
);
// Track that a dialog is already visible, to
// avoid spawning multiple dialogs at once.
dialogVisible = true;
}
return deferred.promise;
}
function getUserInput(formModel, value) {
var overlayModel = {
title: formModel.name,
message: formModel.message,
structure: formModel,
value: value
};
// Provide result from the model
function resultGetter() {
return overlayModel.value;
}
// Show the overlay-dialog
return getDialogResponse(
"overlay-dialog",
overlayModel,
resultGetter
);
}
function getUserChoice(dialogModel) {
// Show the overlay-options dialog
return getDialogResponse(
"overlay-options",
{ dialog: dialogModel }
);
}
return {
/**
* Request user input via a window-modal dialog.
*
* @param {FormModel} formModel a description of the form
* to be shown (see platform/forms)
* @param {object} value the initial state of the form
* @returns {Promise} a promsie for the form value that the
* user has supplied; this may be rejected if
* user input cannot be obtained (for instance,
* because the user cancelled the dialog)
* @memberof platform/commonUI/dialog.DialogService#
*/
getUserInput: getUserInput,
/**
* Request that the user chooses from a set of options,
* which will be shown as buttons.
*
* @param dialogModel a description of the dialog to show
* @memberof platform/commonUI/dialog.DialogService#
*/
getUserChoice: getUserChoice
};
} }
// Stop showing whatever overlay is currently active
// (e.g. because the user hit cancel)
DialogService.prototype.dismiss = function () {
var overlay = this.overlay;
if (overlay) {
overlay.dismiss();
}
this.dialogVisible = false;
};
DialogService.prototype.getDialogResponse = function (key, model, resultGetter) {
// We will return this result as a promise, because user
// input is asynchronous.
var deferred = this.$q.defer(),
self = this;
// Confirm function; this will be passed in to the
// overlay-dialog template and associated with a
// OK button click
function confirm(value) {
// Pass along the result
deferred.resolve(resultGetter ? resultGetter() : value);
// Stop showing the dialog
self.dismiss();
}
// Cancel function; this will be passed in to the
// overlay-dialog template and associated with a
// Cancel or X button click
function cancel() {
deferred.reject();
self.dismiss();
}
// Add confirm/cancel callbacks
model.confirm = confirm;
model.cancel = cancel;
if (this.dialogVisible) {
// Only one dialog should be shown at a time.
// The application design should be such that
// we never even try to do this.
this.$log.warn([
"Dialog already showing; ",
"unable to show ",
model.name
].join(""));
deferred.reject();
} else {
// Add the overlay using the OverlayService, which
// will handle actual insertion into the DOM
this.overlay = this.overlayService.createOverlay(
key,
model
);
// Track that a dialog is already visible, to
// avoid spawning multiple dialogs at once.
this.dialogVisible = true;
}
return deferred.promise;
};
/**
* Request user input via a window-modal dialog.
*
* @param {FormModel} formModel a description of the form
* to be shown (see platform/forms)
* @param {object} value the initial state of the form
* @returns {Promise} a promise for the form value that the
* user has supplied; this may be rejected if
* user input cannot be obtained (for instance,
* because the user cancelled the dialog)
*/
DialogService.prototype.getUserInput = function (formModel, value) {
var overlayModel = {
title: formModel.name,
message: formModel.message,
structure: formModel,
value: value
};
// Provide result from the model
function resultGetter() {
return overlayModel.value;
}
// Show the overlay-dialog
return this.getDialogResponse(
"overlay-dialog",
overlayModel,
resultGetter
);
};
/**
* Request that the user chooses from a set of options,
* which will be shown as buttons.
*
* @param dialogModel a description of the dialog to show
* @return {Promise} a promise for the user's choice
*/
DialogService.prototype.getUserChoice = function (dialogModel) {
// Show the overlay-options dialog
return this.getDialogResponse(
"overlay-options",
{ dialog: dialogModel }
);
};
return DialogService; return DialogService;
} }
); );

81
platform/commonUI/dialog/src/OverlayService.js
View File

@ -47,54 +47,51 @@ define(
* @constructor * @constructor
*/ */
function OverlayService($document, $compile, $rootScope) { function OverlayService($document, $compile, $rootScope) {
function createOverlay(key, overlayModel) { this.$document = $document;
// Create a new scope for this overlay this.$compile = $compile;
var scope = $rootScope.$new(), this.$rootScope = $rootScope;
element; }
// Stop showing the overlay; additionally, release the scope /**
// that it uses. * Add a new overlay to the document. This will be
function dismiss() { * prepended to the document body; the overlay's
scope.$destroy(); * template (as pointed to by the `key` argument) is
element.remove(); * responsible for having a useful z-order, and for
} * blocking user interactions if appropriate.
*
* @param {string} key the symbolic key which identifies
* the template of the overlay to be shown
* @param {object} overlayModel the model to pass to the
* included overlay template (this will be passed
* in via ng-model)
*/
OverlayService.prototype.createOverlay = function (key, overlayModel) {
// Create a new scope for this overlay
var scope = this.$rootScope.$new(),
element;
// If no model is supplied, just fill in a default "cancel" // Stop showing the overlay; additionally, release the scope
overlayModel = overlayModel || { cancel: dismiss }; // that it uses.
function dismiss() {
// Populate the scope; will be passed directly to the template scope.$destroy();
scope.overlay = overlayModel; element.remove();
scope.key = key;
// Create the overlay element and add it to the document's body
element = $compile(TEMPLATE)(scope);
$document.find('body').prepend(element);
return {
dismiss: dismiss
};
} }
// If no model is supplied, just fill in a default "cancel"
overlayModel = overlayModel || { cancel: dismiss };
// Populate the scope; will be passed directly to the template
scope.overlay = overlayModel;
scope.key = key;
// Create the overlay element and add it to the document's body
element = this.$compile(TEMPLATE)(scope);
this.$document.find('body').prepend(element);
return { return {
/** dismiss: dismiss
* Add a new overlay to the document. This will be
* prepended to the document body; the overlay's
* template (as pointed to by the `key` argument) is
* responsible for having a useful z-order, and for
* blocking user interactions if appropriate.
*
* @param {string} key the symbolic key which identifies
* the template of the overlay to be shown
* @param {object} overlayModel the model to pass to the
* included overlay template (this will be passed
* in via ng-model)
* @memberof platform/commonUI/dialog.OverlayService#
*/
createOverlay: createOverlay
}; };
} };
return OverlayService; return OverlayService;
} }