rwiki 0.2.4 → 0.2.5

data/public/javascripts/Rwiki/Tabs/PageTab.js

@@ -0,0 +1,47 @@
+Ext.ns('Rwiki.Tabs');
+
+Rwiki.Tabs.PageTab = Ext.extend(Ext.Container, {
+  constructor: function() {
+    Ext.apply(this, {
+      closable: true,
+      cls: 'page-container',
+      iconCls: 'icon-page'
+    });
+
+    Rwiki.Tabs.PageTab.superclass.constructor.apply(this, arguments);
+  },
+
+  setPage: function(page) {
+    this._page = page;
+  },
+
+  getPage: function() {
+    return this._page;
+  },
+
+  setTitle: function(title) {
+    $(this.tabEl).find('.x-tab-strip-text').text(title);
+  },
+
+  setContent: function(content) {
+    var pageContainer = this.getPageContainer();
+    pageContainer.html(content);
+  },
+
+  show: function() {
+    Rwiki.Tabs.PageTab.superclass.show.apply(this, arguments);
+
+    this.setTitle(this._page.getTitle());
+    this.setContent(this._page.getHtmlContent());
+
+    Rwiki.statusBar.clearStatus({ useDefaults: true });
+  },
+
+  getPagePath: function() {
+    return this._page.getPath();
+  },
+
+  getPageContainer: function() {
+    return $('#' + this.id);
+  }
+});

data/public/javascripts/Rwiki/Tabs/Toolbar.js

@@ -0,0 +1,101 @@
+Ext.ns('Rwiki.Tabs');
+
+Rwiki.Tabs.Toolbar = Ext.extend(Ext.Toolbar, {
+
+  initComponent: function() {
+    this.editPageButton = new Rwiki.Button({
+      text: 'Edit page',
+      iconCls: 'icon-edit',
+      scope: this,
+      handler: this.onEditPage,
+      disabled: true
+    });
+
+    this.printPageButton = new Rwiki.Button({
+      text: 'Print page',
+      iconCls: 'icon-print',
+      scope: this,
+      handler: this.onPrintPage,
+      disabled: true
+    });
+
+    this.findPageButton = new Rwiki.Button({
+      text: 'Find page',
+      iconCls: 'icon-search',
+      scope: this,
+      handler: this.onFuzzyFinder
+    });
+
+    this.findTextButton = new Rwiki.Button({
+      text: 'Text search',
+      iconCls: 'icon-search',
+      scope: this,
+      handler: this.onTextSearch
+    });
+
+    this.aboutButton = new Rwiki.Button({
+      text: 'About',
+      iconCls: 'icon-about',
+      scope: this,
+      handler: this.onAbout
+    });
+
+    Ext.apply(this, {
+      enableOverflow: true,
+      items: [
+        this.editPageButton,
+        this.printPageButton,
+        '-',
+        this.findPageButton,
+        this.findTextButton,
+        '->',
+        this.aboutButton
+      ]
+    });
+
+    Rwiki.Tabs.Toolbar.superclass.initComponent.apply(this, arguments);
+  },
+
+  initEvents: function() {
+    Rwiki.Tabs.Toolbar.initEvents.appy(this, arguments);
+    this.addEvents('rwiki:toolbar:editPage', 'rwiki:toolbar:printPage');
+  },
+
+  enablePageRelatedItems: function(){
+    this.editPageButton.setDisabled(false);
+    this.printPageButton.setDisabled(false);
+  },
+
+  disablePageRelatedItems: function() {
+    this.editPageButton.setDisabled(true);
+    this.printPageButton.setDisabled(true);
+  },
+
+  onEditPage: function() {
+    this.fireEvent('rwiki:toolbar:editPage');
+  },
+
+  onPrintPage: function() {
+    this.fireEvent('rwiki:Toolbar:printPage');
+  },
+
+  onFuzzyFinder: function() {
+    var fuzzyFinder = new Rwiki.Search.FuzzyFinderWindow();
+    fuzzyFinder.show();
+  },
+
+  onTextSearch: function() {
+    var textSearch = new Rwiki.Search.TextSearchWindow();
+    textSearch.show();
+  },
+
+  onAbout: function() {
+    if (!this.aboutDialog) {
+      this.aboutDialog = new Rwiki.AboutDialog();
+    }
+
+    this.aboutDialog.show();
+  }
+
+});
+

data/public/javascripts/Rwiki/TocPanel.js

