338 lines
9.9 KiB
JavaScript
338 lines
9.9 KiB
JavaScript
/*!
|
|
* @file app.js
|
|
*
|
|
* @brief
|
|
* JSONEditor is an editor to display and edit JSON data in a treeview.
|
|
*
|
|
* Supported browsers: Chrome, Firefox, Safari, Opera, Internet Explorer 8+
|
|
*
|
|
* @license
|
|
* This json editor is open sourced with the intention to use the editor as
|
|
* a component in your own application. Not to just copy and monetize the editor
|
|
* as it is.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
* use this file except in compliance with the License. You may obtain a copy
|
|
* of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*
|
|
* Copyright (C) 2011-2013 Jos de Jong, http://jsoneditoronline.org
|
|
*
|
|
* @author Jos de Jong, <wjosdejong@gmail.com>
|
|
* @date 2013-01-05
|
|
*/
|
|
|
|
|
|
var editor = null;
|
|
var formatter = null;
|
|
|
|
var app = {};
|
|
|
|
/**
|
|
* Get the JSON from the formatter and load it in the editor
|
|
*/
|
|
app.formatterToEditor = function() {
|
|
try {
|
|
editor.set(formatter.get());
|
|
}
|
|
catch (err) {
|
|
app.notify.showError(err);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get the JSON from the editor and load it into the formatter
|
|
*/
|
|
app.editorToFormatter = function () {
|
|
try {
|
|
formatter.set(editor.get());
|
|
}
|
|
catch (err) {
|
|
app.notify.showError(err);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Load the interface (editor, formatter, splitter)
|
|
*/
|
|
// TODO: split the method load in multiple methods, it is too large
|
|
app.load = function() {
|
|
try {
|
|
// notification handler
|
|
app.notify = new Notify();
|
|
|
|
// retriever for loading/saving files
|
|
app.retriever = new FileRetriever({
|
|
scriptUrl: 'fileretriever.php',
|
|
notify: app.notify
|
|
});
|
|
|
|
// default json document
|
|
var json = {
|
|
"array": [1, 2, 3],
|
|
"boolean": true,
|
|
"null": null,
|
|
"number": 123,
|
|
"object": {"a": "b", "c": "d", "e": "f"},
|
|
"string": "Hello World"
|
|
};
|
|
|
|
// load url if query parameters contains a url
|
|
if (window.QueryParams) {
|
|
var qp = new QueryParams();
|
|
var url = qp.getValue('url');
|
|
if (url) {
|
|
json = {};
|
|
app.openUrl(url);
|
|
}
|
|
}
|
|
|
|
// Store whether editor or formatter is last changed
|
|
app.lastChanged = undefined;
|
|
|
|
// formatter
|
|
var container = document.getElementById("jsonformatter");
|
|
formatter = new jsoneditor.JSONFormatter(container, {
|
|
change: function () {
|
|
app.lastChanged = formatter;
|
|
}
|
|
});
|
|
formatter.set(json);
|
|
formatter.onError = function (err) {
|
|
app.notify.showError(err);
|
|
};
|
|
|
|
// editor
|
|
container = document.getElementById("jsoneditor");
|
|
editor = new jsoneditor.JSONEditor(container, {
|
|
change: function () {
|
|
app.lastChanged = editor;
|
|
}, mode:'form'
|
|
});
|
|
editor.set(json);
|
|
// TODO: automatically synchronize data of formatter and editor? (editor should keep its state though)
|
|
|
|
// splitter
|
|
var domSplitter = document.getElementById('splitter');
|
|
app.splitter = new Splitter({
|
|
container: domSplitter,
|
|
change: function () {
|
|
app.resize();
|
|
}
|
|
});
|
|
|
|
// button Formatter-to-Editor
|
|
domSplitter.appendChild(document.createElement('br'));
|
|
domSplitter.appendChild(document.createElement('br'));
|
|
domSplitter.appendChild(document.createElement('br'));
|
|
var toForm = document.createElement('button');
|
|
toForm.id = 'toForm';
|
|
toForm.title = 'JSON to Editor';
|
|
toForm.className = 'convert';
|
|
toForm.innerHTML = '<div class="convert-right"></div>';
|
|
toForm.onclick = function () {
|
|
this.focus();
|
|
app.formatterToEditor();
|
|
};
|
|
domSplitter.appendChild(toForm);
|
|
|
|
// button Editor-to-Formatter
|
|
domSplitter.appendChild(document.createElement('br'));
|
|
domSplitter.appendChild(document.createElement('br'));
|
|
var toJSON = document.createElement('button');
|
|
toJSON.id = 'toJSON';
|
|
toJSON.title = 'Editor to JSON';
|
|
toJSON.className = 'convert';
|
|
toJSON.innerHTML = '<div class="convert-left"></div>';
|
|
toJSON.onclick = function () {
|
|
this.focus();
|
|
app.editorToFormatter();
|
|
};
|
|
domSplitter.appendChild(toJSON);
|
|
|
|
// web page resize handler
|
|
jsoneditor.util.addEventListener(window, 'resize', app.resize);
|
|
|
|
// clear button
|
|
var domClear = document.getElementById('clear');
|
|
domClear.onclick = app.clearFile;
|
|
|
|
/* TODO: enable clicking on open to execute the default, "open file"
|
|
// open button
|
|
var domOpen = document.getElementById('open');
|
|
var domOpenMenuButton = document.getElementById('openMenuButton');
|
|
domOpen.onclick = function (event) {
|
|
event = event || window.event; // for IE8
|
|
var target = event.target || event.srcElement;
|
|
if (target == domOpenMenuButton ||
|
|
(event.offsetX > domOpen.offsetWidth - domOpenMenuButton.offsetWidth)) {
|
|
// clicked on the menu button
|
|
}
|
|
else {
|
|
app.openFile();
|
|
}
|
|
};
|
|
*/
|
|
|
|
// menu button open file
|
|
var domMenuOpenFile = document.getElementById('menuOpenFile');
|
|
domMenuOpenFile.onclick = function (event) {
|
|
app.openFile();
|
|
jsoneditor.util.stopPropagation(event);
|
|
jsoneditor.util.preventDefault(event);
|
|
};
|
|
|
|
// menu button open url
|
|
var domMenuOpenUrl = document.getElementById('menuOpenUrl');
|
|
domMenuOpenUrl.onclick = function (event) {
|
|
app.openUrl();
|
|
jsoneditor.util.stopPropagation(event);
|
|
jsoneditor.util.preventDefault(event);
|
|
};
|
|
|
|
// save button
|
|
var domSave = document.getElementById('save');
|
|
domSave.onclick = app.saveFile;
|
|
|
|
// TODO: implement a focus method
|
|
formatter.textarea.focus();
|
|
|
|
// enforce FireFox to not do spell checking on any input field
|
|
document.body.spellcheck = false;
|
|
} catch (err) {
|
|
app.notify.showError(err);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Callback method called when a file or url is opened.
|
|
* @param {Error} err
|
|
* @param {String} data
|
|
*/
|
|
app.openCallback = function (err, data) {
|
|
if (!err) {
|
|
if (data != undefined) {
|
|
formatter.setText(data);
|
|
try {
|
|
var json = jsoneditor.util.parse(data);
|
|
editor.set(json);
|
|
}
|
|
catch (err) {
|
|
editor.set({});
|
|
app.notify.showError(err);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
app.notify.showError(err);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Open a file explorer to select a file and open the file
|
|
*/
|
|
app.openFile = function() {
|
|
app.retriever.loadFile(app.openCallback);
|
|
};
|
|
|
|
/**
|
|
* Open a url. If no url is provided as parameter, a dialog will be opened
|
|
* to select a url.
|
|
* @param {String} [url]
|
|
*/
|
|
app.openUrl = function (url) {
|
|
if (!url) {
|
|
app.retriever.loadUrlDialog(app.openCallback);
|
|
}
|
|
else {
|
|
app.retriever.loadUrl(url, app.openCallback);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Open a file explorer to save the file.
|
|
*/
|
|
app.saveFile = function () {
|
|
// first synchronize the editors and formatters contents
|
|
if (app.lastChanged == editor) {
|
|
app.editorToFormatter();
|
|
}
|
|
/* TODO: also sync from formatter to editor? will clear the history ...
|
|
if (app.lastChanged == formatter) {
|
|
app.formatterToEditor();
|
|
}
|
|
*/
|
|
app.lastChanged = undefined;
|
|
|
|
// save the text from the formatter
|
|
// TODO: show a 'saving...' notification
|
|
var data = formatter.getText();
|
|
app.retriever.saveFile(data, function (err) {
|
|
if (err) {
|
|
app.notify.showError(err);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Clear the current file
|
|
*/
|
|
app.clearFile = function () {
|
|
var json = {};
|
|
formatter.set(json);
|
|
editor.set(json);
|
|
};
|
|
|
|
app.resize = function() {
|
|
var domEditor = document.getElementById('jsoneditor');
|
|
var domFormatter = document.getElementById('jsonformatter');
|
|
var domSplitter = document.getElementById('splitter');
|
|
var domAd = document.getElementById('ad');
|
|
var domAdInfo = document.getElementById('adInfo');
|
|
|
|
var width = window.innerWidth || document.body.offsetWidth || document.documentElement.offsetWidth;
|
|
var height = window.innerHeight || document.body.offsetHeight || document.documentElement.offsetHeight;
|
|
var adWidth = domAd ? domAd.clientWidth : 0;
|
|
var splitterWidth = domSplitter.clientWidth;
|
|
if (adWidth) {
|
|
width -= (adWidth + 15); // Not so nice, +15 here for the margin
|
|
}
|
|
|
|
if (app.splitter) {
|
|
var splitterLeft = width * app.splitter.getValue();
|
|
|
|
// resize formatter
|
|
domFormatter.style.width = Math.round(splitterLeft) + 'px';
|
|
|
|
// resize editor
|
|
// the width has a -1 to prevent the width from being just half a pixel
|
|
// wider than the window, causing the content elements to wrap...
|
|
domEditor.style.left = Math.round(splitterLeft + splitterWidth) + 'px';
|
|
domEditor.style.width = Math.round(width - splitterLeft - splitterWidth - 1) + 'px';
|
|
}
|
|
|
|
// resize ad text
|
|
if (domAdInfo && domAd) {
|
|
var infoHeight = domAdInfo.clientHeight;
|
|
domAd.style.paddingTop = infoHeight + 'px';
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Hide the advertisement
|
|
*/
|
|
app.hideAds = function() {
|
|
var domAd = document.getElementById("ad");
|
|
if (domAd) {
|
|
domAd.parentNode.removeChild(domAd);
|
|
app.resize();
|
|
}
|
|
};
|