mediawiki-extensions-Visual.../modules/ve-mw/dm/models/ve.dm.MWImageModel.js
Moriel Schottlender e454b81f4d When changing image source, use already-available API info
When the user changes an image to another in the media dialog, we
already have API info that includes the original dimensions, media
type and other information that is required for the Scalable object
to compute the new current dimensions. We can use this info if it
exists instead of asking for another API call. Also make sure to
update the filename when we change an image in the dialog.

Bug: T87267
Change-Id: I9d86959b99b3f3dfed92255a9dba9a8fdd352dcb
2015-01-29 01:58:07 +00:00

1194 lines
33 KiB
JavaScript

/*!
* VisualEditor DataModel MWImageModel class.
*
* @copyright 2011-2015 VisualEditor Team and others; see AUTHORS.txt
* @license The MIT License (MIT); see LICENSE.txt
*/
/**
* MediaWiki image model.
*
* @class
* @mixins OO.EventEmitter
*
* @constructor
* @param {Object} [config] Configuration options
* @cfg {string} [resourceName] The resource name of the given media file
* @cfg {Object} [currentDimensions] Current dimensions, width & height
* @cfg {Object} [minDimensions] Minimum dimensions, width & height
* @cfg {boolean} [isDefaultSize] Object is using its default size dimensions
*/
ve.dm.MWImageModel = function VeDmMWImageModel( config ) {
var scalable, currentDimensions, minDimensions;
config = config || {};
// Mixin constructors
OO.EventEmitter.call( this );
// Properties
this.attributesCache = null;
// Image properties
this.captionDoc = null;
this.caption = null;
this.mediaType = null;
this.altText = '';
this.type = null;
this.alignment = null;
this.scalable = null;
this.sizeType = null;
this.border = false;
this.borderable = false;
this.dir = null;
this.lang = null;
this.defaultDimensions = null;
this.imageSrc = '';
this.imageResourceName = '';
this.imageHref = '';
this.boundingBox = null;
this.initialHash = {};
// Get wiki default thumbnail size
this.defaultThumbSize = mw.config.get( 'wgVisualEditorConfig' )
.defaultUserOptions.defaultthumbsize;
if ( config.resourceName ) {
this.setImageResourceName( config.resourceName );
}
// Create scalable
currentDimensions = config.currentDimensions || {};
minDimensions = config.minDimensions || {};
scalable = new ve.dm.Scalable( {
currentDimensions: {
width: currentDimensions.width,
height: currentDimensions.height
},
minDimensions: {
width: minDimensions.width || 1,
height: minDimensions.height || 1
},
defaultSize: !!config.isDefaultSize
} );
// Set the initial scalable, connect it to events
// and request an update from the API
this.attachScalable( scalable );
};
/* Inheritance */
OO.mixinClass( ve.dm.MWImageModel, OO.EventEmitter );
/* Events */
/**
* Change of image alignment or of having alignment at all
*
* @event alignmentChange
* @param {string} Alignment 'left', 'right', 'center' or 'none'
*/
/**
* Change in size type between default and custom
*
* @event sizeDefaultChange
* @param {boolean} Image is default size
*/
/**
* Change in the image type
*
* @event typeChange
* @param {string} Image type 'thumb', 'frame', 'frameless' or 'none'
*/
/* Static Properties */
ve.dm.MWImageModel.static.infoCache = {};
/* Static Methods */
/**
* Create a new image node based on given parameters.
* @param {Object} attributes Image attributes
* @param {string} [imageType] Image node type 'mwInlineImage' or 'mwBlockImage'.
* Defaults to 'mwBlockImage'
* @returns {ve.dm.MWImageNode} An image node
*/
ve.dm.MWImageModel.static.createImageNode = function ( attributes, imageType ) {
var attrs, newNode, newDimensions,
defaultThumbSize = mw.config.get( 'wgVisualEditorConfig' ).defaultUserOptions.defaultthumbsize;
attrs = ve.extendObject( {
type: 'thumb',
align: 'default',
width: defaultThumbSize,
mediaType: 'BITMAP',
defaultSize: true
}, attributes );
if ( attrs.defaultSize ) {
newDimensions = ve.dm.MWImageNode.static.scaleToThumbnailSize( attrs, attrs.mediaType );
if ( newDimensions ) {
attrs.width = newDimensions.width;
attrs.height = newDimensions.height;
}
}
imageType = imageType || 'mwBlockImage';
newNode = ve.dm.nodeFactory.create( imageType, {
type: imageType,
attributes: attrs
} );
ve.dm.MWImageNode.static.syncScalableToType( attrs.type, attrs.mediaType, newNode.getScalable() );
return newNode;
};
/**
* Load from image data with scalable information.
*
* @param {Object} attrs Image node attributes
* @param {string} [dir] Document direction
* @param {string} [lang] Document language
* @param {string} [caption] Existing image caption HTML
* @return {ve.dm.MWImageModel} Image model
*/
ve.dm.MWImageModel.static.newFromImageAttributes = function ( attrs, dir, lang, caption ) {
var captionDomTree,
imgModel = new ve.dm.MWImageModel( {
resourceName: attrs.resource,
currentDimensions: {
width: attrs.width,
height: attrs.height
},
defaultSize: !!attrs.defaultSize
} );
// Cache the attributes so we can create a new image without
// losing any existing information
imgModel.cacheOriginalImageAttributes( attrs );
imgModel.setImageSource( attrs.src );
imgModel.setFilename( new mw.Title( attrs.resource.replace( /^(\.+\/)*/, '' ) ).getMainText() );
imgModel.setImageHref( attrs.href );
// Set bounding box
imgModel.setBoundingBox( {
width: attrs.width,
height: attrs.height
} );
// Collect all the information
imgModel.toggleBorder( !!attrs.borderImage );
imgModel.setAltText( attrs.alt || '' );
imgModel.setDir( dir );
imgModel.setLang( lang );
imgModel.setType( attrs.type );
// Fix cases where alignment is undefined
// Inline images have no 'align' (they have 'valign' instead)
// But we do want an alignment case for these in case they
// are transformed to block images
imgModel.setAlignment( attrs.align || 'default' );
// Default size
imgModel.toggleDefaultSize( !!attrs.defaultSize );
// TODO: When scale/upright is available, set the size
// type accordingly
imgModel.setSizeType(
imgModel.isDefaultSize() ?
'default' :
'custom'
);
// If a caption is given, use it in the document
if ( caption ) {
captionDomTree = ve.createDocumentFromHtml( caption );
imgModel.setCaptionDocument( ve.dm.converter.getModelFromDom( captionDomTree ) );
}
return imgModel;
};
/* Methods */
/**
* Get the hash object of the current image model state.
* @returns {Object} Hash object
*/
ve.dm.MWImageModel.prototype.getHashObject = function () {
var hash = {
filename: this.getFilename(),
altText: this.getAltText(),
type: this.getType(),
alignment: this.getAlignment(),
sizeType: this.getSizeType(),
border: this.hasBorder(),
borderable: this.isBorderable()
};
if ( this.getScalable() ) {
hash.scalable = {
currentDimensions: ve.copy( this.getScalable().getCurrentDimensions() ),
isDefault: this.getScalable().isDefault()
};
}
return hash;
};
/**
* Normalize the source url by stripping the protocol off.
* This is done so when an image is replaced with the same image,
* the imageModel can recognize that nothing has actually changed.
*
* Example:
* 'http://upload.wikimedia.org/wikipedia/commons/0/Foo.png'
* to '//upload.wikimedia.org/wikipedia/commons/0/Foo.png'
*
* @return {string} Normalized image source
*/
ve.dm.MWImageModel.prototype.getNormalizedImageSource = function () {
// Strip the url prefix 'http' / 'https' etc
return this.getImageSource().replace( /^https?:\/\//, '//' );
};
/**
* Adjust the model parameters based on a new image
* @param {Object} attrs New image source attributes
* @param {Object} [APIinfo] The image's API info
* @throws {Error} Image has insufficient details to compute the imageModel details.
*/
ve.dm.MWImageModel.prototype.changeImageSource = function ( attrs, APIinfo ) {
var imageModel = this;
if ( attrs.mediaType ) {
this.setMediaType( attrs.mediaType );
}
if ( attrs.href ) {
this.setImageHref( attrs.href );
}
if ( attrs.resource ) {
this.setImageResourceName( attrs.resource );
this.setFilename( new mw.Title( attrs.resource.replace( /^(\.+\/)*/, '' ) ).getMainText() );
}
if ( attrs.src ) {
this.setImageSource( attrs.src );
}
// Remove the scalable default and original dimensions
this.scalable.clearOriginalDimensions();
this.scalable.clearDefaultDimensions();
this.scalable.clearMaxDimensions();
this.scalable.clearMinDimensions();
// If we already have dimensions from the API, use them
if ( APIinfo ) {
imageModel.scalable.setOriginalDimensions( {
width: APIinfo.width,
height: APIinfo.height
} );
// Update media type
imageModel.setMediaType( APIinfo.mediatype );
// Update defaults
ve.dm.MWImageNode.static.syncScalableToType(
imageModel.getType(),
APIinfo.mediatype,
imageModel.scalable
);
imageModel.updateScalableDetails( {
width: APIinfo.width,
height: APIinfo.height
} );
} else {
// Call for updated scalable if we don't have dimensions from the API info
if ( this.getFilename() ) {
// Update anyways
ve.dm.MWImageNode.static.getScalablePromise( this.getFilename() ).done( function ( info ) {
imageModel.scalable.setOriginalDimensions( {
width: info.width,
height: info.height
} );
// Update media type
imageModel.setMediaType( info.mediatype );
// Update defaults
ve.dm.MWImageNode.static.syncScalableToType(
imageModel.getType(),
info.mediatype,
imageModel.scalable
);
imageModel.updateScalableDetails( {
width: info.width,
height: info.height
} );
} );
} else {
throw new Error( 'Cannot compute details for an image without remote filename and without sizing info.' );
}
}
};
/**
* Get the current image node type according to the attributes.
* If either of the parameters are given, the node type is tested
* against them, otherwise, it is tested against the current image
* parameters.
*
* @param {string} [imageType] Optional. Image type.
* @param {string} [align] Optional. Image alignment.
* @return {string} Node type 'mwInlineImage' or 'mwBlockImage'
*/
ve.dm.MWImageModel.prototype.getImageNodeType = function ( imageType, align ) {
imageType = imageType || this.getType();
if (
( this.getType() === 'frameless' || this.getType() === 'none' ) &&
( !this.isAligned( align ) || this.isDefaultAligned( imageType, align ) )
) {
return 'mwInlineImage';
} else {
return 'mwBlockImage';
}
};
/**
* Get the original bounding box
* @returns {Object} Bounding box with width and height
*/
ve.dm.MWImageModel.prototype.getBoundingBox = function () {
return this.boundingBox;
};
/**
* Update an existing image node by changing its attributes
*
* @param {ve.dm.MWImageNode} node Image node to update
* @param {ve.dm.Surface} surfaceModel Surface model of main document
*/
ve.dm.MWImageModel.prototype.updateImageNode = function ( node, surfaceModel ) {
var captionRange, captionNode,
doc = surfaceModel.getDocument();
// Update the caption
if ( node.getType() === 'mwBlockImage' ) {
captionNode = node.getCaptionNode();
if ( !captionNode ) {
// There was no caption before, so insert one now
surfaceModel.getFragment()
.adjustLinearSelection( 1 )
.collapseToStart()
.insertContent( [ { type: 'mwImageCaption' }, { type: '/mwImageCaption' } ] );
// Update the caption node
captionNode = node.getCaptionNode();
}
captionRange = captionNode.getRange();
// Remove contents of old caption
surfaceModel.change(
ve.dm.Transaction.newFromRemoval(
doc,
captionRange,
true
)
);
// Add contents of new caption
surfaceModel.change(
ve.dm.Transaction.newFromDocumentInsertion(
doc,
captionRange.start,
this.getCaptionDocument()
)
);
}
// Update attributes
surfaceModel.change(
ve.dm.Transaction.newFromAttributeChanges(
doc,
node.getOffset(),
this.getUpdatedAttributes()
)
);
};
/**
* Insert image into a surface.
*
* Image is inserted at the current fragment position.
*
* @param {ve.dm.SurfaceFragment} fragment Fragment covering range to insert at
* @return {ve.dm.SurfaceFragment} Fragment covering inserted image
* @throws {Error} Unknown image node type
*/
ve.dm.MWImageModel.prototype.insertImageNode = function ( fragment ) {
var editAttributes, captionDoc,
offset,
contentToInsert = [],
nodeType = this.getImageNodeType(),
originalAttrs = ve.copy( this.getOriginalImageAttributes() ),
surfaceModel = fragment.getSurface();
if ( !( fragment.getSelection() instanceof ve.dm.LinearSelection ) ) {
return fragment;
}
editAttributes = $.extend( originalAttrs, this.getUpdatedAttributes() );
// Remove old classes
delete editAttributes.originalClasses;
delete editAttributes.unrecognizedClasses;
contentToInsert = [
{
type: nodeType,
attributes: editAttributes
},
{ type: '/' + nodeType }
];
switch ( nodeType ) {
case 'mwInlineImage':
// Try to put the image inside the nearest content node
offset = fragment.getDocument().data.getNearestContentOffset( fragment.getSelection().getRange().start );
if ( offset > -1 ) {
fragment = fragment.clone( new ve.dm.LinearSelection( fragment.getDocument(), new ve.Range( offset ) ) );
}
fragment.insertContent( contentToInsert );
return fragment;
case 'mwBlockImage':
contentToInsert.splice( 1, 0, { type: 'mwImageCaption' }, { type: '/mwImageCaption' } );
// Try to put the image in front of the structural node
offset = fragment.getDocument().data.getNearestStructuralOffset( fragment.getSelection().getRange().start, -1 );
if ( offset > -1 ) {
fragment = fragment.clone( new ve.dm.LinearSelection( fragment.getDocument(), new ve.Range( offset ) ) );
}
fragment.insertContent( contentToInsert );
// Check if there is caption document and insert it
captionDoc = this.getCaptionDocument();
if ( captionDoc.data.countNonInternalElements() > 2 ) {
// Add contents of new caption
surfaceModel.change(
ve.dm.Transaction.newFromDocumentInsertion(
surfaceModel.getDocument(),
fragment.getSelection().getRange().start + 2,
this.getCaptionDocument()
)
);
}
return fragment;
default:
throw new Error( 'Unknown image node type ' + nodeType );
}
};
/**
* Return all updated attributes that belong to the node.
* @return {Object} Updated attributes
*/
ve.dm.MWImageModel.prototype.getUpdatedAttributes = function () {
var attrs, currentDimensions,
origAttrs = this.getOriginalImageAttributes();
// Adjust default dimensions if size is set to default
if ( this.scalable.isDefault() && this.scalable.getDefaultDimensions() ) {
currentDimensions = this.scalable.getDefaultDimensions();
} else {
currentDimensions = this.getCurrentDimensions();
}
attrs = {
type: this.getType(),
width: currentDimensions.width,
height: currentDimensions.height,
defaultSize: this.isDefaultSize(),
borderImage: this.hasBorder()
};
if ( origAttrs.alt !== undefined || this.getAltText() !== '' ) {
attrs.alt = this.getAltText();
}
if ( this.isDefaultAligned() ) {
attrs.align = 'default';
} else if ( !this.isAligned() ) {
attrs.align = 'none';
} else {
attrs.align = this.getAlignment();
}
attrs.src = this.getImageSource();
attrs.href = this.getImageHref();
attrs.resource = this.getImageResourceName();
// If converting from block to inline, set isLinked=true to avoid |link=
if ( origAttrs.isLinked === undefined && this.getImageNodeType() === 'mwInlineImage' ) {
attrs.isLinked = true;
}
return attrs;
};
/**
* Deal with default change on the scalable object
*
* @param {boolean} isDefault
*/
ve.dm.MWImageModel.prototype.onScalableDefaultSizeChange = function ( isDefault ) {
this.toggleDefaultSize( isDefault );
};
/**
* Set the image file source
* @param {string} src The source of the given media file
*/
ve.dm.MWImageModel.prototype.setImageSource = function ( src ) {
this.imageSrc = src;
};
/**
* Set the image file resource name
* @param {string} resourceName The resource name of the given image file
*/
ve.dm.MWImageModel.prototype.setImageResourceName = function ( resourceName ) {
this.imageResourceName = resourceName;
};
/**
* Set the image href value
* @param {string} href The destination href of the given media file
*/
ve.dm.MWImageModel.prototype.setImageHref = function ( href ) {
this.imageHref = href;
};
/**
* Set the original bounding box
* @param {Object} box Bounding box with width and height
*/
ve.dm.MWImageModel.prototype.setBoundingBox = function ( box ) {
this.boundingBox = box;
};
/**
* Set the initial hash object of the image to be compared to when
* checking if the model is modified.
*
* @param {Object} hash The initial hash object
*/
ve.dm.MWImageModel.prototype.storeInitialHash = function ( hash ) {
this.initialHash = hash;
};
/**
* Set symbolic name of media type.
*
* Example values: "BITMAP" for JPEG or PNG images; "DRAWING" for SVG graphics
*
* @param {string|undefined} Symbolic media type name, or undefined if empty
*/
ve.dm.MWImageModel.prototype.setMediaType = function ( type ) {
this.mediaType = type;
};
/**
* Check whether the image is set to default size
* @return {boolean} Default size flag on or off
*/
ve.dm.MWImageModel.prototype.isDefaultSize = function () {
return this.scalable.isDefault();
};
/**
* Check whether the image has the border flag set
* @return {boolean} Border flag on or off
*/
ve.dm.MWImageModel.prototype.hasBorder = function () {
return this.border;
};
/**
* Check whether the image has floating alignment set
* @param {string} [align] Optional. Alignment value to test against.
* @return {boolean} hasAlignment flag on or off
*/
ve.dm.MWImageModel.prototype.isAligned = function ( align ) {
align = align || this.alignment;
// The image is aligned if it has alignment (not undefined and not null)
// and if its alignment is not 'none'.
// Inline images initially have null alignment value (and are not aligned)
return align && align !== 'none';
};
/**
* Check whether the image is set to default alignment
* We explicitly repeat tests so to avoid recursively calling
* the other methods.
* @param {string} [align] Optional alignment value to test against.
* Supplying this parameter would test whether this align parameter
* would mean the image is aligned to its default position.
* @return {boolean} defaultAlignment flag on or off
*/
ve.dm.MWImageModel.prototype.isDefaultAligned = function ( imageType, align ) {
var alignment = align || this.getAlignment(),
defaultAlignment = ( this.getDir() === 'rtl' ) ? 'left' : 'right';
imageType = imageType || this.getType();
// No alignment specified means defeault alignment always
// Inline images have no align attribute; during the initialization
// stage of the model we have to account for that option. Later the
// model creates a faux alignment for inline images ('none' for default)
// but if initially the alignment is null or undefined, it means the image
// is inline without explicit alignment (which makes it default aligned)
if ( !alignment ) {
return true;
}
if (
(
( imageType === 'frameless' || imageType === 'none' ) &&
alignment === 'none'
) ||
(
( imageType === 'thumb' || imageType === 'frame' ) &&
alignment === defaultAlignment
)
) {
return true;
}
return false;
};
/**
* Check whether the image can have a border set on it
* @return {boolean} Border possible or not
*/
ve.dm.MWImageModel.prototype.isBorderable = function () {
return this.borderable;
};
/**
* Get the image file resource name
* @returns {string} resourceName The resource name of the given media file
*/
ve.dm.MWImageModel.prototype.getResourceName = function () {
return this.imageResourceName;
};
/**
* Get the image alternate text
* @return {string} Alternate text
*/
ve.dm.MWImageModel.prototype.getAltText = function () {
return this.altText || '';
};
/**
* Get image wikitext type; 'thumb', 'frame', 'frameless' or 'none/inline'
* @return {string} Image type
*/
ve.dm.MWImageModel.prototype.getType = function () {
return this.type;
};
/**
* Get the image size type of the image
*/
ve.dm.MWImageModel.prototype.getSizeType = function () {
return this.sizeType;
};
/**
* Get symbolic name of media type.
*
* Example values: "BITMAP" for JPEG or PNG images; "DRAWING" for SVG graphics
*
* @return {string|undefined} Symbolic media type name, or undefined if empty
*/
ve.dm.MWImageModel.prototype.getMediaType = function () {
return this.mediaType;
};
/**
* Get image alignment 'left', 'right', 'center', 'none' or 'default'
* @return {string|null} Image alignment. Inline images have initial alignment
* value of null.
*/
ve.dm.MWImageModel.prototype.getAlignment = function () {
return this.alignment;
};
/**
* Get image vertical alignment
* 'middle', 'baseline', 'sub', 'super', 'top', 'text-top', 'bottom', 'text-bottom' or 'default'
* @return {string} Image alignment
*/
ve.dm.MWImageModel.prototype.getVerticalAlignment = function () {
return this.verticalAlignment;
};
/**
* Get the scalable object responsible for size manipulations
* for the given image
* @return {ve.dm.Scalable} Scalable object
*/
ve.dm.MWImageModel.prototype.getScalable = function () {
return this.scalable;
};
/**
* Get the image current dimensions
* @return {Object} Current dimensions width/height
* @return {number} dimensions.width The width of the image
* @return {number} dimensions.height The height of the image
*/
ve.dm.MWImageModel.prototype.getCurrentDimensions = function () {
return this.scalable.getCurrentDimensions();
};
/**
* Get image caption document.
*
* Auto-generates a blank document if no document exists.
*
* @return {ve.dm.Document} Caption document
*/
ve.dm.MWImageModel.prototype.getCaptionDocument = function () {
if ( !this.captionDoc ) {
this.captionDoc = new ve.dm.Document( [
{ type: 'paragraph', internal: { generated: 'wrapper' } },
{ type: '/paragraph' },
{ type: 'internalList' },
{ type: '/internalList' }
],
/* htmlDocument */ null,
/* parentDocument */ null,
/* internalList */ null,
/* innerWhitespace */ null,
/* lang */ this.getLang(),
/* dir */ this.getDir() );
}
return this.captionDoc;
};
/**
* Toggle the option of whether this image can or cannot have
* a border set on it.
*
* @param {boolean} [borderable] Set or unset borderable. If not
* specified, the current state is toggled.
*/
ve.dm.MWImageModel.prototype.toggleBorderable = function ( borderable ) {
borderable = borderable !== undefined ? !!borderable : !this.isBorderable();
this.borderable = borderable;
};
/**
* Toggle the border flag of the image
*
* @param {boolean} [hasBorder] Border flag. Omit to toggle current value.
*/
ve.dm.MWImageModel.prototype.toggleBorder = function ( hasBorder ) {
hasBorder = hasBorder !== undefined ? !!hasBorder : !this.hasBorder();
this.border = !!hasBorder;
};
/**
* Toggle the default size flag of the image
* @param {boolean} [isDefault] Default size flag. Omit to toggle current value.
* @fires sizeDefaultChange
*/
ve.dm.MWImageModel.prototype.toggleDefaultSize = function ( isDefault ) {
isDefault = isDefault !== undefined ? !!isDefault : !this.isDefaultSize();
if ( this.isDefaultSize() !== isDefault ) {
this.scalable.toggleDefault( !!isDefault );
this.resetDefaultDimensions();
this.emit( 'sizeDefaultChange', !!isDefault );
}
};
/**
* Cache all image attributes
* @param {Object} attrs Image attributes
*/
ve.dm.MWImageModel.prototype.cacheOriginalImageAttributes = function ( attrs ) {
this.attributesCache = attrs;
};
/**
* Get the cache of all image attributes
* @return {Object} attrs Image attributes
*/
ve.dm.MWImageModel.prototype.getOriginalImageAttributes = function () {
return this.attributesCache;
};
/**
* Set the current dimensions of the image.
* Normalize in case only one dimension is available.
* @param {Object} dimensions Dimensions width and height
* @param {number} dimensions.width The width of the image
* @param {number} dimensions.height The height of the image
*/
ve.dm.MWImageModel.prototype.setCurrentDimensions = function ( dimensions ) {
var normalizedDimensions = ve.dm.Scalable.static.getDimensionsFromValue( dimensions, this.scalable.getRatio() );
this.scalable.setCurrentDimensions( normalizedDimensions );
};
/**
* Set alternate text
* @param {string} text Alternate text
*/
ve.dm.MWImageModel.prototype.setAltText = function ( text ) {
this.altText = text;
};
/**
* Set image type
* @see #getType
*
* @param {string} type Image type
* @fires typeChange
*/
ve.dm.MWImageModel.prototype.setType = function ( type ) {
var isDefaultAligned = this.isDefaultAligned( this.imageCurrentType );
this.type = type;
// If we're switching between inline and block or vise versa,
// check if the old type image was default aligned
if ( isDefaultAligned && this.imageCurrentType !== this.type ) {
if ( this.type === 'none' || this.type === 'frameless' ) {
// Reset default alignment for switching to inline images
this.setAlignment( 'none' );
} else {
// Reset default alignment for all other images
this.setAlignment( 'default' );
}
}
// Cache the current type for next check
this.imageCurrentType = type;
if ( type === 'frame' || type === 'thumb' ) {
// Disable border option
this.toggleBorderable( false );
} else {
// Enable border option
this.toggleBorderable( true );
}
// If type is frame, set to 'default' size
if ( type === 'frame' ) {
this.toggleDefaultSize( true );
}
// Let the image node update scalable considerations
// for default and max dimensions as per the new type.
ve.dm.MWImageNode.static.syncScalableToType( type, this.getMediaType(), this.getScalable() );
this.emit( 'typeChange', type );
};
/**
* Reset the default dimensions of the image based on its type
* and on whether we have the originalDimensions object from
* the API
*/
ve.dm.MWImageModel.prototype.resetDefaultDimensions = function () {
var originalDimensions = this.scalable.getOriginalDimensions();
if ( !$.isEmptyObject( originalDimensions ) ) {
if ( this.getType() === 'thumb' || this.getType() === 'frameless' ) {
// Default is thumb size
if ( originalDimensions.width <= this.defaultThumbSize ) {
this.scalable.setDefaultDimensions( originalDimensions );
} else {
this.scalable.setDefaultDimensions(
ve.dm.Scalable.static.getDimensionsFromValue( {
width: this.defaultThumbSize
}, this.scalable.getRatio() )
);
}
} else {
// Default is original size
this.scalable.setDefaultDimensions( originalDimensions );
}
} else {
this.scalable.setDefaultDimensions( {} );
}
};
/**
* Retrieve the currently set default dimensions from the scalable
* object attached to the image.
*
* @return {Object} Image default dimensions
*/
ve.dm.MWImageModel.prototype.getDefaultDimensions = function () {
return this.scalable.getDefaultDimensions();
};
/**
* Change size type of the image
*
* @param {string} type Size type 'default', 'custom' or 'scale'
*/
ve.dm.MWImageModel.prototype.setSizeType = function ( type ) {
if ( this.sizeType !== type ) {
this.sizeType = type;
this.toggleDefaultSize( type === 'default' );
}
};
/**
* Set image alignment
*
* @see #getAlignment
*
* @param {string} align Alignment
*/
ve.dm.MWImageModel.prototype.setAlignment = function ( align ) {
if ( align === 'default' ) {
// If default, set the alignment to language dir default
align = this.getDefaultDir();
}
this.alignment = align;
this.emit( 'alignmentChange', align );
};
/**
* Set image vertical alignment
*
* @see #getVerticalAlignment
*
* @param {string} valign Alignment
*/
ve.dm.MWImageModel.prototype.setVerticalAlignment = function ( valign ) {
this.verticalAlignment = valign;
this.emit( 'alignmentChange', valign );
};
/**
* Get the default alignment according to the document direction
*
* @param {string} [imageNodeType] Optional. The image node type that we would
* like to get the default direction for. Supplying this parameter allows us
* to check what the default alignment of a specific type of node would be.
* If the parameter is not supplied, the default alignment will be calculated
* based on the current node type.
* @return {string} Node alignment based on document direction
*/
ve.dm.MWImageModel.prototype.getDefaultDir = function ( imageNodeType ) {
imageNodeType = imageNodeType || this.getImageNodeType();
if ( this.getDir() === 'rtl' ) {
// Assume position is 'left'
return ( imageNodeType === 'mwBlockImage' ) ? 'left' : 'none';
} else {
// Assume position is 'right'
return ( imageNodeType === 'mwBlockImage' ) ? 'right' : 'none';
}
};
/**
* Get the directionality of the image, especially important for
* default alignment.
*
* @return {string} Current document direction 'rtl' or 'ltr'
*/
ve.dm.MWImageModel.prototype.getDir = function () {
return this.dir;
};
/**
* Set the directionality of the image, especially important for
* default alignment.
* @param {string} dir 'rtl' or 'ltr'
*/
ve.dm.MWImageModel.prototype.setDir = function ( dir ) {
this.dir = dir;
};
/**
* Get the language of the image document. Specifically relevant
* for the caption document.
* @return {string} Document language
*/
ve.dm.MWImageModel.prototype.getLang = function () {
return this.lang;
};
/**
* Set the language of the image document. Specifically relevant
* for the caption document.
* @param {string} lang Document language
*/
ve.dm.MWImageModel.prototype.setLang = function ( lang ) {
this.lang = lang;
};
/**
* Get the image file source
* The image file source that points to the location of the
* file on the web.
* For instance, '//upload.wikimedia.org/wikipedia/commons/0/0f/Foo.jpg'
* @returns {string} The source of the given media file
*/
ve.dm.MWImageModel.prototype.getImageSource = function () {
return this.imageSrc;
};
/**
* Get the image file resource name.
* The resource name represents the filename without the full
* source url.
* For example, './File:Foo.jpg'
* @returns {string} The resource name of the given media file
*/
ve.dm.MWImageModel.prototype.getImageResourceName = function () {
return this.imageResourceName;
};
/**
* Get the image href value.
* This is the link that the image leads to. It usually contains
* the link to the source of the image in commons or locally, but
* may hold an alternative link if link= is supplied in the wikitext.
* For example, './File:Foo.jpg' or 'http://www.wikipedia.org'
* @returns {string} The destination href of the given media file
*/
ve.dm.MWImageModel.prototype.getImageHref = function () {
return this.imageHref;
};
/**
* Attach a new scalable object to the model and request the
* information from the API.
*
* @param {ve.dm.Scalable} Scalable object
*/
ve.dm.MWImageModel.prototype.attachScalable = function ( scalable ) {
var imageName = this.getResourceName().replace( /^(\.+\/)*/, '' ),
imageModel = this;
if ( this.scalable instanceof ve.dm.Scalable ) {
this.scalable.disconnect( this );
}
this.scalable = scalable;
// Events
this.scalable.connect( this, { defaultSizeChange: 'onScalableDefaultSizeChange' } );
// Call for updated scalable
if ( imageName ) {
ve.dm.MWImageNode.static.getScalablePromise( imageName ).done( function ( info ) {
imageModel.scalable.setOriginalDimensions( {
width: info.width,
height: info.height
} );
// Update media type
imageModel.setMediaType( info.mediatype );
// Update according to type
ve.dm.MWImageNode.static.syncScalableToType(
imageModel.getType(),
imageModel.getMediaType(),
imageModel.getScalable()
);
// We have to adjust the details in the initial hash if the original
// image was 'default' since we didn't have default until now and the
// default dimensions that were 'recorded' were wrong
if ( !$.isEmptyObject( imageModel.initialHash ) && imageModel.initialHash.scalable.isDefault ) {
imageModel.initialHash.scalable.currentDimensions = imageModel.scalable.getDefaultDimensions();
}
} );
}
};
/**
* Set the filename of the current image
* @param {string} filename Image filename
*/
ve.dm.MWImageModel.prototype.setFilename = function ( filename ) {
this.filename = filename;
};
/**
* Get the filename of the current image
* @returns {string} filename Image filename
*/
ve.dm.MWImageModel.prototype.getFilename = function () {
return this.filename;
};
/**
* If the image changed, update scalable definitions.
* @param {Object} originalDimensions Image original dimensions
*/
ve.dm.MWImageModel.prototype.updateScalableDetails = function ( originalDimensions ) {
var newDimensions;
// Resize the new image's current dimensions to default or based on the bounding box
if ( this.isDefaultSize() ) {
// Scale to default
newDimensions = ve.dm.MWImageNode.static.scaleToThumbnailSize( originalDimensions );
} else {
if ( this.getBoundingBox() ) {
// Scale the new image by its width
newDimensions = ve.dm.MWImageNode.static.resizeToBoundingBox(
originalDimensions,
{
width: this.boundingBox.width,
height: Infinity
}
);
} else {
newDimensions = originalDimensions;
}
}
if ( newDimensions ) {
this.getScalable().setCurrentDimensions( newDimensions );
}
};
/**
* Set image caption document.
*
* @param {ve.dm.Document} Image caption document
*/
ve.dm.MWImageModel.prototype.setCaptionDocument = function ( doc ) {
this.captionDoc = doc;
};
/**
* Check if the model attributes and parameters have been modified by
* comparing the current hash to the new hash object.
* @return {boolean} Model has been modified
*/
ve.dm.MWImageModel.prototype.hasBeenModified = function () {
if ( this.initialHash ) {
return !ve.compare( this.initialHash, this.getHashObject() );
}
return true;
};