2013-07-03 22:14:52 +00:00
|
|
|
/*!
|
2015-07-29 13:41:30 +00:00
|
|
|
* VisualEditor MediaWiki DesktopArticleTarget init.
|
2013-07-03 22:14:52 +00:00
|
|
|
*
|
|
|
|
* This file must remain as widely compatible as the base compatibility
|
|
|
|
* for MediaWiki itself (see mediawiki/core:/resources/startup.js).
|
2017-04-06 21:02:18 +00:00
|
|
|
* Avoid use of: SVG, HTML5 DOM, ContentEditable etc.
|
2013-07-03 22:14:52 +00:00
|
|
|
*
|
2019-01-01 13:24:23 +00:00
|
|
|
* @copyright 2011-2019 VisualEditor Team and others; see AUTHORS.txt
|
2013-07-03 22:14:52 +00:00
|
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
|
|
*/
|
|
|
|
|
2019-02-20 20:23:43 +00:00
|
|
|
/* eslint-disable no-jquery/no-global-selector */
|
2019-07-22 20:33:15 +00:00
|
|
|
// TODO: ve.now and ve.track should be moved to mw.libs.ve
|
|
|
|
/* global ve */
|
2019-01-08 17:00:09 +00:00
|
|
|
|
2013-07-03 22:14:52 +00:00
|
|
|
/**
|
|
|
|
* Platform preparation for the MediaWiki view page. This loads (when user needs it) the
|
|
|
|
* actual MediaWiki integration and VisualEditor library.
|
|
|
|
*
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* @class mw.libs.ve
|
2015-07-29 13:41:30 +00:00
|
|
|
* @alternateClassName ve.init.mw.DesktopArticleTarget.init
|
2013-07-03 22:14:52 +00:00
|
|
|
* @singleton
|
|
|
|
*/
|
|
|
|
( function () {
|
2016-05-26 12:08:26 +00:00
|
|
|
var conf, tabMessages, uri, pageExists, viewUri, veEditUri, veEditSourceUri, isViewPage, isEditPage,
|
2017-04-26 17:20:58 +00:00
|
|
|
pageCanLoadEditor, init, targetPromise, enable, tempdisable, autodisable,
|
2017-09-11 15:03:18 +00:00
|
|
|
tabPreference, enabledForUser, initialWikitext, oldId,
|
2018-01-23 20:51:11 +00:00
|
|
|
isLoading, tempWikitextEditor, tempWikitextEditorData, $toolbarPlaceholder,
|
2019-04-09 19:48:25 +00:00
|
|
|
data = require( './data.json' ),
|
2019-04-10 19:41:02 +00:00
|
|
|
veactionToMode = {
|
|
|
|
edit: 'visual',
|
|
|
|
editsource: 'source'
|
2016-09-03 00:30:06 +00:00
|
|
|
},
|
2019-04-10 19:41:02 +00:00
|
|
|
availableModes = [],
|
2015-05-09 13:47:10 +00:00
|
|
|
active = false,
|
2016-07-26 03:04:47 +00:00
|
|
|
targetLoaded = false,
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
plugins = [];
|
2013-07-03 22:14:52 +00:00
|
|
|
|
2017-10-18 22:50:31 +00:00
|
|
|
function showLoading( mode ) {
|
2018-03-16 15:39:21 +00:00
|
|
|
var $content, windowHeight, clientTop, top, bottom, middle;
|
2015-08-19 18:05:01 +00:00
|
|
|
|
2016-08-23 16:27:30 +00:00
|
|
|
if ( isLoading ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
isLoading = true;
|
|
|
|
|
2016-02-10 02:27:50 +00:00
|
|
|
$( 'html' ).addClass( 've-activated ve-loading' );
|
2015-02-21 05:09:50 +00:00
|
|
|
if ( !init.$loading ) {
|
2019-02-06 01:06:10 +00:00
|
|
|
init.progressBar = new mw.libs.ve.ProgressBarWidget();
|
|
|
|
init.$loading = $( '<div>' )
|
|
|
|
.addClass( 've-init-mw-desktopArticleTarget-loading-overlay' )
|
|
|
|
.append( init.progressBar.$element );
|
2015-02-15 11:42:21 +00:00
|
|
|
}
|
2017-10-04 12:52:05 +00:00
|
|
|
// eslint-disable-next-line no-use-before-define
|
|
|
|
$( document ).on( 'keydown', onDocumentKeyDown );
|
2015-08-19 18:05:01 +00:00
|
|
|
|
|
|
|
$content = $( '#content' );
|
2017-10-18 22:50:31 +00:00
|
|
|
if ( mode !== 'source' ) {
|
|
|
|
// Center within visible part of the target
|
2018-03-16 15:39:21 +00:00
|
|
|
windowHeight = window.innerHeight;
|
|
|
|
clientTop = $content[ 0 ].offsetTop - window.pageYOffset;
|
|
|
|
top = Math.max( clientTop, 0 );
|
|
|
|
bottom = Math.min( clientTop + $content[ 0 ].offsetHeight, windowHeight );
|
2017-10-18 22:50:31 +00:00
|
|
|
middle = ( bottom - top ) / 2;
|
2018-03-16 15:39:21 +00:00
|
|
|
init.$loading.css( 'top', middle + Math.max( -clientTop, 0 ) );
|
2019-02-06 00:29:42 +00:00
|
|
|
} else {
|
|
|
|
init.$loading.css( 'top', '' );
|
2017-10-18 22:50:31 +00:00
|
|
|
}
|
2015-02-15 11:42:21 +00:00
|
|
|
|
|
|
|
$content.prepend( init.$loading );
|
|
|
|
}
|
|
|
|
|
2015-05-09 13:47:10 +00:00
|
|
|
function incrementLoadingProgress() {
|
2019-02-06 01:06:10 +00:00
|
|
|
init.progressBar.incrementLoadingProgress();
|
2015-05-09 13:47:10 +00:00
|
|
|
}
|
|
|
|
|
2017-10-04 12:52:05 +00:00
|
|
|
function clearLoading() {
|
2019-02-06 01:06:10 +00:00
|
|
|
init.progressBar.clearLoading();
|
2016-08-23 16:27:30 +00:00
|
|
|
isLoading = false;
|
2017-10-04 12:52:05 +00:00
|
|
|
// eslint-disable-next-line no-use-before-define
|
|
|
|
$( document ).off( 'keydown', onDocumentKeyDown );
|
2016-02-17 15:35:16 +00:00
|
|
|
$( 'html' ).removeClass( 've-loading' );
|
2015-02-21 05:09:50 +00:00
|
|
|
if ( init.$loading ) {
|
|
|
|
init.$loading.detach();
|
|
|
|
}
|
2017-10-18 22:50:31 +00:00
|
|
|
if ( tempWikitextEditor ) {
|
2018-01-23 20:51:11 +00:00
|
|
|
if ( ve.init && ve.init.target ) {
|
|
|
|
// eslint-disable-next-line no-use-before-define
|
|
|
|
ve.init.target.toolbarSetupDeferred.then( teardownTempWikitextEditor );
|
|
|
|
} else {
|
|
|
|
// Target didn't get created. Teardown editor anyway.
|
|
|
|
// eslint-disable-next-line no-use-before-define
|
|
|
|
teardownTempWikitextEditor();
|
|
|
|
}
|
2017-10-18 22:50:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function setupTempWikitextEditor( data ) {
|
2018-02-01 20:25:11 +00:00
|
|
|
var content = data.content;
|
|
|
|
// Add trailing linebreak to non-empty wikitext documents for consistency
|
|
|
|
// with old editor and usability. Will be stripped on save. T156609
|
|
|
|
if ( content ) {
|
|
|
|
content += '\n';
|
|
|
|
}
|
|
|
|
tempWikitextEditor = new mw.libs.ve.MWTempWikitextEditorWidget( { value: content } );
|
2018-01-23 20:51:11 +00:00
|
|
|
tempWikitextEditorData = data;
|
2017-10-18 22:50:31 +00:00
|
|
|
|
|
|
|
// Create an equal-height placeholder for the toolbar to avoid vertical jump
|
|
|
|
// when the real toolbar is ready.
|
|
|
|
$toolbarPlaceholder = $( '<div>' ).addClass( 've-init-mw-desktopArticleTarget-toolbarPlaceholder' );
|
|
|
|
$( '#content' ).prepend( $toolbarPlaceholder );
|
|
|
|
|
|
|
|
// Add class for transition after first render
|
|
|
|
setTimeout( function () {
|
|
|
|
$toolbarPlaceholder.addClass( 've-init-mw-desktopArticleTarget-toolbarPlaceholder-open' );
|
|
|
|
} );
|
|
|
|
|
|
|
|
// Bring forward some transformations that show the editor is now ready
|
|
|
|
$( '#firstHeading' ).addClass( 've-init-mw-desktopArticleTarget-uneditableContent' );
|
|
|
|
$( '#mw-content-text' )
|
|
|
|
.before( tempWikitextEditor.$element )
|
|
|
|
.addClass( 'oo-ui-element-hidden' );
|
|
|
|
$( 'html' ).addClass( 've-tempSourceEditing' ).removeClass( 've-loading' );
|
|
|
|
|
|
|
|
// Resize the textarea to fit content. We could do this more often (e.g. on change)
|
|
|
|
// but hopefully this temporary textarea won't be visible for too long.
|
2018-01-22 00:49:49 +00:00
|
|
|
tempWikitextEditor.adjustSize().moveCursorToStart();
|
2018-09-24 15:03:55 +00:00
|
|
|
ve.track( 'mwedit.ready', { mode: 'source', platform: 'desktop' } );
|
2018-01-22 18:27:43 +00:00
|
|
|
mw.libs.ve.tempWikitextEditor = tempWikitextEditor;
|
|
|
|
mw.hook( 've.wikitextInteractive' ).fire();
|
2017-10-18 22:50:31 +00:00
|
|
|
}
|
|
|
|
|
2018-01-23 20:51:11 +00:00
|
|
|
function syncTempWikitextEditor() {
|
|
|
|
var newContent = tempWikitextEditor.getValue();
|
|
|
|
|
2018-02-01 20:25:11 +00:00
|
|
|
// Strip trailing linebreak. Will get re-added in ArticleTarget#parseDocument.
|
|
|
|
if ( newContent.slice( -1 ) === '\n' ) {
|
|
|
|
newContent = newContent.slice( 0, -1 );
|
|
|
|
}
|
|
|
|
|
2018-01-23 20:51:11 +00:00
|
|
|
if ( newContent !== tempWikitextEditorData.content ) {
|
|
|
|
// Write changes back to response data object,
|
|
|
|
// which will be used to construct the surface.
|
|
|
|
tempWikitextEditorData.content = newContent;
|
|
|
|
// TODO: Consider writing changes using a
|
|
|
|
// transaction so they can be undone.
|
|
|
|
// For now, just mark surface as pre-modified
|
|
|
|
tempWikitextEditorData.fromEditedState = true;
|
|
|
|
}
|
2017-10-18 22:50:31 +00:00
|
|
|
|
2018-01-23 20:51:11 +00:00
|
|
|
// Store the last-seen selection and pass to the target
|
|
|
|
tempWikitextEditorData.initialSourceRange = tempWikitextEditor.getRange();
|
2017-10-18 22:50:31 +00:00
|
|
|
|
2018-01-23 20:51:11 +00:00
|
|
|
tempWikitextEditor.$element.prop( 'readonly', true );
|
|
|
|
}
|
|
|
|
|
|
|
|
function teardownTempWikitextEditor() {
|
2017-10-18 22:50:31 +00:00
|
|
|
// Destroy widget and placeholder
|
|
|
|
tempWikitextEditor.$element.remove();
|
2018-01-22 18:27:43 +00:00
|
|
|
mw.libs.ve.tempWikitextEditor = tempWikitextEditor = null;
|
2018-01-23 20:51:11 +00:00
|
|
|
tempWikitextEditorData = null;
|
2017-10-18 22:50:31 +00:00
|
|
|
$toolbarPlaceholder.remove();
|
|
|
|
$toolbarPlaceholder = null;
|
|
|
|
|
|
|
|
$( '#mw-content-text' ).removeClass( 'oo-ui-element-hidden' );
|
|
|
|
$( 'html' ).removeClass( 've-tempSourceEditing' );
|
2015-02-21 05:09:50 +00:00
|
|
|
}
|
|
|
|
|
2017-10-04 12:52:05 +00:00
|
|
|
function abortLoading() {
|
|
|
|
$( 'html' ).removeClass( 've-activated' );
|
|
|
|
active = false;
|
|
|
|
// Push read tab URL to history
|
|
|
|
if ( history.pushState && $( '#ca-view a' ).length ) {
|
|
|
|
history.pushState( { tag: 'visualeditor' }, document.title, new mw.Uri( $( '#ca-view a' ).attr( 'href' ) ) );
|
|
|
|
}
|
|
|
|
clearLoading();
|
|
|
|
}
|
|
|
|
|
|
|
|
function onDocumentKeyDown( e ) {
|
|
|
|
if ( e.which === 27 /* OO.ui.Keys.ESCAPE */ ) {
|
|
|
|
abortLoading();
|
|
|
|
e.preventDefault();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-08 19:19:17 +00:00
|
|
|
function parseSection( section ) {
|
|
|
|
var parsedSection = section;
|
2016-12-15 00:07:22 +00:00
|
|
|
// Section must be a number, 'new' or 'T-' prefixed
|
2019-02-13 13:21:26 +00:00
|
|
|
if ( section !== 'new' ) {
|
|
|
|
parsedSection = section.indexOf( 'T-' ) === 0 ? +section.slice( 2 ) : +section;
|
2016-12-08 19:19:17 +00:00
|
|
|
if ( isNaN( parsedSection ) ) {
|
|
|
|
parsedSection = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return parsedSection;
|
|
|
|
}
|
|
|
|
|
2013-07-03 22:14:52 +00:00
|
|
|
/**
|
|
|
|
* Use deferreds to avoid loading and instantiating Target multiple times.
|
2015-08-19 18:21:01 +00:00
|
|
|
*
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* @private
|
2016-05-26 12:08:26 +00:00
|
|
|
* @param {string} mode Target mode: 'visual' or 'source'
|
2019-04-16 15:17:29 +00:00
|
|
|
* @param {number|string} section Section to edit
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* @return {jQuery.Promise}
|
2013-07-03 22:14:52 +00:00
|
|
|
*/
|
2016-12-08 19:19:17 +00:00
|
|
|
function getTarget( mode, section ) {
|
2014-09-07 22:47:58 +00:00
|
|
|
if ( !targetPromise ) {
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
// The TargetLoader module is loaded in the bottom queue, so it should have been
|
|
|
|
// requested already but it might not have finished loading yet
|
|
|
|
targetPromise = mw.loader.using( 'ext.visualEditor.targetLoader' )
|
|
|
|
.then( function () {
|
2015-04-03 20:38:39 +00:00
|
|
|
mw.libs.ve.targetLoader.addPlugin( function () {
|
2017-02-01 17:00:07 +00:00
|
|
|
// Run VisualEditorPreloadModules, but if they fail, we still want to continue
|
2015-04-03 20:38:39 +00:00
|
|
|
// loading, so convert failure to success
|
2018-01-23 23:24:25 +00:00
|
|
|
return mw.loader.using( conf.preloadModules ).catch(
|
2015-04-03 20:38:39 +00:00
|
|
|
function () {
|
|
|
|
return $.Deferred().resolve();
|
|
|
|
}
|
|
|
|
);
|
|
|
|
} );
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
// Add modules specific to desktop (modules shared between desktop
|
|
|
|
// and mobile are already added by TargetLoader)
|
2017-02-27 16:13:56 +00:00
|
|
|
[ 'ext.visualEditor.desktopArticleTarget' ]
|
|
|
|
// Add requested plugins
|
|
|
|
.concat( plugins )
|
|
|
|
.forEach( mw.libs.ve.targetLoader.addPlugin );
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
plugins = [];
|
2017-12-07 11:14:00 +00:00
|
|
|
return mw.libs.ve.targetLoader.loadModules( mode );
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
} )
|
2014-09-07 22:47:58 +00:00
|
|
|
.then( function () {
|
2019-04-10 19:41:02 +00:00
|
|
|
var target;
|
2016-10-27 22:29:38 +00:00
|
|
|
|
2017-10-04 12:52:05 +00:00
|
|
|
if ( !active ) {
|
|
|
|
// Loading was aborted
|
|
|
|
// TODO: Make loaders abortable instead of waiting
|
|
|
|
targetPromise = null;
|
|
|
|
return $.Deferred().reject().promise();
|
|
|
|
}
|
|
|
|
|
2016-06-24 15:04:32 +00:00
|
|
|
target = ve.init.mw.targetFactory.create(
|
2016-10-27 22:29:38 +00:00
|
|
|
conf.contentModels[ mw.config.get( 'wgPageContentModel' ) ], {
|
2019-04-10 19:41:02 +00:00
|
|
|
modes: availableModes,
|
2017-01-19 13:27:30 +00:00
|
|
|
defaultMode: mode
|
2016-10-27 22:29:38 +00:00
|
|
|
}
|
2016-06-24 15:04:32 +00:00
|
|
|
);
|
2016-05-09 22:28:24 +00:00
|
|
|
target.setContainer( $( '#content' ) );
|
2016-07-26 03:04:47 +00:00
|
|
|
targetLoaded = true;
|
2014-09-07 22:47:58 +00:00
|
|
|
return target;
|
2014-08-20 01:53:01 +00:00
|
|
|
}, function ( e ) {
|
2014-12-03 23:35:48 +00:00
|
|
|
mw.log.warn( 'VisualEditor failed to load: ' + e );
|
2014-09-07 22:47:58 +00:00
|
|
|
} );
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
2015-03-31 19:52:14 +00:00
|
|
|
|
2016-12-08 19:19:17 +00:00
|
|
|
targetPromise.then( function ( target ) {
|
|
|
|
target.section = section;
|
2015-03-31 19:52:14 +00:00
|
|
|
} );
|
|
|
|
|
2014-09-07 22:47:58 +00:00
|
|
|
return targetPromise;
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
|
|
|
|
2016-10-28 00:22:30 +00:00
|
|
|
function trackActivateStart( initData ) {
|
2017-12-07 11:14:00 +00:00
|
|
|
ve.track( 'trace.activate.enter', { mode: initData.mode } );
|
2018-08-28 14:50:11 +00:00
|
|
|
// ve.track normally tries to guess the current platform based on
|
|
|
|
// ve.init.target. We're in a pre-target-loaded state, so have it
|
|
|
|
// hardcode desktop here.
|
|
|
|
initData.platform = 'desktop';
|
2016-10-28 00:22:30 +00:00
|
|
|
ve.track( 'mwedit.init', initData );
|
|
|
|
mw.libs.ve.activationStart = ve.now();
|
|
|
|
}
|
2015-10-14 23:34:34 +00:00
|
|
|
|
2019-05-13 21:51:30 +00:00
|
|
|
function getTabMessage( key ) {
|
2019-11-01 16:20:22 +00:00
|
|
|
var tabMsgKey = tabMessages[ key ];
|
|
|
|
if ( !tabMsgKey && ( key === 'edit' || key === 'create' ) ) {
|
2019-05-13 21:51:30 +00:00
|
|
|
// Some skins don't use the default 'edit' and 'create' message keys.
|
|
|
|
// e.g. vector-view-edit, vector-view-create
|
2019-11-01 16:20:22 +00:00
|
|
|
tabMsgKey = mw.config.get( 'skin' ) + '-view-' + key;
|
|
|
|
// The following messages can be used here:
|
|
|
|
// * vector-view-edit
|
|
|
|
// * vector-view-create
|
|
|
|
// * messages for other skins
|
|
|
|
if ( !mw.message( tabMsgKey ).exists() ) {
|
|
|
|
tabMsgKey = key;
|
2019-05-13 21:51:30 +00:00
|
|
|
}
|
|
|
|
}
|
2019-11-01 16:20:22 +00:00
|
|
|
return mw.msg( tabMsgKey );
|
2019-05-13 21:51:30 +00:00
|
|
|
}
|
|
|
|
|
2016-10-28 00:22:30 +00:00
|
|
|
function setEditorPreference( editor ) {
|
|
|
|
var key = pageExists ? 'edit' : 'create',
|
2019-05-13 21:51:30 +00:00
|
|
|
sectionKey = 'editsection';
|
2015-10-23 16:29:56 +00:00
|
|
|
|
2016-10-28 00:22:30 +00:00
|
|
|
if ( editor !== 'visualeditor' && editor !== 'wikitext' ) {
|
|
|
|
throw new Error( 'setEditorPreference called with invalid option: ', editor );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (
|
|
|
|
mw.config.get( 'wgVisualEditorConfig' ).singleEditTab &&
|
|
|
|
tabPreference === 'remember-last'
|
|
|
|
) {
|
|
|
|
if ( $( '#ca-view-foreign' ).length ) {
|
|
|
|
key += 'localdescription';
|
|
|
|
}
|
|
|
|
if ( editor === 'wikitext' ) {
|
|
|
|
key += 'source';
|
|
|
|
sectionKey += 'source';
|
2015-10-23 16:29:56 +00:00
|
|
|
}
|
2015-10-14 23:34:34 +00:00
|
|
|
|
2019-11-01 16:20:22 +00:00
|
|
|
$( '#ca-edit a' ).text( getTabMessage( key ) );
|
|
|
|
$( '.mw-editsection a' ).text( getTabMessage( sectionKey ) );
|
2016-10-28 00:22:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
$.cookie( 'VEE', editor, { path: '/', expires: 30 } );
|
|
|
|
if ( mw.user.isAnon() ) {
|
2018-09-04 12:45:00 +00:00
|
|
|
return $.Deferred().resolve().promise();
|
2016-10-28 00:22:30 +00:00
|
|
|
}
|
|
|
|
if ( mw.user.options.get( 'visualeditor-editor' ) === editor ) {
|
2018-09-04 12:45:00 +00:00
|
|
|
return $.Deferred().resolve().promise();
|
2015-10-14 23:34:34 +00:00
|
|
|
}
|
2018-05-07 20:21:13 +00:00
|
|
|
// Same as ve.init.target.getLocalApi()
|
|
|
|
return new mw.Api().saveOption( 'visualeditor-editor', editor ).then( function () {
|
2016-10-28 00:22:30 +00:00
|
|
|
mw.user.options.set( 'visualeditor-editor', editor );
|
|
|
|
} );
|
2015-10-14 23:34:34 +00:00
|
|
|
}
|
2015-12-12 00:51:32 +00:00
|
|
|
|
2015-02-21 05:09:50 +00:00
|
|
|
/**
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* Load and activate the target.
|
|
|
|
*
|
|
|
|
* If you need to call methods on the target before activate is called, call getTarget()
|
|
|
|
* yourself, chain your work onto that promise, and pass that chained promise in as targetPromise.
|
|
|
|
* E.g. `activateTarget( getTarget().then( function( target ) { target.doAThing(); } ) );`
|
2015-02-21 05:09:50 +00:00
|
|
|
*
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* @private
|
2016-05-26 12:08:26 +00:00
|
|
|
* @param {string} mode Target mode: 'visual' or 'source'
|
2016-12-08 19:24:10 +00:00
|
|
|
* @param {number|string} [section] Section to edit (currently just source mode)
|
2015-12-10 16:07:50 +00:00
|
|
|
* @param {jQuery.Promise} [targetPromise] Promise that will be resolved with a ve.init.mw.DesktopArticleTarget
|
2015-11-10 17:50:19 +00:00
|
|
|
* @param {boolean} [modified] The page was been modified before loading (e.g. in source mode)
|
2015-02-21 05:09:50 +00:00
|
|
|
*/
|
2016-09-06 19:16:55 +00:00
|
|
|
function activateTarget( mode, section, targetPromise, modified ) {
|
2016-07-26 03:04:47 +00:00
|
|
|
var dataPromise;
|
|
|
|
// Only call requestPageData early if the target object isn't there yet.
|
|
|
|
// If the target object is there, this is a second or subsequent load, and the
|
|
|
|
// internal state of the target object can influence the load request.
|
|
|
|
if ( !targetLoaded ) {
|
|
|
|
// The TargetLoader module is loaded in the bottom queue, so it should have been
|
|
|
|
// requested already but it might not have finished loading yet
|
|
|
|
dataPromise = mw.loader.using( 'ext.visualEditor.targetLoader' )
|
|
|
|
.then( function () {
|
2017-09-11 14:53:50 +00:00
|
|
|
return mw.libs.ve.targetLoader.requestPageData( mode, mw.config.get( 'wgRelevantPageName' ), {
|
2018-02-21 22:58:50 +00:00
|
|
|
sessionStore: true,
|
2017-09-11 14:53:50 +00:00
|
|
|
section: section,
|
2017-09-11 15:03:18 +00:00
|
|
|
oldId: oldId,
|
2017-10-02 20:29:58 +00:00
|
|
|
// Should be ve.init.mw.DesktopArticleTarget.static.trackingName, but the
|
|
|
|
// class hasn't loaded yet.
|
|
|
|
// This is used for stats tracking, so do not change!
|
|
|
|
targetName: 'mwTarget',
|
2017-09-11 14:53:50 +00:00
|
|
|
modified: modified,
|
2017-09-14 20:08:09 +00:00
|
|
|
preload: uri.query.preload,
|
2019-08-26 18:21:29 +00:00
|
|
|
preloadparams: uri.query.preloadparams,
|
2018-01-14 16:16:47 +00:00
|
|
|
// If switching to visual with modifications, check if we have wikitext to convert
|
|
|
|
wikitext: mode === 'visual' && modified ? $( '#wpTextbox1' ).textSelection( 'getContents' ) : undefined
|
2017-09-11 14:53:50 +00:00
|
|
|
} );
|
2018-02-21 22:58:50 +00:00
|
|
|
} );
|
|
|
|
|
|
|
|
dataPromise
|
|
|
|
.then( function ( response ) {
|
|
|
|
if (
|
|
|
|
// Check target promise hasn't already failed (isLoading=false)
|
|
|
|
isLoading &&
|
|
|
|
// TODO: Support tempWikitextEditor when section=new (T185633)
|
|
|
|
mode === 'source' && section !== 'new' &&
|
|
|
|
// Can't use temp editor when recovering an autosave
|
|
|
|
!( response.visualeditor && response.visualeditor.recovered )
|
|
|
|
) {
|
2017-10-18 22:50:31 +00:00
|
|
|
setupTempWikitextEditor( response.visualeditor );
|
|
|
|
}
|
|
|
|
} )
|
2018-02-21 22:58:50 +00:00
|
|
|
.then( incrementLoadingProgress );
|
2016-07-26 03:04:47 +00:00
|
|
|
}
|
2015-03-16 16:07:14 +00:00
|
|
|
|
2017-10-18 22:50:31 +00:00
|
|
|
showLoading( mode );
|
2015-05-09 13:47:10 +00:00
|
|
|
incrementLoadingProgress();
|
|
|
|
active = true;
|
2015-03-16 16:07:14 +00:00
|
|
|
|
2016-12-08 19:19:17 +00:00
|
|
|
targetPromise = targetPromise || getTarget( mode, section );
|
2015-03-13 15:50:23 +00:00
|
|
|
targetPromise
|
2015-02-21 05:09:50 +00:00
|
|
|
.then( function ( target ) {
|
2016-06-01 13:52:57 +00:00
|
|
|
var activatePromise;
|
2015-05-09 13:47:10 +00:00
|
|
|
incrementLoadingProgress();
|
|
|
|
target.on( 'deactivate', function () {
|
|
|
|
active = false;
|
|
|
|
} );
|
2016-06-01 13:52:57 +00:00
|
|
|
// Detach the loading bar for activation so it doesn't get moved around
|
|
|
|
// and altered, re-attach immediately after
|
|
|
|
init.$loading.detach();
|
2016-11-12 16:11:59 +00:00
|
|
|
// If target was already loaded, ensure the mode is correct
|
2016-11-30 12:03:56 +00:00
|
|
|
target.setDefaultMode( mode );
|
2018-01-23 20:51:11 +00:00
|
|
|
if ( tempWikitextEditor ) {
|
|
|
|
syncTempWikitextEditor();
|
|
|
|
}
|
2016-06-01 13:52:57 +00:00
|
|
|
activatePromise = target.activate( dataPromise );
|
|
|
|
$( '#content' ).prepend( init.$loading );
|
|
|
|
return activatePromise;
|
2015-02-21 05:09:50 +00:00
|
|
|
} )
|
|
|
|
.then( function () {
|
2017-10-18 22:50:31 +00:00
|
|
|
if ( mode === 'visual' ) {
|
|
|
|
// 'mwedit.ready' has already been fired for source mode in setupTempWikitextEditor
|
|
|
|
ve.track( 'mwedit.ready', { mode: mode } );
|
2018-01-22 18:27:43 +00:00
|
|
|
} else if ( !tempWikitextEditor ) {
|
2018-05-02 16:34:48 +00:00
|
|
|
// We're in source mode, but skipped the
|
|
|
|
// tempWikitextEditor, so make sure we do relevant
|
|
|
|
// tracking / hooks:
|
|
|
|
ve.track( 'mwedit.ready', { mode: mode } );
|
2018-01-22 18:27:43 +00:00
|
|
|
mw.hook( 've.wikitextInteractive' ).fire();
|
2017-10-18 22:50:31 +00:00
|
|
|
}
|
2017-12-07 11:14:00 +00:00
|
|
|
ve.track( 'mwedit.loaded', { mode: mode } );
|
2015-02-21 05:09:50 +00:00
|
|
|
} )
|
2017-10-04 12:52:05 +00:00
|
|
|
.always( clearLoading );
|
2015-02-21 05:09:50 +00:00
|
|
|
}
|
|
|
|
|
2019-04-05 13:51:14 +00:00
|
|
|
function activatePageTarget( mode, section, modified ) {
|
2017-12-07 11:14:00 +00:00
|
|
|
trackActivateStart( { type: 'page', mechanism: 'click', mode: mode } );
|
2016-06-30 01:11:13 +00:00
|
|
|
|
2016-10-28 00:22:30 +00:00
|
|
|
if ( !active ) {
|
2019-04-10 19:41:02 +00:00
|
|
|
if ( uri.query.action !== 'edit' && !( uri.query.veaction in veactionToMode ) ) {
|
2016-10-28 00:22:30 +00:00
|
|
|
if ( history.pushState ) {
|
|
|
|
// Replace the current state with one that is tagged as ours, to prevent the
|
|
|
|
// back button from breaking when used to exit VE. FIXME: there should be a better
|
|
|
|
// way to do this. See also similar code in the DesktopArticleTarget constructor.
|
|
|
|
history.replaceState( { tag: 'visualeditor' }, document.title, uri );
|
|
|
|
// Set veaction to edit
|
|
|
|
history.pushState( { tag: 'visualeditor' }, document.title, mode === 'source' ? veEditSourceUri : veEditUri );
|
|
|
|
}
|
2015-12-12 00:51:32 +00:00
|
|
|
|
2016-10-28 00:22:30 +00:00
|
|
|
// Update mw.Uri instance
|
|
|
|
uri = veEditUri;
|
2016-06-30 01:11:13 +00:00
|
|
|
}
|
|
|
|
|
2019-04-05 13:51:14 +00:00
|
|
|
activateTarget( mode, section, undefined, modified );
|
2016-03-08 23:12:39 +00:00
|
|
|
}
|
2015-12-12 00:51:32 +00:00
|
|
|
}
|
|
|
|
|
2015-10-23 16:29:56 +00:00
|
|
|
function getLastEditor() {
|
2017-04-27 15:23:26 +00:00
|
|
|
// This logic matches VisualEditorHooks::getLastEditor
|
2015-10-23 16:29:56 +00:00
|
|
|
var editor = $.cookie( 'VEE' );
|
2016-11-08 14:14:47 +00:00
|
|
|
// Set editor to user's preference or site's default if …
|
2016-03-07 19:27:23 +00:00
|
|
|
if (
|
|
|
|
// … user is logged in,
|
|
|
|
!mw.user.isAnon() ||
|
|
|
|
// … no cookie is set, or
|
|
|
|
!editor ||
|
|
|
|
// value is invalid.
|
|
|
|
!( editor === 'visualeditor' || editor === 'wikitext' )
|
|
|
|
) {
|
2015-10-23 16:29:56 +00:00
|
|
|
editor = mw.user.options.get( 'visualeditor-editor' );
|
|
|
|
}
|
|
|
|
return editor;
|
|
|
|
}
|
|
|
|
|
2016-12-29 20:08:53 +00:00
|
|
|
function getPreferredEditor() {
|
2019-05-19 12:54:32 +00:00
|
|
|
// This logic matches VisualEditorHooks::getPreferredEditor
|
|
|
|
// !!+ casts '0' to false
|
|
|
|
var isRedLink = !!+uri.query.redlink;
|
|
|
|
// On dual-edit-tab wikis, the edit page must mean the user wants wikitext,
|
|
|
|
// unless following a redlink
|
|
|
|
if ( !mw.config.get( 'wgVisualEditorConfig' ).singleEditTab && !isRedLink ) {
|
2017-05-15 11:33:40 +00:00
|
|
|
return 'wikitext';
|
|
|
|
}
|
|
|
|
|
2016-12-29 20:08:53 +00:00
|
|
|
switch ( tabPreference ) {
|
|
|
|
case 'prefer-ve':
|
|
|
|
return 'visualeditor';
|
|
|
|
case 'prefer-wt':
|
|
|
|
return 'wikitext';
|
2019-05-19 12:54:32 +00:00
|
|
|
case 'remember-last':
|
|
|
|
return getLastEditor();
|
2017-04-27 15:23:26 +00:00
|
|
|
case 'multi-tab':
|
|
|
|
// 'multi-tab'
|
|
|
|
// TODO: See VisualEditor.hooks.php
|
2019-05-19 12:54:32 +00:00
|
|
|
return isRedLink ?
|
|
|
|
getLastEditor() :
|
|
|
|
'wikitext';
|
2016-12-29 20:08:53 +00:00
|
|
|
}
|
2017-04-27 15:23:26 +00:00
|
|
|
return null;
|
2016-12-29 20:08:53 +00:00
|
|
|
}
|
|
|
|
|
2013-07-03 22:14:52 +00:00
|
|
|
conf = mw.config.get( 'wgVisualEditorConfig' );
|
2013-08-02 20:25:44 +00:00
|
|
|
tabMessages = conf.tabMessages;
|
2019-08-26 18:21:29 +00:00
|
|
|
uri = new mw.Uri( null, { arrayParams: true } );
|
2017-03-23 21:32:00 +00:00
|
|
|
// T156998: Don't trust uri.query.oldid, it'll be wrong if uri.query.diff or uri.query.direction
|
|
|
|
// is set to 'next' or 'prev'.
|
2017-09-11 15:03:18 +00:00
|
|
|
oldId = mw.config.get( 'wgRevisionId' ) || $( 'input[name=parentRevId]' ).val();
|
2018-05-01 00:09:28 +00:00
|
|
|
// wgFlaggedRevsEditLatestRevision is set by FlaggedRevs extension when viewing a stable revision
|
|
|
|
if ( oldId === mw.config.get( 'wgCurRevisionId' ) || mw.config.get( 'wgFlaggedRevsEditLatestRevision' ) ) {
|
|
|
|
// The page may have been edited by someone else after we loaded it, setting this to "undefined"
|
|
|
|
// indicates that we should load the actual latest revision.
|
2017-09-11 15:03:18 +00:00
|
|
|
oldId = undefined;
|
2017-04-07 10:49:30 +00:00
|
|
|
}
|
2014-11-19 22:40:41 +00:00
|
|
|
pageExists = !!mw.config.get( 'wgRelevantArticleId' );
|
2013-11-07 22:21:08 +00:00
|
|
|
viewUri = new mw.Uri( mw.util.getUrl( mw.config.get( 'wgRelevantPageName' ) ) );
|
2015-11-20 01:47:22 +00:00
|
|
|
isViewPage = mw.config.get( 'wgIsArticle' ) && !( 'diff' in uri.query );
|
2018-11-02 16:54:01 +00:00
|
|
|
isEditPage = mw.config.get( 'wgAction' ) === 'edit' || mw.config.get( 'wgAction' ) === 'submit';
|
|
|
|
pageCanLoadEditor = isViewPage || isEditPage;
|
2013-07-03 22:14:52 +00:00
|
|
|
|
2017-10-16 17:02:00 +00:00
|
|
|
// Cast "0" (T89513)
|
|
|
|
enable = !!+mw.user.options.get( 'visualeditor-enable' );
|
|
|
|
tempdisable = !!+mw.user.options.get( 'visualeditor-betatempdisable' );
|
|
|
|
autodisable = !!+mw.user.options.get( 'visualeditor-autodisable' );
|
|
|
|
tabPreference = mw.user.options.get( 'visualeditor-tabs' );
|
|
|
|
|
|
|
|
function isOnlyTabVE() {
|
|
|
|
return conf.singleEditTab && getPreferredEditor() === 'visualeditor';
|
|
|
|
}
|
|
|
|
|
|
|
|
function isOnlyTabWikitext() {
|
|
|
|
return conf.singleEditTab && getPreferredEditor() === 'wikitext';
|
|
|
|
}
|
|
|
|
|
2013-07-03 22:14:52 +00:00
|
|
|
init = {
|
2013-10-10 12:33:49 +00:00
|
|
|
blacklist: conf.blacklist,
|
2013-07-03 22:14:52 +00:00
|
|
|
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
/**
|
|
|
|
* Add a plugin module or function.
|
|
|
|
*
|
|
|
|
* Plugins are run after VisualEditor is loaded, but before it is initialized. This allows
|
|
|
|
* plugins to add classes and register them with the factories and registries.
|
|
|
|
*
|
|
|
|
* The parameter to this function can be a ResourceLoader module name or a function.
|
|
|
|
*
|
|
|
|
* If it's a module name, it will be loaded together with the VisualEditor core modules when
|
|
|
|
* VE is loaded. No special care is taken to ensure that the module runs after the VE
|
|
|
|
* classes are loaded, so if this is desired, the module should depend on
|
|
|
|
* ext.visualEditor.core .
|
|
|
|
*
|
|
|
|
* If it's a function, it will be invoked once the VisualEditor core modules and any
|
|
|
|
* plugin modules registered through this function have been loaded, but before the editor
|
Load RL modules in one load.php request, rather than in two stages
This introduces TargetLoader, which manages plugins and RL modules
in a slightly more generic fashion so that Targets themselves don't
have to. This allows us to load all RL modules in one load.php
request, rather than first loading ViewPageTarget which then
loads the other modules.
TargetLoader loads in the bottom queue, so it will be loaded
as part of the main load.php request, but in VPT.init.js we
still have to wait for it with using() because it might not
have arrived yet. This also degrades gracefully on cached pages
where TargetLoader isn't in the bottom queue: it'll be loaded
as a separate request instead, which is suboptimal but no
worse that what we were doing before.
Right now TargetLoader is small enough that it could also be in
the top queue, but in the future we want to add things like
the action=visualeditor API request to it, and mw.Api is
relatively big.
Note: this also makes a breaking change to the plugin API:
plugin callbacks no longer receive the target instance
as a parameter, as they're now executed before the target
has been constructed rather than after. In the long term,
if we want to give plugins access to the target instance,
we could give them the target promise somehow. For now,
I've killed this feature because nothing used it and
the change from a direct object reference to a promise
would have been a breaking change anyway.
Also fixed incorrect documentation index for ve.init.mw.ViewPageTarget.init.
Bug: T53569
Change-Id: Ibfa6abbeaf872ae2aadc6ed9d5beba7473ea441a
2015-02-26 01:22:44 +00:00
|
|
|
* is intialized. The function can optionally return a jQuery.Promise . VisualEditor will
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
* only be initialized once all promises returned by plugin functions have been resolved.
|
|
|
|
*
|
|
|
|
* // Register ResourceLoader module
|
2014-12-01 19:59:53 +00:00
|
|
|
* mw.libs.ve.addPlugin( 'ext.gadget.foobar' );
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
*
|
|
|
|
* // Register a callback
|
2014-12-01 19:59:53 +00:00
|
|
|
* mw.libs.ve.addPlugin( function ( target ) {
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
* ve.dm.Foobar = .....
|
|
|
|
* } );
|
|
|
|
*
|
|
|
|
* // Register a callback that loads another script
|
2014-12-01 19:59:53 +00:00
|
|
|
* mw.libs.ve.addPlugin( function () {
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
* return $.getScript( 'http://example.com/foobar.js' );
|
|
|
|
* } );
|
|
|
|
*
|
|
|
|
* @param {string|Function} plugin Module name or callback that optionally returns a promise
|
|
|
|
*/
|
2013-12-06 02:34:44 +00:00
|
|
|
addPlugin: function ( plugin ) {
|
Infrastructure for loading plugins in the MW integration
Server-side, plugins can register themselves by adding to
$wgVisualEditorPluginModules. This is the recommended way for
MW extensions to extend VE. Client-side, plugins can register
themselves through mw.libs.ve.addPlugin(), which takes a string
(RL module name) or a callback.
When VisualEditor loads, we load the registered plugin modules in
parallel with ext.visualEditor.core. Note that they're loaded in
parallel, not after, and so the plugins should explicitly depend
on ext.visualEditor.core if they use or extend classes in VE core.
Once the modules finish loading and user and site scripts have run,
we execute the registered plugin callbacks. These callbacks can
optionally return a promise. We gather these promises and wait for
all of them to be resolved, then initialize the editor.
This allows Gadgets to extend VE by top-loading a small module that
depends on ext.visualEditor.viewPageTarget.init and calls
mw.libs.ve.addPlugin( 'ext.gadget.bottomHalfGadget' ); , the bottom
half being a hidden Gadget that depends on ext.visualEditor.core and
contains the actual code. The addPlugin() call needs to be in a
top-loading module because otherwise there's no guarantee that the
plugin will be registered before the user clicks edit and VE loads.
User and site scripts can extend VE by simply calling addPlugin()
directly, as mw.libs.ve is already present when user scripts run (since
it's top-loaded) and VE waits for 'user' and 'site' to run before
executing plugins.
If user/site scripts need to load additional JS files, they can load
these with $.getScript() and return the corresponding promise:
mw.libs.ve.addPlugin( function() { return $.getScript( 'URL' ); } );
For a diagram of all this, see
https://www.mediawiki.org/wiki/File:VE-plugin-infrastructure.jpg :)
VisualEditor.php:
* Add $wgVisualEditorPluginModules
VisualEditor.hooks.php:
* Expose $wgVisualEditorPluginModules in JS
ve.init.mw.ViewPageTarget.init.js:
* Add mw.libs.ve.addPlugin function that just stores the registered
values in an array and passes them into the mw.Target when it's
being initialized
ve.init.mw.Target.js:
* Add $wgVisualEditorPluginModules to the set of modules to load when
initializing VE
* Add a Deferred (this.modulesReady) to track module loading
* Add addPlugin() and addPlugins() methods that add to either
this.modules or this.pluginCallbacks
* In load(), instead of mw.loader.load()ing this.modules, use using()
to load this.modules plus user and site, and fire onModulesReady()
when they're loaded
* In onModulesReady(), execute the registered callbacks, gather the
returned promises, wait for all of them to be resolved, then resolve
this.modulesReady
* Fire onReady based on this.modulesReady being resolved, rather than
using a second using() call
Bug: 50514
Change-Id: Ib7d87a17eaac6ecdb8b0803b13840d7ee58902df
2013-07-22 20:34:28 +00:00
|
|
|
plugins.push( plugin );
|
|
|
|
},
|
|
|
|
|
2017-10-16 17:02:00 +00:00
|
|
|
/**
|
|
|
|
* Adjust edit page links in the current document
|
|
|
|
*
|
|
|
|
* This will run multiple times in a page lifecycle, notably when the
|
|
|
|
* page first loads and after post-save content replacement occurs. It
|
|
|
|
* needs to avoid doing anything which will cause problems if it's run
|
|
|
|
* twice or more.
|
|
|
|
*/
|
|
|
|
setupEditLinks: function () {
|
|
|
|
// NWE
|
|
|
|
if ( init.isWikitextAvailable && !isOnlyTabVE() ) {
|
|
|
|
$(
|
|
|
|
// Edit section links, except VE ones when both editors visible
|
|
|
|
'.mw-editsection a:not( .mw-editsection-visualeditor ),' +
|
|
|
|
// Edit tab
|
|
|
|
'#ca-edit a,' +
|
|
|
|
// Add section is currently a wikitext-only feature
|
|
|
|
'#ca-addsection a'
|
|
|
|
).each( function () {
|
|
|
|
var uri = new mw.Uri( this.href );
|
|
|
|
if ( 'action' in uri.query ) {
|
|
|
|
delete uri.query.action;
|
|
|
|
uri.query.veaction = 'editsource';
|
|
|
|
$( this ).attr( 'href', uri.toString() );
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the tabs appropriately if the user has VE on
|
|
|
|
if ( init.isAvailable && enabledForUser ) {
|
|
|
|
// … on two-edit-tab wikis, or single-edit-tab wikis, where the user wants both …
|
|
|
|
if ( !init.isSingleEditTab ) {
|
|
|
|
// … set the skin up with both tabs and both section edit links.
|
|
|
|
init.setupMultiTabSkin();
|
|
|
|
} else if (
|
|
|
|
pageCanLoadEditor && (
|
|
|
|
( init.isVisualAvailable && isOnlyTabVE() ) ||
|
|
|
|
( init.isWikitextAvailable && isOnlyTabWikitext() )
|
|
|
|
)
|
|
|
|
) {
|
|
|
|
// … on single-edit-tab wikis, where VE is the user's preferred editor
|
|
|
|
// Handle section edit link clicks
|
|
|
|
$( '.mw-editsection a' ).off( '.ve-target' ).on( 'click.ve-target', function ( e ) {
|
|
|
|
// isOnlyTabVE is computed on click as it may have changed since load
|
|
|
|
init.onEditSectionLinkClick( isOnlyTabVE() ? 'visual' : 'source', e );
|
|
|
|
} );
|
|
|
|
// Allow instant switching to edit mode, without refresh
|
|
|
|
$( '#ca-edit' ).off( '.ve-target' ).on( 'click.ve-target', function ( e ) {
|
|
|
|
init.onEditTabClick( isOnlyTabVE() ? 'visual' : 'source', e );
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2016-11-08 12:47:30 +00:00
|
|
|
setupMultiTabSkin: function () {
|
|
|
|
init.setupMultiTabs();
|
|
|
|
init.setupMultiSectionLinks();
|
2013-07-05 06:01:31 +00:00
|
|
|
},
|
|
|
|
|
2016-11-08 12:47:30 +00:00
|
|
|
setupMultiTabs: function () {
|
2013-08-01 19:14:41 +00:00
|
|
|
var caVeEdit,
|
2013-07-03 22:14:52 +00:00
|
|
|
action = pageExists ? 'edit' : 'create',
|
2018-10-26 21:45:42 +00:00
|
|
|
isMinerva = mw.config.get( 'skin' ) === 'minerva',
|
|
|
|
// HACK: Minerva doesn't have a normal tabs container, this only kind of works
|
2019-08-30 20:46:09 +00:00
|
|
|
pTabsId = isMinerva ? 'content' :
|
2018-10-26 21:45:42 +00:00
|
|
|
$( '#p-views' ).length ? 'p-views' : 'p-cactions',
|
2019-03-26 19:54:04 +00:00
|
|
|
// Minerva puts the '#ca-...' ids on <a> nodes
|
|
|
|
$caSource = $( 'li#ca-viewsource' ),
|
|
|
|
$caEdit = $( 'li#ca-edit, li#page-actions-edit' ),
|
|
|
|
$caVeEdit = $( 'li#ca-ve-edit' ),
|
2013-07-03 22:14:52 +00:00
|
|
|
$caEditLink = $caEdit.find( 'a' ),
|
2013-08-01 19:14:41 +00:00
|
|
|
$caVeEditLink = $caVeEdit.find( 'a' ),
|
2015-08-19 18:05:01 +00:00
|
|
|
caVeEditNextnode =
|
2017-09-28 05:34:33 +00:00
|
|
|
( conf.tabPosition === 'before' ) ?
|
2015-08-19 18:05:01 +00:00
|
|
|
$caEdit.get( 0 ) :
|
|
|
|
$caEdit.next().get( 0 );
|
|
|
|
|
2013-08-01 19:14:41 +00:00
|
|
|
if ( !$caVeEdit.length ) {
|
|
|
|
// The below duplicates the functionality of VisualEditorHooks::onSkinTemplateNavigation()
|
|
|
|
// in case we're running on a cached page that doesn't have these tabs yet.
|
2013-07-03 22:14:52 +00:00
|
|
|
|
|
|
|
// If there is no edit tab or a view-source tab,
|
|
|
|
// the user doesn't have permission to edit.
|
2013-08-01 19:14:41 +00:00
|
|
|
if ( $caEdit.length && !$caSource.length ) {
|
|
|
|
// Add the VisualEditor tab (#ca-ve-edit)
|
|
|
|
caVeEdit = mw.util.addPortletLink(
|
|
|
|
pTabsId,
|
|
|
|
// Use url instead of '#'.
|
|
|
|
// So that 1) one can always open it in a new tab, even when
|
|
|
|
// onEditTabClick is bound.
|
2016-11-02 12:12:33 +00:00
|
|
|
// 2) when onEditTabClick is not bound (!pageCanLoadEditor) it will
|
2013-08-01 19:14:41 +00:00
|
|
|
// just work.
|
|
|
|
veEditUri,
|
2019-11-01 16:20:22 +00:00
|
|
|
getTabMessage( action ),
|
2013-08-01 19:14:41 +00:00
|
|
|
'ca-ve-edit',
|
|
|
|
mw.msg( 'tooltip-ca-ve-edit' ),
|
|
|
|
mw.msg( 'accesskey-ca-ve-edit' ),
|
|
|
|
caVeEditNextnode
|
|
|
|
);
|
|
|
|
|
|
|
|
$caVeEdit = $( caVeEdit );
|
2019-03-26 19:54:04 +00:00
|
|
|
$caVeEditLink = $caVeEdit.find( 'a' );
|
2019-08-30 20:46:09 +00:00
|
|
|
// HACK: Copy the 'class' attribute, otherwise the link has no icon on Minerva
|
2018-10-26 21:45:42 +00:00
|
|
|
if ( isMinerva ) {
|
|
|
|
$caVeEdit.attr( 'class', $caEdit.attr( 'class' ) );
|
2019-03-26 19:54:04 +00:00
|
|
|
$caVeEditLink.attr( 'class', $caEditLink.attr( 'class' ) );
|
2018-10-26 21:45:42 +00:00
|
|
|
}
|
2013-08-01 19:14:41 +00:00
|
|
|
}
|
2014-03-18 05:25:08 +00:00
|
|
|
} else if ( $caEdit.length && $caVeEdit.length ) {
|
2013-08-01 19:14:41 +00:00
|
|
|
// Make the state of the page consistent with the config if needed
|
2017-09-28 05:34:33 +00:00
|
|
|
if ( conf.tabPosition === 'before' ) {
|
2017-09-28 13:54:55 +00:00
|
|
|
if ( $caEdit.next()[ 0 ] === $caVeEdit[ 0 ] ) {
|
2013-08-01 19:14:41 +00:00
|
|
|
$caVeEdit.after( $caEdit );
|
|
|
|
}
|
|
|
|
} else {
|
2017-09-28 13:54:55 +00:00
|
|
|
if ( $caVeEdit.next()[ 0 ] === $caEdit[ 0 ] ) {
|
2013-08-01 19:14:41 +00:00
|
|
|
$caEdit.after( $caVeEdit );
|
|
|
|
}
|
|
|
|
}
|
2019-11-01 16:20:22 +00:00
|
|
|
$caVeEditLink.text( getTabMessage( action ) );
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
|
|
|
|
2014-05-16 21:51:12 +00:00
|
|
|
// If the edit tab is hidden, remove it.
|
2017-04-25 15:36:30 +00:00
|
|
|
if ( !( init.isVisualAvailable && enabledForUser ) ) {
|
2014-05-16 21:51:12 +00:00
|
|
|
$caVeEdit.remove();
|
2016-11-02 12:12:33 +00:00
|
|
|
} else if ( pageCanLoadEditor ) {
|
2015-11-06 18:23:44 +00:00
|
|
|
// Allow instant switching to edit mode, without refresh
|
2017-10-16 17:02:00 +00:00
|
|
|
$caVeEdit.off( '.ve-target' ).on( 'click.ve-target', init.onEditTabClick.bind( init, 'visual' ) );
|
2014-05-16 21:51:12 +00:00
|
|
|
}
|
2018-08-02 16:58:36 +00:00
|
|
|
if ( pageCanLoadEditor ) {
|
|
|
|
// Always bind "Edit source" tab, because we want to handle switching with changes
|
|
|
|
$caEdit.off( '.ve-target' ).on( 'click.ve-target', init.onEditTabClick.bind( init, 'source' ) );
|
|
|
|
}
|
2016-11-02 12:12:33 +00:00
|
|
|
if ( pageCanLoadEditor && init.isWikitextAvailable ) {
|
2018-08-02 16:58:36 +00:00
|
|
|
// Only bind "Add topic" tab if NWE is available, because VE doesn't support section
|
|
|
|
// so we never have to switch from it when editing a section
|
|
|
|
$( '#ca-addsection' ).off( '.ve-target' ).on( 'click.ve-target', init.onEditTabClick.bind( init, 'source' ) );
|
2016-05-26 12:08:26 +00:00
|
|
|
}
|
2014-05-16 21:51:12 +00:00
|
|
|
|
2013-08-01 19:14:41 +00:00
|
|
|
// Alter the edit tab (#ca-edit)
|
2014-04-08 23:07:33 +00:00
|
|
|
if ( $( '#ca-view-foreign' ).length ) {
|
2015-08-19 17:33:02 +00:00
|
|
|
if ( tabMessages[ action + 'localdescriptionsource' ] !== null ) {
|
2019-11-01 16:20:22 +00:00
|
|
|
// The following messages can be used here:
|
|
|
|
// * editlocaldescriptionsource
|
|
|
|
// * createlocaldescriptionsource
|
2015-08-19 17:33:02 +00:00
|
|
|
$caEditLink.text( mw.msg( tabMessages[ action + 'localdescriptionsource' ] ) );
|
2014-04-08 23:07:33 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-08-19 17:33:02 +00:00
|
|
|
if ( tabMessages[ action + 'source' ] !== null ) {
|
2019-11-01 16:20:22 +00:00
|
|
|
// The following messages can be used here:
|
|
|
|
// * editsource
|
|
|
|
// * createsource
|
2015-08-19 17:33:02 +00:00
|
|
|
$caEditLink.text( mw.msg( tabMessages[ action + 'source' ] ) );
|
2014-04-08 23:07:33 +00:00
|
|
|
}
|
2013-08-01 19:14:41 +00:00
|
|
|
}
|
2014-04-03 01:14:54 +00:00
|
|
|
|
2018-10-26 21:45:42 +00:00
|
|
|
if ( isMinerva ) {
|
|
|
|
// Minerva hides the link text - display tiny icons instead
|
|
|
|
mw.loader.load( [ 'oojs-ui.styles.icons-editing-advanced', 'oojs-ui.styles.icons-accessibility' ] );
|
|
|
|
$caEdit.find( 'a' ).each( function () {
|
|
|
|
var $icon = $( '<span>' ).addClass( 'mw-ui-icon mw-ui-icon-before mw-ui-icon-wikiText' );
|
|
|
|
$( this ).addClass( 've-edit-source' ).prepend( $icon );
|
|
|
|
} );
|
|
|
|
$caVeEdit.find( 'a' ).each( function () {
|
|
|
|
var $icon = $( '<span>' ).addClass( 'mw-ui-icon mw-ui-icon-before mw-ui-icon-eye' );
|
|
|
|
$( this ).addClass( 've-edit-visual' ).prepend( $icon );
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
|
2016-09-20 22:37:00 +00:00
|
|
|
if ( init.isVisualAvailable ) {
|
2015-08-25 03:49:27 +00:00
|
|
|
if ( conf.tabPosition === 'before' ) {
|
|
|
|
$caEdit.addClass( 'collapsible' );
|
|
|
|
} else {
|
|
|
|
$caVeEdit.addClass( 'collapsible' );
|
|
|
|
}
|
2014-04-03 01:14:54 +00:00
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
},
|
|
|
|
|
2016-11-08 12:47:30 +00:00
|
|
|
setupMultiSectionLinks: function () {
|
mw.ViewPageTarget: Get rid of FOUC on edit section brackets
We don't have a FOUC on the appearing of the 'edit' link. That
one is handled quite intelligently:
* Via the stylesheet that is also loaded in noscript mode, its
(hidden) appearance is already predetermined. So as soon as
those elements are seen by the browser they style correctly
for users without JavaScript (display: none).
* This same stylesheet also hides it for users with JavaScript
but where VE is not available (e.g. due to browser support).
While ve-not-available is added very early on (before
document ready), it could in theory cause a short FOUC, but
that's okay. We simply don't know that VE isn't supported
until then. We optimise for the common case (JavaScript
enabled, VE available), while still ensuring that it is
always hidden in noscript, and is hidden as soon as possible
when VE turns out not to be available.
For some reason, one small detail (the little bit of whitespace
added inside the brackets), was left out of this and was
implemented by adding the class 'mw-editsection-expanded' to them
from a document ready handler.
* First step, get rid of the script that adds this class and
use ve-available instead. That means they're styled
correctly much earlier (we add the class to <html> before
document ready). This can still cause a brief FOUC, though
in most cases they're correct from the start.
* Step two, make brackets expand by default for script users,
and let ve-not-available reset it. This way, like with edit tabs,
a FOUC will never happen for ve-available. And even for
ve-not-available, a FOUC is rare since we add it before
document ready via <html> look-ahead styling.
There was still a brief reflow jump because of negative margins
between two paint events. One was undoing the other at a later
time. These negative margins are a remnant of when we were doing
animations (follows-up I4b9c47fd65a70). They were added to reduce
reflows and content shift, but were now actually causing them.
Removed "padding-right" from mw-editsection, and negative margin
from the brackets.
Also:
* Don't add inline 'style="direction: ltr;"' on every single
editsection throughout the DOM. This was the only operation we
were doing unconditionally. While I doubt the need of it in
general, we can at least allow MediaWiki to do it right, and
only add the override if needed. This saves quite a few DOM
operations.
Change-Id: I7a729edc2cd4a66ebc0ad6935ffd02cb9b948bff
2014-05-07 00:08:53 +00:00
|
|
|
var $editsections = $( '#mw-content-text .mw-editsection' ),
|
2018-10-26 21:45:42 +00:00
|
|
|
isMinerva = mw.config.get( 'skin' ) === 'minerva',
|
2018-12-13 16:44:25 +00:00
|
|
|
bodyDir = $( document.body ).css( 'direction' );
|
mw.ViewPageTarget: Get rid of FOUC on edit section brackets
We don't have a FOUC on the appearing of the 'edit' link. That
one is handled quite intelligently:
* Via the stylesheet that is also loaded in noscript mode, its
(hidden) appearance is already predetermined. So as soon as
those elements are seen by the browser they style correctly
for users without JavaScript (display: none).
* This same stylesheet also hides it for users with JavaScript
but where VE is not available (e.g. due to browser support).
While ve-not-available is added very early on (before
document ready), it could in theory cause a short FOUC, but
that's okay. We simply don't know that VE isn't supported
until then. We optimise for the common case (JavaScript
enabled, VE available), while still ensuring that it is
always hidden in noscript, and is hidden as soon as possible
when VE turns out not to be available.
For some reason, one small detail (the little bit of whitespace
added inside the brackets), was left out of this and was
implemented by adding the class 'mw-editsection-expanded' to them
from a document ready handler.
* First step, get rid of the script that adds this class and
use ve-available instead. That means they're styled
correctly much earlier (we add the class to <html> before
document ready). This can still cause a brief FOUC, though
in most cases they're correct from the start.
* Step two, make brackets expand by default for script users,
and let ve-not-available reset it. This way, like with edit tabs,
a FOUC will never happen for ve-available. And even for
ve-not-available, a FOUC is rare since we add it before
document ready via <html> look-ahead styling.
There was still a brief reflow jump because of negative margins
between two paint events. One was undoing the other at a later
time. These negative margins are a remnant of when we were doing
animations (follows-up I4b9c47fd65a70). They were added to reduce
reflows and content shift, but were now actually causing them.
Removed "padding-right" from mw-editsection, and negative margin
from the brackets.
Also:
* Don't add inline 'style="direction: ltr;"' on every single
editsection throughout the DOM. This was the only operation we
were doing unconditionally. While I doubt the need of it in
general, we can at least allow MediaWiki to do it right, and
only add the override if needed. This saves quite a few DOM
operations.
Change-Id: I7a729edc2cd4a66ebc0ad6935ffd02cb9b948bff
2014-05-07 00:08:53 +00:00
|
|
|
|
|
|
|
// Match direction of the user interface
|
|
|
|
// TODO: Why is this needed? It seems to work fine without.
|
|
|
|
if ( $editsections.css( 'direction' ) !== bodyDir ) {
|
|
|
|
// Avoid creating inline style attributes if the inherited value is already correct
|
|
|
|
$editsections.css( 'direction', bodyDir );
|
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
|
|
|
|
// The "visibility" css construct ensures we always occupy the same space in the layout.
|
|
|
|
// This prevents the heading from changing its wrap when the user toggles editSourceLink.
|
2013-08-01 19:14:41 +00:00
|
|
|
if ( $editsections.find( '.mw-editsection-visualeditor' ).length === 0 ) {
|
|
|
|
// If PHP didn't build the section edit links (because of caching), build them
|
|
|
|
$editsections.each( function () {
|
|
|
|
var $editsection = $( this ),
|
|
|
|
$editSourceLink = $editsection.find( 'a' ).eq( 0 ),
|
|
|
|
$editLink = $editSourceLink.clone(),
|
|
|
|
$divider = $( '<span>' ),
|
|
|
|
dividerText = mw.msg( 'pipe-separator' );
|
|
|
|
|
2019-11-01 16:20:22 +00:00
|
|
|
// The following messages can be used here:
|
|
|
|
// * visualeditor-ca-editsource-section
|
|
|
|
// * config value of tabMessages.editsectionsource
|
2018-10-13 01:10:42 +00:00
|
|
|
$editSourceLink.text( mw.msg( tabMessages.editsectionsource ) );
|
2019-11-01 16:20:22 +00:00
|
|
|
// The following messages can be used here:
|
|
|
|
// * editsection
|
|
|
|
// * config value of tabMessages.editsections
|
2018-10-13 01:10:42 +00:00
|
|
|
$editLink.text( mw.msg( tabMessages.editsection ) );
|
|
|
|
|
2013-08-01 19:14:41 +00:00
|
|
|
$divider
|
|
|
|
.addClass( 'mw-editsection-divider' )
|
|
|
|
.text( dividerText );
|
2018-08-09 14:10:53 +00:00
|
|
|
// Don't mess with section edit links on foreign file description pages (T56259)
|
2014-04-28 15:07:03 +00:00
|
|
|
if ( !$( '#ca-view-foreign' ).length ) {
|
|
|
|
$editLink
|
2019-03-26 19:54:04 +00:00
|
|
|
.attr( 'href', function ( i, href ) {
|
|
|
|
var veUri = new mw.Uri( veEditUri );
|
|
|
|
veUri.query.section = ( new mw.Uri( href ) ).query.section;
|
|
|
|
return veUri.toString();
|
|
|
|
} )
|
2014-04-28 15:07:03 +00:00
|
|
|
.addClass( 'mw-editsection-visualeditor' );
|
2016-09-06 19:16:55 +00:00
|
|
|
|
2014-04-28 15:07:03 +00:00
|
|
|
if ( conf.tabPosition === 'before' ) {
|
|
|
|
$editSourceLink.before( $editLink, $divider );
|
|
|
|
} else {
|
|
|
|
$editSourceLink.after( $divider, $editLink );
|
|
|
|
}
|
2013-08-01 19:14:41 +00:00
|
|
|
}
|
|
|
|
} );
|
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
|
2018-10-26 21:45:42 +00:00
|
|
|
if ( isMinerva ) {
|
|
|
|
// Minerva hides the link text - display tiny icons instead
|
|
|
|
mw.loader.load( [ 'oojs-ui.styles.icons-editing-advanced', 'oojs-ui.styles.icons-accessibility' ] );
|
|
|
|
$( '#mw-content-text .mw-editsection a:not(.mw-editsection-visualeditor)' ).each( function () {
|
|
|
|
var $icon = $( '<span>' ).addClass( 'mw-ui-icon mw-ui-icon-before mw-ui-icon-wikiText' );
|
|
|
|
$( this ).addClass( 've-edit-source' ).prepend( $icon );
|
|
|
|
} );
|
|
|
|
$( '#mw-content-text .mw-editsection a.mw-editsection-visualeditor' ).each( function () {
|
|
|
|
var $icon = $( '<span>' ).addClass( 'mw-ui-icon mw-ui-icon-before mw-ui-icon-eye' );
|
|
|
|
$( this ).addClass( 've-edit-visual' ).prepend( $icon );
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
|
2016-11-02 12:12:33 +00:00
|
|
|
if ( pageCanLoadEditor ) {
|
2013-08-01 19:14:41 +00:00
|
|
|
// Only init without refresh if we're on a view page. Though section edit links
|
|
|
|
// are rarely shown on non-view pages, they appear in one other case, namely
|
|
|
|
// when on a diff against the latest version of a page. In that case we mustn't
|
2018-08-09 14:10:53 +00:00
|
|
|
// init without refresh as that'd initialise for the wrong rev id (T52925)
|
2013-08-01 19:14:41 +00:00
|
|
|
// and would preserve the wrong DOM with a diff on top.
|
2017-07-18 11:55:33 +00:00
|
|
|
$editsections.find( '.mw-editsection-visualeditor' )
|
|
|
|
.on( 'click', init.onEditSectionLinkClick.bind( init, 'visual' ) );
|
2016-10-24 22:36:44 +00:00
|
|
|
if ( init.isWikitextAvailable ) {
|
2017-07-18 11:55:33 +00:00
|
|
|
// TOOD: Make this less fragile
|
|
|
|
$editsections.find( 'a:not( .mw-editsection-visualeditor )' )
|
|
|
|
.on( 'click', init.onEditSectionLinkClick.bind( init, 'source' ) );
|
2016-09-06 19:16:55 +00:00
|
|
|
}
|
2013-08-01 19:14:41 +00:00
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
},
|
|
|
|
|
2016-08-22 19:40:34 +00:00
|
|
|
/**
|
|
|
|
* Check whether a jQuery event represents a plain left click, without
|
|
|
|
* any modifiers
|
|
|
|
*
|
|
|
|
* This is a duplicate of a function in ve.utils, because this file runs
|
|
|
|
* before any of VE core or OOui has been loaded.
|
|
|
|
*
|
|
|
|
* @param {jQuery.Event} e The jQuery event object
|
|
|
|
* @return {boolean} Whether it was an unmodified left click
|
|
|
|
*/
|
|
|
|
isUnmodifiedLeftClick: function ( e ) {
|
|
|
|
return e && e.which && e.which === 1 && !( e.shiftKey || e.altKey || e.ctrlKey || e.metaKey );
|
|
|
|
},
|
|
|
|
|
2016-09-06 19:16:55 +00:00
|
|
|
onEditTabClick: function ( mode, e ) {
|
2016-12-13 16:42:45 +00:00
|
|
|
var section;
|
2016-08-22 19:40:34 +00:00
|
|
|
if ( !init.isUnmodifiedLeftClick( e ) ) {
|
2013-07-05 06:01:31 +00:00
|
|
|
return;
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
2018-08-02 16:58:36 +00:00
|
|
|
if ( !active && mode === 'source' && !init.isWikitextAvailable ) {
|
|
|
|
// We're not active so we don't need to manage a switch, and
|
|
|
|
// we don't have source mode available so we don't need to
|
|
|
|
// activate VE. Just follow the link.
|
|
|
|
return;
|
|
|
|
}
|
2015-11-04 10:10:28 +00:00
|
|
|
e.preventDefault();
|
2016-08-23 16:27:30 +00:00
|
|
|
if ( isLoading ) {
|
|
|
|
return;
|
|
|
|
}
|
2016-12-08 19:24:10 +00:00
|
|
|
|
2016-12-13 16:42:45 +00:00
|
|
|
section = $( e.target ).closest( '#ca-addsection' ).length ? 'new' : null;
|
2016-12-08 19:24:10 +00:00
|
|
|
|
2016-12-13 16:42:45 +00:00
|
|
|
if ( active ) {
|
2016-09-07 00:02:48 +00:00
|
|
|
targetPromise.done( function ( target ) {
|
2018-06-27 23:25:36 +00:00
|
|
|
if ( target.getDefaultMode() === 'source' ) {
|
|
|
|
if ( mode === 'visual' ) {
|
|
|
|
target.switchToVisualEditor();
|
|
|
|
} else if ( mode === 'source' ) {
|
|
|
|
// Requested section may have changed --
|
|
|
|
// switchToWikitextSection will do nothing if the
|
|
|
|
// section is unchanged.
|
|
|
|
target.switchToWikitextSection( section );
|
|
|
|
}
|
|
|
|
} else if ( target.getDefaultMode() === 'visual' ) {
|
|
|
|
if ( mode === 'source' ) {
|
|
|
|
if ( section ) {
|
|
|
|
// switching from visual via the "add section" tab
|
|
|
|
target.switchToWikitextSection( section );
|
|
|
|
} else {
|
|
|
|
target.editSource();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Visual-to-visual doesn't need to do anything,
|
|
|
|
// because we don't have any section concerns. Just
|
|
|
|
// no-op it.
|
2016-09-07 00:02:48 +00:00
|
|
|
}
|
|
|
|
} );
|
|
|
|
} else {
|
2016-12-13 16:42:45 +00:00
|
|
|
if ( section !== null ) {
|
|
|
|
this.onEditSectionLinkClick( mode, e, section );
|
|
|
|
} else {
|
|
|
|
init.activateVe( mode );
|
|
|
|
}
|
2016-08-23 16:27:30 +00:00
|
|
|
}
|
2015-11-04 10:10:28 +00:00
|
|
|
},
|
|
|
|
|
2016-05-26 12:08:26 +00:00
|
|
|
activateVe: function ( mode ) {
|
2019-04-05 13:51:14 +00:00
|
|
|
var wikitext = $( '#wpTextbox1' ).textSelection( 'getContents' ),
|
|
|
|
sectionVal = $( 'input[name=wpSection]' ).val(),
|
2019-04-18 18:38:15 +00:00
|
|
|
section = sectionVal !== '' && sectionVal !== undefined ? +sectionVal : null,
|
|
|
|
config = mw.config.get( 'wgVisualEditorConfig' ),
|
|
|
|
canSwitch = config.fullRestbaseUrl || config.allowLossySwitching,
|
|
|
|
modified = mw.config.get( 'wgAction' ) === 'submit' ||
|
|
|
|
(
|
|
|
|
mw.config.get( 'wgAction' ) === 'edit' &&
|
|
|
|
wikitext !== initialWikitext
|
|
|
|
);
|
2013-07-05 06:01:31 +00:00
|
|
|
|
2015-11-18 01:26:01 +00:00
|
|
|
// Close any open jQuery.UI dialogs (e.g. WikiEditor's find and replace)
|
|
|
|
if ( $.fn.dialog ) {
|
|
|
|
$( '.ui-dialog-content' ).dialog( 'close' );
|
|
|
|
}
|
|
|
|
|
2018-09-06 13:13:55 +00:00
|
|
|
// Release the edit warning on #wpTextbox1 which was setup in mediawiki.action.edit.editWarning.js
|
|
|
|
function releaseOldEditWarning() {
|
|
|
|
$( window ).off( 'beforeunload.editwarning' );
|
|
|
|
}
|
|
|
|
|
2019-04-18 18:38:15 +00:00
|
|
|
if ( modified && !canSwitch ) {
|
2015-12-11 23:39:34 +00:00
|
|
|
mw.loader.using( 'ext.visualEditor.switching' ).done( function () {
|
|
|
|
var windowManager = new OO.ui.WindowManager(),
|
|
|
|
switchWindow = new mw.libs.ve.SwitchConfirmDialog();
|
|
|
|
|
2018-12-13 16:44:25 +00:00
|
|
|
$( document.body ).append( windowManager.$element );
|
2015-12-11 23:39:34 +00:00
|
|
|
windowManager.addWindows( [ switchWindow ] );
|
|
|
|
windowManager.openWindow( switchWindow )
|
2017-06-01 22:21:58 +00:00
|
|
|
.closed.then( function ( data ) {
|
2016-04-05 00:25:33 +00:00
|
|
|
var oldUri;
|
2016-04-28 21:08:26 +00:00
|
|
|
// TODO: windowManager.destroy()?
|
2019-04-18 18:38:15 +00:00
|
|
|
if ( data && data.action === 'discard' ) {
|
2018-09-06 13:13:55 +00:00
|
|
|
releaseOldEditWarning();
|
2015-12-12 00:51:32 +00:00
|
|
|
setEditorPreference( 'visualeditor' );
|
2016-04-05 00:25:33 +00:00
|
|
|
oldUri = veEditUri.clone();
|
|
|
|
delete oldUri.query.veswitched;
|
|
|
|
location.href = oldUri.extend( { wteswitched: 1 } );
|
2015-12-11 23:39:34 +00:00
|
|
|
}
|
2015-10-14 23:34:34 +00:00
|
|
|
} );
|
2015-12-11 23:39:34 +00:00
|
|
|
} );
|
2015-11-09 17:55:21 +00:00
|
|
|
} else {
|
2018-09-06 13:13:55 +00:00
|
|
|
releaseOldEditWarning();
|
2019-04-18 18:38:15 +00:00
|
|
|
activatePageTarget( mode, section, modified );
|
2014-10-21 01:10:41 +00:00
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
},
|
|
|
|
|
2016-12-08 19:24:10 +00:00
|
|
|
/**
|
|
|
|
* Handle section edit links being clicked
|
|
|
|
*
|
|
|
|
* @param {string} mode Edit mode
|
|
|
|
* @param {jQuery.Event} e Click event
|
|
|
|
* @param {number|string} [section] Override edit section, taken from link URL if not specified
|
|
|
|
*/
|
|
|
|
onEditSectionLinkClick: function ( mode, e, section ) {
|
2016-12-15 00:07:22 +00:00
|
|
|
var targetPromise,
|
|
|
|
uri = new mw.Uri( e.target.href ),
|
|
|
|
title = mw.Title.newFromText( uri.query.title || '' );
|
|
|
|
|
2018-04-30 09:57:45 +00:00
|
|
|
if (
|
|
|
|
// Modified click (e.g. ctrl+click)
|
|
|
|
!init.isUnmodifiedLeftClick( e ) ||
|
|
|
|
// Not an edit action
|
|
|
|
!( 'action' in uri.query || 'veaction' in uri.query ) ||
|
|
|
|
// Edit target is on another host (e.g. commons file)
|
2018-07-03 22:09:36 +00:00
|
|
|
uri.getHostPort() !== location.host ||
|
2018-04-30 09:57:45 +00:00
|
|
|
// Title param doesn't match current page
|
|
|
|
title && title.getPrefixedText() !== new mw.Title( mw.config.get( 'wgRelevantPageName' ) ).getPrefixedText()
|
|
|
|
) {
|
2013-07-05 06:01:31 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-08-23 16:27:30 +00:00
|
|
|
e.preventDefault();
|
|
|
|
if ( isLoading ) {
|
|
|
|
return;
|
|
|
|
}
|
2013-07-05 06:01:31 +00:00
|
|
|
|
2017-12-07 11:14:00 +00:00
|
|
|
trackActivateStart( { type: 'section', mechanism: 'click', mode: mode } );
|
2014-11-18 20:47:11 +00:00
|
|
|
|
2019-04-10 19:41:02 +00:00
|
|
|
if ( history.pushState && !( uri.query.veaction in veactionToMode ) ) {
|
2014-11-18 20:47:11 +00:00
|
|
|
// Replace the current state with one that is tagged as ours, to prevent the
|
|
|
|
// back button from breaking when used to exit VE. FIXME: there should be a better
|
2015-07-29 13:41:30 +00:00
|
|
|
// way to do this. See also similar code in the DesktopArticleTarget constructor.
|
2014-11-18 20:47:11 +00:00
|
|
|
history.replaceState( { tag: 'visualeditor' }, document.title, uri );
|
|
|
|
// Change the state to the href of the section link that was clicked. This saves
|
|
|
|
// us from having to figure out the section number again.
|
2014-11-19 01:10:52 +00:00
|
|
|
history.pushState( { tag: 'visualeditor' }, document.title, this.href );
|
2014-10-21 01:10:41 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 13:21:26 +00:00
|
|
|
// Use section from URL
|
|
|
|
if ( section === undefined ) {
|
|
|
|
section = parseSection( uri.query.section );
|
2016-09-06 19:16:55 +00:00
|
|
|
}
|
2019-02-13 13:21:26 +00:00
|
|
|
targetPromise = getTarget( mode, section );
|
2016-09-06 19:16:55 +00:00
|
|
|
activateTarget( mode, section, targetPromise );
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-11-08 12:37:51 +00:00
|
|
|
init.isSingleEditTab = conf.singleEditTab && tabPreference !== 'multi-tab';
|
|
|
|
|
2016-04-15 02:05:27 +00:00
|
|
|
// On a view page, extend the current URI so parameters like oldid are carried over
|
|
|
|
// On a non-view page, use viewUri
|
2016-12-29 19:38:09 +00:00
|
|
|
if ( init.isSingleEditTab ) {
|
2016-04-15 02:05:27 +00:00
|
|
|
veEditUri = viewUri.clone().extend( { action: 'edit' } );
|
|
|
|
delete veEditUri.query.veaction;
|
|
|
|
} else {
|
2016-11-02 12:12:33 +00:00
|
|
|
veEditUri = ( pageCanLoadEditor ? uri : viewUri ).clone().extend( { veaction: 'edit' } );
|
|
|
|
veEditSourceUri = ( pageCanLoadEditor ? uri : viewUri ).clone().extend( { veaction: 'editsource' } );
|
2016-04-15 02:05:27 +00:00
|
|
|
delete veEditUri.query.action;
|
2016-05-26 12:08:26 +00:00
|
|
|
delete veEditSourceUri.query.action;
|
2016-04-15 02:05:27 +00:00
|
|
|
}
|
2017-09-11 15:03:18 +00:00
|
|
|
if ( oldId ) {
|
|
|
|
veEditUri.extend( { oldid: oldId } );
|
2016-04-15 02:05:27 +00:00
|
|
|
}
|
2013-09-30 16:18:46 +00:00
|
|
|
|
2013-08-02 20:25:44 +00:00
|
|
|
// Whether VisualEditor should be available for the current user, page, wiki, mediawiki skin,
|
|
|
|
// browser etc.
|
|
|
|
init.isAvailable = (
|
2016-04-21 11:29:20 +00:00
|
|
|
// Support check asserts that Array.prototype.indexOf is available so we can use it below
|
2016-02-26 20:16:25 +00:00
|
|
|
VisualEditorSupportCheck() &&
|
2016-02-16 19:20:04 +00:00
|
|
|
|
|
|
|
( ( 'vewhitelist' in uri.query ) || !$.client.test( init.blacklist, null, true ) ) &&
|
2013-08-02 20:25:44 +00:00
|
|
|
|
2016-12-24 16:17:01 +00:00
|
|
|
// Not on pages which are outputs of the Translate extensions
|
2018-02-28 14:36:42 +00:00
|
|
|
// TODO: Allow the Translate extension to do this itself (T174180)
|
2016-12-24 16:17:01 +00:00
|
|
|
mw.config.get( 'wgTranslatePageTranslation' ) !== 'translation' &&
|
|
|
|
|
2018-02-28 14:36:42 +00:00
|
|
|
// Not on the edit conflict page of the TwoColumnConflict extension (T156251)
|
|
|
|
// TODO: Allow the TwoColumnConflict extension to do this itself (T174180)
|
2018-11-05 17:36:25 +00:00
|
|
|
mw.config.get( 'wgTwoColConflict' ) !== 'true'
|
2016-09-20 22:37:00 +00:00
|
|
|
);
|
2016-10-24 22:36:44 +00:00
|
|
|
|
2017-04-27 15:23:26 +00:00
|
|
|
// Duplicated in VisualEditor.hooks.php#isVisualAvailable()
|
2016-09-20 22:37:00 +00:00
|
|
|
init.isVisualAvailable = (
|
|
|
|
init.isAvailable &&
|
|
|
|
|
2019-05-09 20:37:28 +00:00
|
|
|
(
|
|
|
|
// Only in enabled namespaces
|
|
|
|
conf.namespaces.indexOf( new mw.Title( mw.config.get( 'wgRelevantPageName' ) ).getNamespaceId() ) !== -1 ||
|
|
|
|
// Or if forced by the URL parameter (T221892)
|
|
|
|
uri.query.veaction === 'edit'
|
|
|
|
) &&
|
2013-07-19 02:44:22 +00:00
|
|
|
|
2016-04-21 11:40:42 +00:00
|
|
|
// Only for pages with a supported content model
|
2018-07-06 00:10:20 +00:00
|
|
|
Object.prototype.hasOwnProperty.call( conf.contentModels, mw.config.get( 'wgPageContentModel' ) )
|
2013-07-19 02:44:22 +00:00
|
|
|
);
|
|
|
|
|
2017-04-27 15:23:26 +00:00
|
|
|
// Duplicated in VisualEditor.hooks.php#isWikitextAvailable()
|
2016-10-24 22:36:44 +00:00
|
|
|
init.isWikitextAvailable = (
|
|
|
|
init.isAvailable &&
|
|
|
|
|
|
|
|
// Enabled on site
|
|
|
|
conf.enableWikitext &&
|
|
|
|
|
|
|
|
// User preference
|
|
|
|
mw.user.options.get( 'visualeditor-newwikitext' ) &&
|
|
|
|
|
|
|
|
// Only on wikitext pages
|
|
|
|
mw.config.get( 'wgPageContentModel' ) === 'wikitext'
|
|
|
|
);
|
|
|
|
|
2019-04-10 19:41:02 +00:00
|
|
|
if ( init.isVisualAvailable ) {
|
|
|
|
availableModes.push( 'visual' );
|
|
|
|
}
|
|
|
|
|
2016-10-24 22:36:44 +00:00
|
|
|
if ( init.isWikitextAvailable ) {
|
2019-04-10 19:41:02 +00:00
|
|
|
availableModes.push( 'source' );
|
2016-10-24 22:36:44 +00:00
|
|
|
}
|
|
|
|
|
2017-04-25 15:36:30 +00:00
|
|
|
enabledForUser = (
|
2016-12-29 19:38:09 +00:00
|
|
|
// Allow disabling for anonymous users separately from changing the
|
2018-08-09 14:10:53 +00:00
|
|
|
// default preference (T52000)
|
2016-12-29 19:38:09 +00:00
|
|
|
!( conf.disableForAnons && mw.config.get( 'wgUserName' ) === null ) &&
|
|
|
|
|
|
|
|
// User has 'visualeditor-enable' preference enabled (for alpha opt-in)
|
|
|
|
// User has 'visualeditor-betatempdisable' preference disabled
|
|
|
|
// User has 'visualeditor-autodisable' preference disabled
|
2017-04-25 15:36:30 +00:00
|
|
|
enable && !tempdisable && !autodisable &&
|
2016-12-29 19:38:09 +00:00
|
|
|
|
|
|
|
// Except when single edit tab for old wikitext
|
|
|
|
!( conf.singleEditTab && tabPreference === 'prefer-wt' && !init.isWikitextAvailable )
|
|
|
|
);
|
|
|
|
|
2015-12-12 00:51:32 +00:00
|
|
|
// FIXME: We should do this more elegantly
|
|
|
|
init.setEditorPreference = setEditorPreference;
|
|
|
|
|
2013-07-10 13:55:17 +00:00
|
|
|
// Note: Though VisualEditor itself only needs this exposure for a very small reason
|
|
|
|
// (namely to access init.blacklist from the unit tests...) this has become one of the nicest
|
2013-08-03 04:33:03 +00:00
|
|
|
// ways to easily detect whether the VisualEditor initialisation code is present.
|
|
|
|
//
|
|
|
|
// The VE global was once available always, but now that platform integration initialisation
|
|
|
|
// is properly separated, it doesn't exist until the platform loads VisualEditor core.
|
|
|
|
//
|
2016-09-20 22:37:00 +00:00
|
|
|
// Most of mw.libs.ve is considered subject to change and private. An exception is that
|
|
|
|
// mw.libs.ve.isVisualAvailable is public, and indicates whether the VE editor itself can be loaded
|
2013-08-03 04:33:03 +00:00
|
|
|
// on this page. See above for why it may be false.
|
2015-08-05 19:20:31 +00:00
|
|
|
mw.libs.ve = $.extend( mw.libs.ve || {}, init );
|
2013-07-03 22:14:52 +00:00
|
|
|
|
2017-04-25 15:36:30 +00:00
|
|
|
if ( init.isVisualAvailable && enabledForUser ) {
|
2013-09-04 17:57:29 +00:00
|
|
|
$( 'html' ).addClass( 've-available' );
|
|
|
|
} else {
|
2013-08-01 19:14:41 +00:00
|
|
|
$( 'html' ).addClass( 've-not-available' );
|
2013-09-04 17:57:29 +00:00
|
|
|
// Don't return here because we do want the skin setup to consistently happen
|
|
|
|
// for e.g. "Edit" > "Edit source" even when VE is not available.
|
2013-08-02 20:25:44 +00:00
|
|
|
}
|
|
|
|
|
2013-07-03 22:14:52 +00:00
|
|
|
$( function () {
|
2018-03-27 15:36:41 +00:00
|
|
|
var mode, requiredSkinElements, notify,
|
2016-12-29 20:08:53 +00:00
|
|
|
showWikitextWelcome = true,
|
2016-12-08 19:19:17 +00:00
|
|
|
section = uri.query.section !== undefined ? parseSection( uri.query.section ) : null,
|
2016-04-28 21:08:26 +00:00
|
|
|
isLoggedIn = !mw.user.isAnon(),
|
|
|
|
prefSaysShowWelcome = isLoggedIn && !mw.user.options.get( 'visualeditor-hidebetawelcome' ),
|
2018-01-10 16:58:38 +00:00
|
|
|
urlSaysHideWelcome = 'hidewelcomedialog' in new mw.Uri( location.href ).query;
|
2016-04-28 21:08:26 +00:00
|
|
|
|
2017-04-26 17:20:58 +00:00
|
|
|
requiredSkinElements =
|
|
|
|
$( '#content' ).length &&
|
|
|
|
$( '#mw-content-text' ).length &&
|
2018-09-25 12:06:01 +00:00
|
|
|
// A link to open the editor is technically not necessary if it's going to open itself
|
2019-02-09 19:28:34 +00:00
|
|
|
( isEditPage || $( '#ca-edit, #ca-viewsource' ).length );
|
2017-04-26 17:20:58 +00:00
|
|
|
|
2015-10-23 16:29:56 +00:00
|
|
|
if ( uri.query.action === 'edit' && $( '#wpTextbox1' ).length ) {
|
2016-06-21 23:18:09 +00:00
|
|
|
initialWikitext = $( '#wpTextbox1' ).textSelection( 'getContents' );
|
2015-10-14 23:34:34 +00:00
|
|
|
}
|
|
|
|
|
2017-04-25 15:36:30 +00:00
|
|
|
function isSupportedEditPage() {
|
2019-04-09 19:48:25 +00:00
|
|
|
return data.unsupportedEditParams.every( function ( param ) {
|
2017-04-25 15:36:30 +00:00
|
|
|
return uri.query[ param ] === undefined;
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
|
|
|
|
function getInitialEditMode() {
|
|
|
|
// On view pages if veaction is correctly set
|
2019-04-10 19:41:02 +00:00
|
|
|
var mode = veactionToMode[ uri.query.veaction ];
|
|
|
|
if ( isViewPage && init.isAvailable && availableModes.indexOf( mode ) !== -1 ) {
|
|
|
|
return mode;
|
2017-04-25 15:36:30 +00:00
|
|
|
}
|
|
|
|
// Edit pages
|
|
|
|
if ( isEditPage && isSupportedEditPage() ) {
|
|
|
|
// Just did a discard-switch from wikitext editor to VE (in no RESTBase mode)
|
|
|
|
if ( uri.query.wteswitched === '1' ) {
|
|
|
|
return init.isVisualAvailable ? 'visual' : null;
|
|
|
|
}
|
|
|
|
// User has disabled VE, or we are in view source only mode, or we have landed here with posted data
|
|
|
|
if ( !enabledForUser || $( '#ca-viewsource' ).length || mw.config.get( 'wgAction' ) === 'submit' ) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
switch ( getPreferredEditor() ) {
|
|
|
|
case 'visualeditor':
|
|
|
|
if ( init.isVisualAvailable ) {
|
|
|
|
return 'visual';
|
2016-09-17 02:35:32 +00:00
|
|
|
}
|
2017-04-25 15:36:30 +00:00
|
|
|
if ( init.isWikitextAvailable ) {
|
|
|
|
return 'source';
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
|
|
|
|
case 'wikitext':
|
|
|
|
return init.isWikitextAvailable ? 'source' : null;
|
2016-04-15 02:05:27 +00:00
|
|
|
}
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
2017-04-25 15:36:30 +00:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-04-26 17:20:58 +00:00
|
|
|
if ( init.isAvailable && pageCanLoadEditor && !requiredSkinElements ) {
|
|
|
|
mw.log.warn(
|
|
|
|
'Your skin is incompatible with VisualEditor. ' +
|
|
|
|
'See <https://www.mediawiki.org/wiki/VisualEditor/Skin_requirements> for the requirements.'
|
|
|
|
);
|
|
|
|
} else if ( init.isAvailable ) {
|
2017-04-25 15:36:30 +00:00
|
|
|
mode = getInitialEditMode();
|
|
|
|
if ( mode ) {
|
|
|
|
showWikitextWelcome = false;
|
|
|
|
trackActivateStart( {
|
|
|
|
type: section === null ? 'page' : 'section',
|
2017-12-07 11:14:00 +00:00
|
|
|
mechanism: 'url',
|
|
|
|
mode: mode
|
2017-04-25 15:36:30 +00:00
|
|
|
} );
|
|
|
|
activateTarget( mode, section );
|
|
|
|
} else if (
|
|
|
|
init.isVisualAvailable &&
|
|
|
|
pageCanLoadEditor &&
|
|
|
|
init.isSingleEditTab
|
|
|
|
) {
|
|
|
|
// In single edit tab mode we never have an edit tab
|
|
|
|
// with accesskey 'v' so create one
|
2018-12-13 16:44:25 +00:00
|
|
|
$( document.body ).append(
|
2017-04-25 15:36:30 +00:00
|
|
|
$( '<a>' )
|
|
|
|
.attr( { accesskey: mw.msg( 'accesskey-ca-ve-edit' ), href: veEditUri } )
|
|
|
|
// Accesskey fires a click event
|
2017-10-16 17:02:00 +00:00
|
|
|
.on( 'click.ve-target', init.onEditTabClick.bind( init, 'visual' ) )
|
2017-10-18 22:50:31 +00:00
|
|
|
.addClass( 'oo-ui-element-hidden' )
|
2017-04-25 15:36:30 +00:00
|
|
|
);
|
|
|
|
}
|
2015-10-23 16:29:56 +00:00
|
|
|
|
2018-03-10 18:30:12 +00:00
|
|
|
// Add the switch button to WikiEditor on ?action=edit or ?action=submit pages
|
2016-09-20 22:37:00 +00:00
|
|
|
if (
|
|
|
|
init.isVisualAvailable &&
|
2018-03-10 18:30:12 +00:00
|
|
|
[ 'edit', 'submit' ].indexOf( mw.config.get( 'wgAction' ) ) !== -1 &&
|
|
|
|
$( '#wpTextbox1' ).length
|
2016-09-20 22:37:00 +00:00
|
|
|
) {
|
2015-10-23 16:29:56 +00:00
|
|
|
mw.loader.load( 'ext.visualEditor.switching' );
|
|
|
|
$( '#wpTextbox1' ).on( 'wikiEditor-toolbar-doneInitialSections', function () {
|
|
|
|
mw.loader.using( 'ext.visualEditor.switching' ).done( function () {
|
2017-02-24 14:29:21 +00:00
|
|
|
var windowManager, editingTabDialog, switchToolbar, popup,
|
|
|
|
showPopup = !!uri.query.veswitched && !mw.user.options.get( 'visualeditor-hidesourceswitchpopup' ),
|
|
|
|
toolFactory = new OO.ui.ToolFactory(),
|
|
|
|
toolGroupFactory = new OO.ui.ToolGroupFactory();
|
|
|
|
|
|
|
|
toolFactory.register( mw.libs.ve.MWEditModeVisualTool );
|
|
|
|
toolFactory.register( mw.libs.ve.MWEditModeSourceTool );
|
|
|
|
switchToolbar = new OO.ui.Toolbar( toolFactory, toolGroupFactory, {
|
|
|
|
classes: [ 've-init-mw-editSwitch' ]
|
|
|
|
} );
|
|
|
|
|
2017-02-28 23:07:54 +00:00
|
|
|
switchToolbar.on( 'switchEditor', function ( mode ) {
|
2017-02-24 14:29:21 +00:00
|
|
|
if ( mode === 'visual' ) {
|
|
|
|
init.activateVe( 'visual' );
|
2019-06-27 21:44:20 +00:00
|
|
|
$( '#wpTextbox1' ).trigger( 'wikiEditor-switching-visualeditor' );
|
2015-11-10 23:01:49 +00:00
|
|
|
}
|
2017-02-24 14:29:21 +00:00
|
|
|
} );
|
2015-11-10 23:01:49 +00:00
|
|
|
|
2017-02-24 14:29:21 +00:00
|
|
|
switchToolbar.setup( [ {
|
2018-07-03 13:23:21 +00:00
|
|
|
name: 'editMode',
|
2017-02-24 14:29:21 +00:00
|
|
|
type: 'list',
|
2017-02-28 22:59:51 +00:00
|
|
|
icon: 'edit',
|
2017-02-24 14:29:21 +00:00
|
|
|
title: mw.msg( 'visualeditor-mweditmode-tooltip' ),
|
|
|
|
include: [ 'editModeVisual', 'editModeSource' ]
|
|
|
|
} ] );
|
2015-11-10 23:01:49 +00:00
|
|
|
|
2017-02-24 14:29:21 +00:00
|
|
|
popup = new mw.libs.ve.SwitchPopupWidget( 'source' );
|
2015-11-10 23:01:49 +00:00
|
|
|
|
2017-02-24 14:29:21 +00:00
|
|
|
switchToolbar.tools.editModeVisual.toolGroup.$element.append( popup.$element );
|
|
|
|
switchToolbar.emit( 'updateState' );
|
2015-11-10 23:01:49 +00:00
|
|
|
|
2017-02-24 14:29:21 +00:00
|
|
|
$( '.wikiEditor-ui-toolbar' ).prepend( switchToolbar.$element );
|
|
|
|
popup.toggle( showPopup );
|
2015-10-23 16:29:56 +00:00
|
|
|
|
|
|
|
// Duplicate of this code in ve.init.mw.DesktopArticleTarget.js
|
2019-08-01 01:48:24 +00:00
|
|
|
// eslint-disable-next-line no-jquery/no-class-state
|
2015-10-23 16:29:56 +00:00
|
|
|
if ( $( '#ca-edit' ).hasClass( 'visualeditor-showtabdialog' ) ) {
|
2016-05-20 01:36:25 +00:00
|
|
|
$( '#ca-edit' ).removeClass( 'visualeditor-showtabdialog' );
|
2015-10-23 16:29:56 +00:00
|
|
|
// Set up a temporary window manager
|
|
|
|
windowManager = new OO.ui.WindowManager();
|
2018-12-13 16:44:25 +00:00
|
|
|
$( document.body ).append( windowManager.$element );
|
2015-10-23 16:29:56 +00:00
|
|
|
editingTabDialog = new mw.libs.ve.EditingTabDialog();
|
|
|
|
windowManager.addWindows( [ editingTabDialog ] );
|
2016-04-13 21:46:14 +00:00
|
|
|
windowManager.openWindow( editingTabDialog )
|
2017-06-01 22:21:58 +00:00
|
|
|
.closed.then( function ( data ) {
|
2015-10-23 16:29:56 +00:00
|
|
|
// Detach the temporary window manager
|
|
|
|
windowManager.destroy();
|
|
|
|
|
|
|
|
if ( data && data.action === 'prefer-ve' ) {
|
|
|
|
location.href = veEditUri;
|
2016-03-11 05:36:15 +00:00
|
|
|
} else if ( data && data.action === 'multi-tab' ) {
|
|
|
|
location.reload();
|
2015-10-23 16:29:56 +00:00
|
|
|
}
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
} );
|
2016-03-07 20:55:07 +00:00
|
|
|
|
|
|
|
// Remember that the user wanted wikitext, at least this time
|
|
|
|
mw.libs.ve.setEditorPreference( 'wikitext' );
|
2018-03-10 18:30:12 +00:00
|
|
|
|
|
|
|
// If the user has loaded WikiEditor, clear any auto-save state they
|
|
|
|
// may have from a previous VE session
|
|
|
|
// We don't have access to the VE session storage methods, but invalidating
|
|
|
|
// the docstate is sufficient to prevent the data from being used.
|
|
|
|
mw.storage.session.remove( 've-docstate' );
|
2015-10-23 16:29:56 +00:00
|
|
|
}
|
2015-12-14 20:52:26 +00:00
|
|
|
|
2017-10-16 17:02:00 +00:00
|
|
|
init.setupEditLinks();
|
2013-07-03 22:14:52 +00:00
|
|
|
}
|
2013-11-26 09:46:42 +00:00
|
|
|
|
2016-04-28 21:08:26 +00:00
|
|
|
if (
|
2017-07-12 15:29:54 +00:00
|
|
|
pageCanLoadEditor &&
|
2016-04-28 21:08:26 +00:00
|
|
|
showWikitextWelcome &&
|
2018-08-23 13:19:52 +00:00
|
|
|
// At least one editor is available (T201928)
|
|
|
|
( init.isVisualAvailable || init.isWikitextAvailable || $( '#wpTextbox1' ).length ) &&
|
2016-04-28 21:08:26 +00:00
|
|
|
mw.config.get( 'wgVisualEditorConfig' ).showBetaWelcome &&
|
|
|
|
[ 'edit', 'submit' ].indexOf( mw.config.get( 'wgAction' ) ) !== -1 &&
|
|
|
|
!urlSaysHideWelcome &&
|
|
|
|
(
|
|
|
|
prefSaysShowWelcome ||
|
|
|
|
(
|
|
|
|
!isLoggedIn &&
|
2018-01-10 16:58:38 +00:00
|
|
|
mw.storage.get( 've-beta-welcome-dialog' ) === null &&
|
2016-04-28 21:08:26 +00:00
|
|
|
$.cookie( 've-beta-welcome-dialog' ) === null
|
|
|
|
)
|
2017-07-17 22:17:07 +00:00
|
|
|
) &&
|
|
|
|
(
|
|
|
|
// Not on protected pages
|
|
|
|
mw.config.get( 'wgIsProbablyEditable' ) ||
|
|
|
|
mw.config.get( 'wgRelevantPageIsProbablyEditable' )
|
2016-04-28 21:08:26 +00:00
|
|
|
)
|
|
|
|
) {
|
|
|
|
mw.loader.using( 'ext.visualEditor.welcome' ).done( function () {
|
|
|
|
var windowManager = new OO.ui.WindowManager(),
|
|
|
|
welcomeDialog = new mw.libs.ve.WelcomeDialog();
|
2018-12-13 16:44:25 +00:00
|
|
|
$( document.body ).append( windowManager.$element );
|
2016-04-28 21:08:26 +00:00
|
|
|
windowManager.addWindows( [ welcomeDialog ] );
|
|
|
|
windowManager.openWindow(
|
|
|
|
welcomeDialog,
|
|
|
|
{
|
2016-09-20 22:37:00 +00:00
|
|
|
switchable: init.isVisualAvailable,
|
2016-09-15 00:18:10 +00:00
|
|
|
editor: 'source'
|
2016-04-28 21:08:26 +00:00
|
|
|
}
|
|
|
|
)
|
2017-06-01 22:21:58 +00:00
|
|
|
.closed.then( function ( data ) {
|
2016-04-28 21:08:26 +00:00
|
|
|
windowManager.destroy();
|
|
|
|
if ( data && data.action === 'switch-ve' ) {
|
2016-05-26 12:08:26 +00:00
|
|
|
init.activateVe( 'visual' );
|
2016-04-28 21:08:26 +00:00
|
|
|
}
|
|
|
|
} );
|
|
|
|
|
|
|
|
if ( prefSaysShowWelcome ) {
|
2018-05-07 20:21:13 +00:00
|
|
|
// Same as ve.init.target.getLocalApi()
|
|
|
|
new mw.Api().saveOption( 'visualeditor-hidebetawelcome', '1' );
|
2016-04-28 21:08:26 +00:00
|
|
|
mw.user.options.set( 'visualeditor-hidebetawelcome', '1' );
|
|
|
|
} else if ( !isLoggedIn && !urlSaysHideWelcome ) {
|
2018-01-10 16:58:38 +00:00
|
|
|
if ( !mw.storage.set( 've-beta-welcome-dialog', 1 ) ) {
|
2016-04-28 21:08:26 +00:00
|
|
|
$.cookie( 've-beta-welcome-dialog', 1, { path: '/', expires: 30 } );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
|
2015-10-23 16:29:56 +00:00
|
|
|
if ( uri.query.venotify ) {
|
2017-10-05 22:03:10 +00:00
|
|
|
// Load postEdit code to execute the queued event below, which will handle it once it arrives
|
|
|
|
mw.loader.load( 'mediawiki.action.view.postEdit' );
|
|
|
|
|
2018-03-27 15:36:41 +00:00
|
|
|
notify = uri.query.venotify;
|
|
|
|
if ( notify === 'saved' ) {
|
|
|
|
notify = mw.config.get( 'wgEditSubmitButtonLabelPublish' ) ? 'published' : 'saved';
|
|
|
|
}
|
2015-01-22 23:41:10 +00:00
|
|
|
mw.hook( 'postEdit' ).fire( {
|
2019-11-01 16:20:22 +00:00
|
|
|
// The following messages can be used here:
|
|
|
|
// * postedit-confirmation-published
|
|
|
|
// * postedit-confirmation-saved
|
|
|
|
// * postedit-confirmation-created
|
|
|
|
// * postedit-confirmation-restored
|
2018-03-27 15:36:41 +00:00
|
|
|
message: mw.msg( 'postedit-confirmation-' + notify, mw.user )
|
2015-01-22 23:41:10 +00:00
|
|
|
} );
|
|
|
|
|
2015-10-23 16:29:56 +00:00
|
|
|
delete uri.query.venotify;
|
2016-10-12 18:05:12 +00:00
|
|
|
// Get rid of the ?venotify= from the URL
|
|
|
|
if ( history.replaceState ) {
|
|
|
|
history.replaceState( null, document.title, uri );
|
|
|
|
}
|
2015-01-22 23:41:10 +00:00
|
|
|
}
|
2013-07-03 22:14:52 +00:00
|
|
|
} );
|
|
|
|
}() );
|