@@ -0,0 +1,55 @@
+Ext.ns('Rwiki');
+
+Rwiki.TocPanel = Ext.extend(Ext.Panel, {
+  constructor: function() {
+    this._current_page_path = null;
+    this._default_content = 'When you select a page from the tree, the Table of Content will be displayed here.';
+    this._page_without_toc_content = 'This page does not have any sections.';
+
+    Ext.apply(this, {
+      id: 'toc-panel',
+      title: 'Table of Content',
+      region: 'south',
+      split: true,
+      height: 300,
+      bodyStyle: 'padding-bottom:15px;background:#eee;',
+      autoScroll: true,
+      html: '<div id="toc-container"></div>'
+    });
+
+    Rwiki.TocPanel.superclass.constructor.apply(this, arguments);
+
+    this.relayEvents(Rwiki.tabPanel, ['tabchange'])
+    this.relayEvents(Rwiki.Data.PageManager.getInstance(), ['rwiki:pageSaved']);
+
+    this.on('tabchange', function(panel, tab) {
+      if (tab) {
+        var page = tab.getPage();
+        this._setContent(page.getHtmlToc());
+      } else {
+        // the last tab was closed
+        this._setContent(this._default_content);
+      }
+    });
+
+    this.on('rwiki:pageSaved', function(page) {
+      this._setContent(page.getHtmlToc());
+    });
+  },
+
+  render: function() {
+    Rwiki.TocPanel.superclass.render.apply(this, arguments);
+    this._setContent(this._default_content);
+  },
+
+  _setContent: function(content) {
+    var container = Ext.get('toc-container');
+
+    if (content != '') {
+      container.update(content);
+    } else {
+      container.update(this._page_without_toc_content);
+    }
+  }
+});
+

data/public/javascripts/Rwiki/Tree/Loader.js

@@ -0,0 +1,23 @@
+Ext.ns('Rwiki.Tree');
+
+Rwiki.Tree.Loader = Ext.extend(Ext.tree.TreeLoader, {
+  constructor: function() {
+    Ext.apply(this, {
+      preloadChildren: true,
+      clearOnLoad: false
+    });
+
+    Rwiki.Tree.Loader.superclass.constructor.apply(this, arguments);
+
+    // pass extra parameters
+    this.on('beforeload', function(loader, node) {
+      loader.baseParams = {
+        path: node.getPath()
+      };
+    });
+  },
+
+  createNode: function(attr) {
+    return new Rwiki.Tree.Node(attr);
+  }
+});

data/public/javascripts/Rwiki/Tree/Menu.js

@@ -0,0 +1,100 @@
+Ext.ns('Rwiki.Tree');
+
+Rwiki.Tree.Menu = Ext.extend(Ext.menu.Menu, {
+  constructor: function() {
+    Ext.apply(this, {
+      id: 'feeds-ctx',
+      items: [{
+        text: 'Add page',
+        id: 'add-page',
+        iconCls: 'icon-add-page',
+        scope: this,
+        handler: this.onCreatePage
+      }, '-',  {
+        text: 'Rename page',
+        id: 'rename-page',
+        iconCls: 'icon-rename-page',
+        scope: this,
+        handler: this.onRenameNode
+      }, {
+        text: 'Delete page',
+        id: 'delete-page',
+        iconCls: 'icon-delete-page',
+        scope: this,
+        handler: this.onDeleteNode
+      }]
+    });
+
+    Rwiki.Tree.Menu.superclass.constructor.apply(this, arguments);
+  },
+
+  show: function(node, xy) {
+    this.node = node;
+    node.select();
+
+    this.setItemDisabled('delete-page', node.isRoot);
+    this.setItemDisabled('rename-page', node.isRoot);
+
+    this.showAt(xy);
+  },
+
+  onCreatePage: function() {
+    var parentNode = this.node;
+
+    var callback = function(button, name) {
+      if (button !== 'ok') {
+        return;
+      }
+
+      var parentPath = parentNode.getPath();
+      Rwiki.nodeManager.createPage(parentPath, name);
+    }
+
+    Ext.MessageBox.prompt('Add page', 'New page name:', callback);
+  },
+
+  onRenameNode: function() {
+    var node = this.node;
+    if (node.isRoot) {
+      return;
+    }
+
+    var oldPath = node.getPath();
+    var oldBaseName = node.text;
+
+    var callback = function(button, newName) {
+      if (button !== 'ok') {
+        return;
+      }
+
+      Rwiki.nodeManager.renameNode(oldPath, newName);
+    };
+
+    Ext.MessageBox.prompt('Rename page', 'Enter a new name:', callback, this, false, oldBaseName);
+  },
+
+  onDeleteNode: function() {
+    var node = this.node;
+    if (node.isRoot) {
+      return;
+    }
+
+    var path = node.getPath();
+
+    var callback = function(button) {
+      if (button !== 'yes') {
+        return;
+      }
+
+      Rwiki.nodeManager.deleteNode(path);
+    };
+
+    var message = 'Delete "' + path + '"?';
+    Ext.MessageBox.confirm('Confirm', message, callback);
+  },
+
+  setItemDisabled: function(id, disabled) {
+    var item = this.findById(id);
+    item.setDisabled(disabled);
+  }
+});

