mirror of
https://github.com/php/web-doc-editor.git
synced 2026-03-24 09:12:07 +01:00
677 lines
25 KiB
JavaScript
677 lines
25 KiB
JavaScript
Ext.namespace('ui', 'ui.cmp', 'ui.cmp._RepositoryTree');
|
|
|
|
//------------------------------------------------------------------------------
|
|
// RepositoryTree internals
|
|
|
|
// RepositoryTree root node
|
|
ui.cmp._RepositoryTree.root = {
|
|
nodeType: 'async',
|
|
id: '/',
|
|
text: _('Repository'),
|
|
draggable: false
|
|
};
|
|
|
|
// RepositoryTree default tree loader
|
|
ui.cmp._RepositoryTree.loader = new Ext.tree.TreeLoader({
|
|
dataUrl: './do/getAllFiles'
|
|
});
|
|
|
|
// RepositoryTree : window to add a new file
|
|
ui.cmp._RepositoryTree.winAddNewFile = Ext.extend(Ext.Window, {
|
|
title: _('Add a new file'),
|
|
iconCls: 'iconFilesNeedTranslate',
|
|
id: 'win-add-new-file',
|
|
layout: 'form',
|
|
width: 350,
|
|
height: 170,
|
|
resizable: false,
|
|
modal: true,
|
|
bodyStyle: 'padding:5px 5px 0',
|
|
labelWidth: 150,
|
|
buttons: [{
|
|
id: 'win-add-new-file-btn',
|
|
text: _('Open the editor'),
|
|
disabled: true,
|
|
handler: function(){
|
|
var cmp = Ext.getCmp('win-add-new-file'), parentFolder = cmp.node.id, newFileName = cmp.items.items[1].getValue(), skeleton = cmp.items.items[2].getValue();
|
|
|
|
if (cmp.node.findChild("id", parentFolder + "/" + newFileName)) {
|
|
// This file already exist.
|
|
PhDOE.winForbidden('file_already_exist');
|
|
return true;
|
|
}
|
|
|
|
cmp.openFile(parentFolder + "/", newFileName, skeleton);
|
|
cmp.close();
|
|
return true;
|
|
|
|
}
|
|
}],
|
|
|
|
openFile: function(FilePath, FileName, skeleton){
|
|
var FileID = Ext.util.md5('FNT-' + FilePath + FileName), storeRecord = {
|
|
data: {
|
|
fileModified: false,
|
|
node: this.node
|
|
}
|
|
}, // simulate a needCommit option to fit with the classic comportement of FNT panel
|
|
t = FilePath.split('/'), FileLang;
|
|
|
|
t.shift();
|
|
|
|
FileLang = t[0];
|
|
|
|
t.shift();
|
|
t.pop();
|
|
|
|
FilePath = '/' + t.join('/') + '/';
|
|
if (FilePath === "//") {
|
|
FilePath = "/";
|
|
}
|
|
|
|
FileID = Ext.util.md5('FNT-' + FilePath + FileName);
|
|
|
|
// Render only if this tab don't exist yet
|
|
if (!Ext.getCmp('main-panel').findById('FNT-' + FileID)) {
|
|
|
|
Ext.getCmp('main-panel').add({
|
|
id: 'FNT-' + FileID,
|
|
layout: 'border',
|
|
title: FileName,
|
|
originTitle: FileName,
|
|
iconCls: 'iconTabNeedTranslate',
|
|
closable: true,
|
|
tabLoaded: false,
|
|
panTRANSLoaded: false,
|
|
panGGTRANSLoaded: true, // Simulate true for google translate panel
|
|
defaults: {
|
|
split: true
|
|
},
|
|
tabTip: String.format(_('New file: in {0}'), FileLang + FilePath),
|
|
items: [new ui.cmp.FilePanel({
|
|
id: 'FNT-NEW-PANEL-' + FileID,
|
|
region: 'center',
|
|
title: _('New file: ') + FileLang + FilePath + FileName,
|
|
isTrans: true,
|
|
prefix: 'FNT',
|
|
ftype: 'NEW',
|
|
fid: FileID,
|
|
fpath: FilePath,
|
|
fname: FileName,
|
|
lang: FileLang,
|
|
parser: 'xml',
|
|
storeRecord: storeRecord,
|
|
syncScrollCB: false,
|
|
syncScroll: false,
|
|
skeleton: skeleton
|
|
})]
|
|
});
|
|
}
|
|
Ext.getCmp('main-panel').setActiveTab('FNT-' + FileID);
|
|
},
|
|
|
|
initComponent: function(){
|
|
Ext.apply(this, {
|
|
items: [{
|
|
xtype: 'displayfield',
|
|
fieldLabel: _('Parent Folder'),
|
|
value: this.node.id
|
|
}, {
|
|
xtype: 'textfield',
|
|
fieldLabel: _('Name for the new file'),
|
|
name: 'newFolderName',
|
|
listeners: {
|
|
valid: function(){
|
|
Ext.getCmp('win-add-new-file-btn').enable();
|
|
},
|
|
invalid: function(){
|
|
Ext.getCmp('win-add-new-file-btn').disable();
|
|
}
|
|
}
|
|
}, {
|
|
xtype: 'combo',
|
|
triggerAction: 'all',
|
|
width: 160,
|
|
editable: false,
|
|
store: new Ext.data.Store({
|
|
proxy: new Ext.data.HttpProxy({
|
|
url: './do/getSkeletonsNames'
|
|
}),
|
|
reader: new Ext.data.JsonReader({
|
|
root: 'Items',
|
|
idProperty: 'name',
|
|
fields: [{
|
|
name: 'name'
|
|
}, {
|
|
name: 'path'
|
|
}]
|
|
})
|
|
}),
|
|
listeners: {
|
|
select: function(c, r, n){
|
|
// If we haven't set any name for this file, we put the name of the skeleton
|
|
if (c.ownerCt.items.items[1].getValue() === "") {
|
|
c.ownerCt.items.items[1].setValue(r.data.name);
|
|
}
|
|
|
|
}
|
|
},
|
|
valueField: 'path',
|
|
displayField: 'name',
|
|
fieldLabel: _('Chose a skeleton')
|
|
}]
|
|
});
|
|
ui.cmp._RepositoryTree.winAddNewFile.superclass.initComponent.call(this);
|
|
}
|
|
});
|
|
|
|
// RepositoryTree : window to add a new folder
|
|
ui.cmp._RepositoryTree.winAddNewFolder = Ext.extend(Ext.Window, {
|
|
title: _('Add a new folder'),
|
|
iconCls: 'iconFolderNew',
|
|
id: 'win-add-new-folder',
|
|
layout: 'form',
|
|
width: 350,
|
|
height: 200,
|
|
resizable: false,
|
|
modal: true,
|
|
bodyStyle: 'padding:5px 5px 0',
|
|
labelWidth: 150,
|
|
buttons: [{
|
|
id: 'win-add-new-folder-btn',
|
|
text: 'Add',
|
|
disabled: true,
|
|
handler: function(){
|
|
var cmp = Ext.getCmp('win-add-new-folder'),
|
|
parentFolder = cmp.node.id,
|
|
newFolderName = cmp.items.items[1].getValue();
|
|
|
|
XHR({
|
|
params: {
|
|
task: 'addNewFolder',
|
|
parentFolder: parentFolder,
|
|
newFolderName: newFolderName
|
|
},
|
|
success: function(){
|
|
Ext.getCmp('win-add-new-folder').close();
|
|
|
|
cmp.node.reload();
|
|
|
|
// Notify
|
|
PhDOE.notify('info', _('Folder created'), String.format(_('Folder <br><br><b>{0}</b><br><br> was created sucessfully under {1} !'), newFolderName, parentFolder));
|
|
},
|
|
failure: function(r){
|
|
//Ext.getCmp('win-add-new-folder').close();
|
|
var o = Ext.util.JSON.decode(r.responseText);
|
|
|
|
if (o.type) {
|
|
PhDOE.winForbidden(o.type);
|
|
}
|
|
else {
|
|
PhDOE.winForbidden();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}],
|
|
initComponent: function(){
|
|
Ext.apply(this, {
|
|
items: [{
|
|
xtype: 'displayfield',
|
|
fieldLabel: _('Parent Folder'),
|
|
value: this.node.id
|
|
}, {
|
|
xtype: 'textfield',
|
|
fieldLabel: _('Name for the new folder'),
|
|
name: 'newFolderName',
|
|
vtype: 'alphanum',
|
|
listeners: {
|
|
valid: function(){
|
|
Ext.getCmp('win-add-new-folder-btn').enable();
|
|
},
|
|
invalid: function(){
|
|
Ext.getCmp('win-add-new-folder-btn').disable();
|
|
}
|
|
}
|
|
}, {
|
|
xtype: 'box',
|
|
html: _('Info: This new folder won\'t be commited until a new file will be commited into it. If you don\'t commit any new file into it until 8 days, it will be automatically deleted.')
|
|
}]
|
|
});
|
|
ui.cmp._RepositoryTree.winAddNewFolder.superclass.initComponent.call(this);
|
|
}
|
|
});
|
|
|
|
Ext.namespace('ui.cmp._RepositoryTree.menu');
|
|
// RepositoryTree folder context menu
|
|
// config - { node }
|
|
ui.cmp._RepositoryTree.menu.folder = function(config){
|
|
Ext.apply(this, config);
|
|
this.init();
|
|
ui.cmp._RepositoryTree.menu.folder.superclass.constructor.call(this);
|
|
};
|
|
Ext.extend(ui.cmp._RepositoryTree.menu.folder, Ext.menu.Menu, {
|
|
init: function(){
|
|
Ext.apply(this, {
|
|
items: [{
|
|
text: (this.node.isExpanded()) ? '<b>' + _('Collapse') + '</b>' : '<b>' + _('Expand') + '</b>',
|
|
iconCls: 'iconFolderClose',
|
|
scope: this,
|
|
handler: function(){
|
|
if (this.node.isExpanded()) {
|
|
this.node.collapse();
|
|
}
|
|
else {
|
|
this.node.expand();
|
|
}
|
|
}
|
|
}, '-', {
|
|
text: _('Update this folder'),
|
|
disabled: true,
|
|
iconCls: 'iconFilesNeedUpdate',
|
|
scope: this,
|
|
handler: function(){
|
|
// We start by expand this node.
|
|
this.node.expand();
|
|
|
|
//... and fire the update processus
|
|
new ui.task.UpdateSingleFolderTask(this.node);
|
|
}
|
|
}, {
|
|
text: _('Add a new folder'),
|
|
iconCls: 'iconFolderNew',
|
|
hidden: (this.node.id === '/' ||
|
|
(Ext.util.Format.substr(this.node.id, 0, 3) !== '/en' && Ext.util.Format.substr(this.node.id, 0, 9) !== '/doc-base')), // Don't allow to add a new folder into root system & in others root folder than /en & /doc-base
|
|
scope: this,
|
|
handler: function(){
|
|
// We start by expand this node.
|
|
this.node.expand();
|
|
|
|
// We display the Add New Folder window
|
|
var win = new ui.cmp._RepositoryTree.winAddNewFolder({
|
|
node: this.node
|
|
});
|
|
win.show(this.node.ui.getEl());
|
|
}
|
|
}, {
|
|
text: _('Add a new file'),
|
|
iconCls: 'iconFilesNeedTranslate',
|
|
hidden: (this.node.id === '/' ||
|
|
(Ext.util.Format.substr(this.node.id, 0, 3) !== '/en' && Ext.util.Format.substr(this.node.id, 0, 9) !== '/doc-base')), // Don't allow to add a new folder into root system & in others root folder than /en & /doc-base
|
|
scope: this,
|
|
handler: function(){
|
|
// We start by expand this node.
|
|
this.node.expand();
|
|
|
|
// We display the Add New Folder window
|
|
var win = new ui.cmp._RepositoryTree.winAddNewFile({
|
|
node: this.node
|
|
});
|
|
win.show(this.node.ui.getEl());
|
|
}
|
|
}]
|
|
});
|
|
}
|
|
});
|
|
|
|
// RepositoryTree file context menu
|
|
// config - { node }
|
|
ui.cmp._RepositoryTree.menu.file = function(config){
|
|
Ext.apply(this, config);
|
|
this.init();
|
|
ui.cmp._RepositoryTree.menu.file.superclass.constructor.call(this);
|
|
};
|
|
Ext.extend(ui.cmp._RepositoryTree.menu.file, Ext.menu.Menu, {
|
|
init: function(){
|
|
var FileName = this.node.attributes.text, t = this.node.attributes.id.split('/'), FileLang, FilePath;
|
|
|
|
t.shift();
|
|
FileLang = t[0];
|
|
t.shift();
|
|
t.pop();
|
|
|
|
FilePath = t.join('/') + '/';
|
|
|
|
Ext.apply(this, {
|
|
items: [{
|
|
text: '<b>' + _('Edit in a new tab') + '</b>',
|
|
iconCls: 'iconTabNeedReviewed',
|
|
scope: this,
|
|
handler: function(){
|
|
ui.cmp._RepositoryTree.instance.fireEvent('dblclick', this.node);
|
|
}
|
|
}, {
|
|
hidden: (this.node.attributes.from === 'search' || PhDOE.user.lang === 'en'),
|
|
text: (FileLang === 'en') ? String.format(_('Open the same file in <b>{0}</b>'), Ext.util.Format.uppercase(PhDOE.user.lang)) : String.format(_('Open the same file in <b>{0}</b>'), 'EN'),
|
|
iconCls: 'iconTabNeedReviewed',
|
|
scope: this,
|
|
handler: function(){
|
|
if (FileLang === 'en') {
|
|
ui.cmp._RepositoryTree.instance.openFile('byPath', PhDOE.user.lang + '/' + FilePath, FileName);
|
|
}
|
|
else {
|
|
ui.cmp._RepositoryTree.instance.openFile('byPath', 'en/' + FilePath, FileName);
|
|
}
|
|
}
|
|
}]
|
|
});
|
|
}
|
|
});
|
|
|
|
//------------------------------------------------------------------------------
|
|
// RepositoryTree
|
|
ui.cmp.RepositoryTree = Ext.extend(Ext.ux.MultiSelectTreePanel, {
|
|
animate: true,
|
|
enableDD: true,
|
|
ddGroup: 'mainPanelDDGroup',
|
|
useArrows: true,
|
|
autoScroll: true,
|
|
border: false,
|
|
containerScroll: true,
|
|
root: ui.cmp._RepositoryTree.root,
|
|
loader: ui.cmp._RepositoryTree.loader,
|
|
|
|
onContextMenu: function(node, e){
|
|
e.stopEvent();
|
|
node.select();
|
|
|
|
if (node.attributes.type === 'folder' || node.isRoot) {
|
|
new ui.cmp._RepositoryTree.menu.folder({
|
|
node: node
|
|
}).showAt(e.getXY());
|
|
}
|
|
else
|
|
if (node.attributes.type === 'file') {
|
|
new ui.cmp._RepositoryTree.menu.file({
|
|
node: node
|
|
}).showAt(e.getXY());
|
|
}
|
|
},
|
|
|
|
onDblClick: function(node){
|
|
if (node.attributes.type === 'file') // files only
|
|
{
|
|
this.openFile('byId', node.attributes.id, false);
|
|
}
|
|
},
|
|
|
|
openFile: function(ftype, first, second){
|
|
|
|
// Here, first argument is fpath and second, fname
|
|
if (ftype === 'byPath') {
|
|
Ext.getCmp('acc-all-files').expand();
|
|
|
|
var fpath = first, fname = second, t = fpath.split('/'), cb = function(node){
|
|
node.ensureVisible();
|
|
if (t[0] && t[0] !== '') {
|
|
// walk into childs
|
|
for (var j = 0; j < node.childNodes.length; ++j) {
|
|
if (node.childNodes[j].text === t[0]) {
|
|
t.shift();
|
|
node.childNodes[j].expand(false, true, cb.createDelegate(this));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// leaf node
|
|
for (var i = 0; i < node.childNodes.length; ++i) {
|
|
if (node.childNodes[i].text === fname) {
|
|
node.childNodes[i].ensureVisible();
|
|
node.childNodes[i].ui.highlight();
|
|
this.openFile('byId', node.childNodes[i].id, false);
|
|
//this.fireEvent('dblclick', node.childNodes[i]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
this.root.expand(false, true, cb.createDelegate(this));
|
|
}
|
|
|
|
// Here, first argument is a nodeID. Second arguments don't exist
|
|
if (ftype === 'byId') {
|
|
var node = this.getNodeById(first), FilePath = node.attributes.id, extension = node.attributes.extension, t, FileID, FileLang, FileName, parser, panelWest, panelCenter;
|
|
|
|
// CleanUp the path
|
|
t = FilePath.split('/');
|
|
t.shift();
|
|
|
|
FileName = t.pop();
|
|
|
|
FileLang = t.shift();
|
|
FilePath = (t.length > 0) ? '/' + t.join('/') + '/' : '/';
|
|
|
|
FileID = Ext.util.md5('AF-' + FileLang + FilePath + FileName);
|
|
|
|
// Render only if this tab don't exist yet
|
|
if (!Ext.getCmp('main-panel').findById('AF-' + FileID)) {
|
|
|
|
if (extension !== 'html') {
|
|
parser = extension;
|
|
}
|
|
else {
|
|
parser = 'xml';
|
|
}
|
|
|
|
if (extension === 'gif' || extension === 'png' || extension === 'jpg') {
|
|
panelWest = {};
|
|
|
|
panelCenter = {
|
|
id: 'AF' + '-ALL-FILE-' + FileID, // We fake the content ID to allow closing this panel
|
|
xtype: 'panel',
|
|
region: 'center',
|
|
layout: 'fit',
|
|
bodyStyle: 'padding:5px 5px 0',
|
|
html: '<img src="./do/getImageContent?' +
|
|
'FileLang=' +
|
|
FileLang +
|
|
'&' +
|
|
'FilePath=' +
|
|
FilePath +
|
|
'&' +
|
|
'FileName=' +
|
|
FileName +
|
|
'&' +
|
|
'csrfToken=' +
|
|
csrfToken +
|
|
'" />'
|
|
};
|
|
|
|
}
|
|
else {
|
|
|
|
panelWest = {
|
|
xtype: 'panel',
|
|
region: 'west',
|
|
title: _('Tools'),
|
|
iconCls: 'iconConf',
|
|
collapsedIconCls: 'iconConf',
|
|
plugins: [Ext.ux.PanelCollapsedTitle],
|
|
layout: 'fit',
|
|
bodyBorder: false,
|
|
split: true,
|
|
collapsible: true,
|
|
collapsed: !PhDOE.user.conf.allFiles.toolsPanelDisplay,
|
|
width: PhDOE.user.conf.allFiles.toolsPanelWidth || 375,
|
|
listeners: {
|
|
collapse: function(){
|
|
if (this.ownerCt.tabLoaded) {
|
|
new ui.task.UpdateConfTask({
|
|
module : 'allFiles',
|
|
itemName : 'toolsPanelDisplay',
|
|
value: false,
|
|
notify: false
|
|
});
|
|
}
|
|
},
|
|
expand: function(){
|
|
if (this.ownerCt.tabLoaded) {
|
|
new ui.task.UpdateConfTask({
|
|
module : 'allFiles',
|
|
itemName : 'toolsPanelDisplay',
|
|
value: true,
|
|
notify: false
|
|
});
|
|
}
|
|
},
|
|
resize: function(a, newWidth){
|
|
if (this.ownerCt.tabLoaded && newWidth && newWidth != PhDOE.user.conf.allFiles.toolsPanelWidth) { // As the type is different, we can't use !== to compare with !
|
|
new ui.task.UpdateConfTask({
|
|
module : 'allFiles',
|
|
itemName : 'toolsPanelWidth',
|
|
value: newWidth,
|
|
notify: false
|
|
});
|
|
}
|
|
}
|
|
},
|
|
items: {
|
|
xtype: 'tabpanel',
|
|
activeTab: 0,
|
|
defaults: {
|
|
autoScroll: true
|
|
},
|
|
items: [{
|
|
title: _('Log'),
|
|
layout: 'fit',
|
|
items: [new ui.cmp.VCSLogGrid({
|
|
prefix: 'AF',
|
|
fid: FileID,
|
|
fpath: FileLang + FilePath,
|
|
fname: FileName,
|
|
loadStore: PhDOE.user.conf.allFiles.toolsPanelLogLoad
|
|
})]
|
|
}, {
|
|
title: _('Entities'),
|
|
layout: 'fit',
|
|
items: [new ui.cmp.EntitiesAcronymsPanel({
|
|
dataType: 'entities',
|
|
prefix: 'AF',
|
|
ftype: 'ALL',
|
|
fid: FileID,
|
|
loadStore: PhDOE.user.conf.allFiles.toolsPanelEntitiesLoad
|
|
})]
|
|
}, {
|
|
title: _('Acronyms'),
|
|
layout: 'fit',
|
|
items: [new ui.cmp.EntitiesAcronymsPanel({
|
|
dataType: 'acronyms',
|
|
prefix: 'AF',
|
|
ftype: 'ALL',
|
|
fid: FileID,
|
|
loadStore: PhDOE.user.conf.allFiles.toolsPanelAcronymsLoad
|
|
})]
|
|
}]
|
|
}
|
|
};
|
|
|
|
panelCenter = new ui.cmp.FilePanel({
|
|
id: 'AF' + '-ALL-PANEL-' + FileID,
|
|
region: 'center',
|
|
title: _('File: ') + FileLang + FilePath + FileName,
|
|
prefix: 'AF',
|
|
ftype: 'ALL',
|
|
spellCheck: PhDOE.user.conf.allFiles.enableSpellCheck,
|
|
spellCheckConf: {module : 'allFiles', itemName : 'enableSpellCheck'},
|
|
fid: FileID,
|
|
fpath: FilePath,
|
|
fname: FileName,
|
|
lang: FileLang,
|
|
parser: parser,
|
|
storeRecord: node,
|
|
syncScrollCB: false,
|
|
syncScroll: false
|
|
});
|
|
}
|
|
|
|
Ext.getCmp('main-panel').add({
|
|
id: 'AF-' + FileID,
|
|
layout: 'border',
|
|
title: FileName,
|
|
originTitle: FileName,
|
|
closable: true,
|
|
tabLoaded: false,
|
|
panEntities: !PhDOE.user.conf.allFiles.toolsPanelEntitiesLoad,
|
|
panAcronyms: !PhDOE.user.conf.allFiles.toolsPanelAcronymsLoad,
|
|
panVCS: !PhDOE.user.conf.allFiles.toolsPanelLogLoad,
|
|
panLoaded: false,
|
|
tabTip: String.format(_('in {0}'), FilePath),
|
|
iconCls: 'iconAllFiles',
|
|
items: [panelCenter, panelWest]
|
|
});
|
|
}
|
|
Ext.getCmp('main-panel').setActiveTab('AF-' + FileID);
|
|
}
|
|
},
|
|
|
|
initComponent: function(){
|
|
Ext.apply(this, {
|
|
tbar: [_('Search: '), ' ', new Ext.form.TwinTriggerField({
|
|
id: 'AF-search',
|
|
validationEvent: false,
|
|
validateOnBlur: false,
|
|
trigger1Class: 'x-form-clear-trigger',
|
|
trigger2Class: 'x-form-search-trigger',
|
|
hideTrigger1: true,
|
|
width: 180,
|
|
enableKeyEvents: true,
|
|
listeners: {
|
|
keypress: function(field, e){
|
|
if (e.getKey() === e.ENTER) {
|
|
this.onTrigger2Click();
|
|
}
|
|
}
|
|
},
|
|
onTrigger1Click: function(){
|
|
var instance = ui.cmp._RepositoryTree.instance;
|
|
this.setValue('');
|
|
this.triggers[0].hide();
|
|
this.setSize(180, 10);
|
|
instance.root.setText(_('Repository'));
|
|
|
|
// clear search
|
|
delete instance.loader.baseParams.search;
|
|
instance.root.reload();
|
|
},
|
|
onTrigger2Click: function(){
|
|
var instance = ui.cmp._RepositoryTree.instance, v = this.getValue();
|
|
|
|
if (v === '' || v.length < 3) {
|
|
this.markInvalid(_('Your search must contain at least 3 characters'));
|
|
return;
|
|
}
|
|
this.clearInvalid();
|
|
|
|
this.triggers[0].show();
|
|
this.setSize(180, 10);
|
|
|
|
// carry search
|
|
instance.loader.baseParams.search = v;
|
|
instance.root.reload(function(){
|
|
instance.root.setText(String.format(_('Search result: {0}'), instance.root.childNodes.length));
|
|
});
|
|
}
|
|
})]
|
|
});
|
|
ui.cmp.RepositoryTree.superclass.initComponent.call(this);
|
|
|
|
this.on('contextmenu', this.onContextMenu, this);
|
|
this.on('dblclick', this.onDblClick, this);
|
|
|
|
new Ext.tree.TreeSorter(this, {
|
|
folderSort: true
|
|
});
|
|
}
|
|
});
|
|
|
|
// singleton
|
|
ui.cmp._RepositoryTree.instance = null;
|
|
ui.cmp.RepositoryTree.getInstance = function(config){
|
|
if (!ui.cmp._RepositoryTree.instance) {
|
|
if (!config) {
|
|
config = {};
|
|
}
|
|
ui.cmp._RepositoryTree.instance = new ui.cmp.RepositoryTree(config);
|
|
}
|
|
return ui.cmp._RepositoryTree.instance;
|
|
};
|