mediawiki-extensions-Visual.../modules/ve/ui/inspectors/ve.ui.AnnotationInspector.js
Trevor Parscal 0ba331afdc Reset context menu on selection change while inspector is open
Objective:

* Make the inspector close and context menu reset when the selection is
  changed while an inspector is open

Changes:

ve.ui.PopupWidget.js
* Add isVisible method

ve.ui.Context.js
* Check if popup is visible when the selection changes and close the
  inspector and reset the context if it is

ve.ui.AnnotationInspector.js
* Don't update the selection when closing if the selection has changed
  since opening

Bug: 50895
Change-Id: Ie7f0b7ac76b0460b39ec002705172376e4e602dc
2013-07-15 23:51:40 +00:00

209 lines
5.9 KiB
JavaScript

/*!
* VisualEditor UserInterface AnnotationInspector class.
*
* @copyright 2011-2013 VisualEditor Team and others; see AUTHORS.txt
* @license The MIT License (MIT); see LICENSE.txt
*/
/**
* Annotation inspector.
*
* @class
* @abstract
* @extends ve.ui.Inspector
*
* @constructor
* @param {ve.ui.Surface} surface
* @param {Object} [config] Config options
*/
ve.ui.AnnotationInspector = function VeUiAnnotationInspector( surface, config ) {
// Parent constructor
ve.ui.Inspector.call( this, surface, config );
// Properties
this.initialAnnotation = null;
this.initialAnnotationHash = null;
this.isNewAnnotation = false;
};
/* Inheritance */
ve.inheritClass( ve.ui.AnnotationInspector, ve.ui.Inspector );
/**
* Annotation models this inspector can edit.
*
* @static
* @inheritable
* @property {Function[]}
*/
ve.ui.AnnotationInspector.static.modelClasses = [];
/* Methods */
/**
* Handle the inspector being setup.
*
* There are 4 scenarios:
* - Zero-length selection not near a word -> no change, text will be inserted on close
* - Zero-length selection inside or adjacent to a word -> expand selection to cover word
* - Selection covering non-annotated text -> trim selection to remove leading/trailing whitespace
* - Selection covering annotated text -> expand selection to cover annotation
*
* @method
*/
ve.ui.AnnotationInspector.prototype.onSetup = function () {
var expandedFragment, trimmedFragment, truncatedFragment,
fragment = this.surface.getModel().getFragment( null, true ),
annotation = this.getMatchingAnnotations( fragment, true ).get( 0 );
// Parent method
ve.ui.Inspector.prototype.onSetup.call( this );
// Initialize range
if ( !annotation ) {
if ( fragment.getRange().isCollapsed() ) {
// Expand to nearest word
expandedFragment = fragment.expandRange( 'word' );
fragment = expandedFragment;
} else {
// Trim whitespace
trimmedFragment = fragment.trimRange();
fragment = trimmedFragment;
}
if ( !fragment.getRange().isCollapsed() ) {
// Create annotation from selection
truncatedFragment = fragment.truncateRange( 255 );
fragment = truncatedFragment;
annotation = this.getAnnotationFromText( fragment.getText() );
fragment.annotateContent( 'set', annotation );
this.isNewAnnotation = true;
}
} else {
// Expand range to cover annotation
expandedFragment = fragment.expandRange( 'annotation', annotation );
fragment = expandedFragment;
}
// Update selection
fragment.select();
};
/**
* Handle the inspector being opened.
*/
ve.ui.AnnotationInspector.prototype.onOpen = function () {
var fragment = this.surface.getModel().getFragment( null, true ),
// Note that we don't set the 'all' flag here so that any
// non-annotated content is annotated on close
initialAnnotation = this.getMatchingAnnotations( fragment ).get( 0 );
// Parent method
ve.ui.Inspector.prototype.onOpen.call( this );
// Initialization
this.initialAnnotation = initialAnnotation;
this.initialAnnotationHash = initialAnnotation ? ve.getHash( initialAnnotation ) : null;
};
/**
* Handle the inspector being closed.
*
* @param {string} action Action that caused the window to be closed
*/
ve.ui.AnnotationInspector.prototype.onClose = function ( action ) {
// Parent method
ve.ui.Inspector.prototype.onClose.call( this, action );
var i, len, annotations, selection,
insert = false,
undo = false,
clear = false,
set = false,
target = this.targetInput.getValue(),
annotation = this.targetInput.getAnnotation(),
remove = action === 'remove' && !!annotation,
surfaceModel = this.surface.getModel(),
fragment = surfaceModel.getFragment( this.initialSelection, false ),
currentSelection = surfaceModel.getSelection();
if ( remove ) {
clear = true;
} else {
if ( this.initialSelection.isCollapsed() ) {
insert = true;
}
if ( ve.getHash( annotation ) !== this.initialAnnotationHash ) {
if ( this.isNewAnnotation ) {
undo = true;
} else {
clear = true;
}
set = true;
}
}
if ( insert ) {
fragment.insertContent( target, false );
// Move cursor to the end of the inserted content, even if back button is used
this.previousSelection = new ve.Range( this.initialSelection.start + target.length );
}
if ( undo ) {
// Go back to before we added an annotation
this.surface.execute( 'history', 'undo' );
}
if ( clear ) {
// Clear all existing annotations
annotations = this.getMatchingAnnotations( fragment, true ).get();
for ( i = 0, len = annotations.length; i < len; i++ ) {
fragment.annotateContent( 'clear', annotations[i] );
}
}
if ( set ) {
// Apply new annotation
fragment.annotateContent( 'set', annotation );
}
if ( action === 'back' ) {
selection = this.previousSelection;
}
// Update selection unless it's been changed since opening inspector
if ( currentSelection.equals( this.initialSelection ) ) {
this.surface.execute(
'content', 'select', selection || new ve.Range( fragment.getRange().end )
);
}
// Reset state
this.isNewAnnotation = false;
};
/**
* Get an annotation object from text.
*
* @method
* @abstract
* @param {string} text Content text
* @returns {ve.dm.Annotation}
* @throws {Error} If not overriden in a subclass
*/
ve.ui.AnnotationInspector.prototype.getAnnotationFromText = function () {
throw new Error(
've.ui.AnnotationInspector.getAnnotationFromText not implemented in subclass'
);
};
/**
* Get matching annotations within a fragment.
*
* @method
* @param {ve.dm.SurfaceFragment} fragment Fragment to get matching annotations within
* @param {boolean} [all] Get annotations which only cover some of the fragment
* @returns {ve.dm.AnnotationSet} Matching annotations
*/
ve.ui.AnnotationInspector.prototype.getMatchingAnnotations = function ( fragment, all ) {
var modelClasses = this.constructor.static.modelClasses;
return fragment.getAnnotations( all ).filter( function ( annnotation ) {
return ve.isInstanceOfAny( annnotation, modelClasses );
} );
};