data/public/javascripts/Rwiki/Tree/Node.js

@@ -0,0 +1,83 @@
+Ext.ns('Rwiki.Tree');
+
+Rwiki.Tree.Node = Ext.extend(Ext.tree.TreeNode, {
+
+  constructor: function(config) {
+    config = Ext.apply({
+      cls: 'rwiki-tree-node',
+      iconCls: 'icon-page'
+    }, config);
+
+    Rwiki.Tree.Node.superclass.constructor.call(this, config);
+
+    this.on('beforemove', function(tree, node, oldParent, newParent) {
+      // do not allow to move a node to the same parent
+      return oldParent !== newParent;
+    });
+  },
+
+  getPath: function() {
+    return Rwiki.Tree.Node.superclass.getPath.call(this, 'text');
+  },
+
+  getName: function() {
+    return this.text;
+  },
+
+  expandAllParents: function() {
+    var nodes = [];
+
+    this.bubble(function(n) {
+      nodes.push(n);
+    });
+
+    nodes = nodes.reverse();
+
+    var i;
+    for (i = 0, len = nodes.length; i < len; i++) {
+      var node = nodes[i];
+
+      var isNotACurrNode = node !== this;
+      if (isNotACurrNode && node.isExpandable()) {
+        node.expand(false);
+      }
+    }
+  },
+
+  expandAll: function() {
+    if (this.isExpandable()) {
+      this.expand();
+      var cs = this.childNodes;
+      var i;
+      for (i = 0, len = cs.length; i < len; i++) {
+        cs[i].expandAll();
+      }
+    }
+  },
+
+  /**
+   * Better version of cascade function.
+   * It can iterate through collapsed nodes.
+   * @see cascade
+   */
+  cascadeAll: function(fn, scope, args) {
+    var wasCollapsed = this.isExpandable() && !this.isExpanded();
+
+    if (wasCollapsed) {
+      this.expand(false, false);
+    }
+
+    if (fn.apply(scope || this, args || [this])) {
+      var cs = this.childNodes;
+
+      for (var i = 0, len = cs.length; i < len; i++) {
+        cs[i].cascadeAll(fn, scope, args);
+      }
+    }
+
+    if (wasCollapsed) {
+      this.collapse(false, false);
+    }
+  }
+
+});

data/public/javascripts/Rwiki/TreePanel.js

@@ -1,61 +1,53 @@
 Ext.ns('Rwiki');
 
 Rwiki.TreePanel = Ext.extend(Ext.tree.TreePanel, {
-  constructor: function() {
-    var toolbar = new Rwiki.TreePanel.Toolbar();
 
+  constructor: function() {
     Ext.apply(this, {
       id: 'tree',
+      title: 'Navigation panel',
       region: 'center',
+      height: 400,
+      minSize: 150,
       autoScroll: true,
 
       animate: true,
       useArrows: true,
       rootVisible: true,
-      loader: new Rwiki.TreePanel.Loader(),
+      loader: new Rwiki.Tree.Loader(),
 
       enableDD: true,
       dropConfig: {
         appendOnly: true
       },
 
-      root: new Rwiki.TreePanel.Node({
+      root: new Rwiki.Tree.Node({
         nodeType: 'async',
         text: Rwiki.rootFolderName,
         draggable: false,
-        baseName: '.'
-      }),
-
-      tbar: toolbar
+        children: Rwiki.nodes
+      })
     });
 
     Rwiki.TreePanel.superclass.constructor.apply(this, arguments);
 
-    this.contextMenu = new Rwiki.TreePanel.Menu();
-    this.on('contextmenu', this.onContextMenu, this);
-
-    this.filter = new Rwiki.TreePanel.Filter(this);
-    this.root.expand();
-
+    this.loader.load(this.root);
     new Ext.tree.TreeSorter(this, {
-      folderSort: true
+      folderSort: false
     });
 
-    var self = this;
+    this.contextMenu = new Rwiki.Tree.Menu();
+    this.on('contextmenu', this.onContextMenu, this);
 
-    toolbar.on('expandAll', function() {
-      self.root.expandChildNodes(true);
-    });
+    this.addEvents('rwiki:pageSelected');
 
-    toolbar.on('collapseAll', function() {
-      self.root.collapseChildNodes(true);
-    });
+    this.on('nodedragover', function(e) {
+      var newParent = e.target;
+      var node = e.dropNode;
 
-    toolbar.on('filterFieldChanged', function(text) {
-      self.filter.filterTree(text);
+      // do not allow to move a node to the same parent
+      return node.parentNode != newParent;
     });
-
-    this.addEvents('rwiki:pageSelected');
   },
 
   initEvents: function() {
@@ -64,18 +56,17 @@ Rwiki.TreePanel = Ext.extend(Ext.tree.TreePanel, {
     this.on('click', this.onClick);
 
     this.on('rwiki:pageLoaded', this.onPageLoaded);
-    this.on('rwiki:folderCreated', this.onFolderCreated);
     this.on('rwiki:pageCreated', this.onPageCreated);
-    this.on('rwiki:nodeRenamed', this.onNodeRenamed);
-    this.on('rwiki:nodeDeleted', this.onNodeDeleted);
+    this.on('rwiki:pageRenamed', this.onPageRenamed);
+    this.on('rwiki:pageDeleted', this.onPageDeleted);
     this.on('beforemovenode', this.onBeforeMoveNode);
 
-    this.relayEvents(Rwiki.NodeManager.getInstance(), [
+    this.relayEvents(Rwiki.Data.PageManager.getInstance(), [
       'rwiki:pageLoaded',
-      'rwiki:folderCreated',
       'rwiki:pageCreated',
-      'rwiki:nodeRenamed',
-      'rwiki:nodeDeleted']);
+      'rwiki:pageRenamed',
+      'rwiki:pageDeleted'
+    ]);
   },
 
   onContextMenu: function(node, e) {
@@ -89,37 +80,21 @@ Rwiki.TreePanel = Ext.extend(Ext.tree.TreePanel, {
   },
 
   onClick: function(node) {
-    if (!node.isLeaf()) return;
-    var page = new Rwiki.Node({ path: node.getPath() });
-    this.fireEvent('rwiki:pageSelected', page);
+    Rwiki.openPage(node.getPath());
   },
 
   onPageLoaded: function(page) {
     var node = this.findNodeByPath(page.getPath());
     if (node) {
+      node.expandAllParents();
       node.select();
     }
   },
 
-  onFolderCreated: function(data) {
-    var node = new Rwiki.TreePanel.Node({
-      baseName: data.baseName,
-      text: data.baseName,
-      cls: 'folder',
-      expandable: true,
-      leaf: false
-    });
-
-    var parentNode = this.findNodeByPath(data.parentPath);
-    parentNode.expand();
-    parentNode.appendChild(node);
-  },
-
   onPageCreated: function(page) {
-    var treeNode = new Rwiki.TreePanel.Node({
+    var treeNode = new Rwiki.Tree.Node({
       baseName: page.getBaseName(),
       text: page.getTitle(),
-      cls: 'page',
       expandable: false,
       leaf: true
     });
@@ -130,15 +105,13 @@ Rwiki.TreePanel = Ext.extend(Ext.tree.TreePanel, {
     treeNode.select();
   },
 
-  onNodeRenamed: function(page) {
+  onPageRenamed: function(page) {
     var treeNode = this.findNodeByPath(page.getData().oldPath);
-    treeNode.setBaseName(page.getBaseName());
     treeNode.setText(page.getTitle());
   },
 
-  onNodeDeleted: function(data) {
-    var path = data.path;
-    var node = this.findNodeByPath(path);
+  onPageDeleted: function(page) {
+    var node = this.findNodeByPath(page.getPath());
     node.remove();
   },
 
@@ -146,31 +119,22 @@ Rwiki.TreePanel = Ext.extend(Ext.tree.TreePanel, {
     var path = node.getPath();
     var newParentPath = newParent.getPath();
 
-    var result = Rwiki.NodeManager.getInstance().moveNode(path, newParentPath);
+    var result = Rwiki.Data.PageManager.getInstance().moveNode(path, newParentPath);
 
     return result.success;
   },
 
   findNodeByPath: function(path) {
     var node = null;
-    this.root.cascadeAll(function(curretNode) {
-      if (curretNode.getPath() == path) {
-        node = curretNode;
+    this.root.cascadeAll(function(currentNode) {
+      if (currentNode.getPath() == path) {
+        node = currentNode;
         return false;
+      } else {
+        return true;
       }
     });
 
     return node;
-  },
-
-  openNodeFromLocationHash: function() {
-    if (!location.hash) return;
-
-    var path = location.hash.replace(new RegExp('^#'), '');
-    var node = this.findNodeByPath(path);
-    if (node) {
-      node.expandAll();
-      this.onClick(node);
-    }
   }
 });