projects/dwt-mac: dwt/custom/TreeEditor.d comparison

comparison dwt/custom/TreeEditor.d @ 41:6337764516f1

Sync dwt/custom with dwt-linux (took copy of complete folder)

author	Frank Benoit <benoit@tionex.de>
date	Tue, 07 Oct 2008 16:29:55 +0200
parents	e831403a80a9
children	63a09873578e

comparison

equal deleted inserted replaced

-:fbe68c33eeee
+:6337764516f1
 /*******************************************************************************
-* Copyright (c) 2000, 2007 IBM Corporation and others.
+* Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
+* Port to the D programming language:
+*     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
-module dwt.custom;
+module dwt.custom.TreeEditor;
+import dwt.dwthelper.utils;
-import dwt.*;
-import dwt.events.*;
-import dwt.graphics.*;
+import dwt.DWT;
-import dwt.widgets.*;
+import dwt.events.ControlEvent;
+import dwt.events.ControlListener;
+import dwt.events.TreeEvent;
+import dwt.events.TreeListener;
+import dwt.graphics.Rectangle;
+import dwt.widgets.Control;
+import dwt.widgets.Display;
+import dwt.widgets.Tree;
+import dwt.widgets.TreeColumn;
+import dwt.widgets.TreeItem;
+import dwt.custom.ControlEditor;
+import dwt.dwthelper.Runnable;
 /**
 *
 * A TreeEditor is a manager for a Control that appears above a cell in a Tree and tracks with the
 * moving and resizing of that cell.  It can be used to display a text widget above a cell
 *       for (int j = 0; j &lt; 3; j++) {
 *           TreeItem subItem = new TreeItem(item, DWT.NONE);
 *           subItem.setText("item " + i + " " + j);
 *       }
 *   }
 *
 *   final TreeEditor editor = new TreeEditor(tree);
 *   //The editor must have the same size as the cell and must
 *   //not be any smaller than 50 pixels.
 *   editor.horizontalAlignment = DWT.LEFT;
 *   editor.grabHorizontal = true;
 *   editor.minimumWidth = 50;
 *
 *   tree.addSelectionListener(new SelectionAdapter() {
 *       public void widgetSelected(SelectionEvent e) {
 *           // Clean up any previous editor control
 *           Control oldEditor = editor.getEditor();
 *           if (oldEditor !is null) oldEditor.dispose();
 *
 *           // Identify the selected row
-*           TreeItem item = cast(TreeItem)e.item;
+*           TreeItem item = (TreeItem)e.item;
 *           if (item is null) return;
 *
 *           // The control that will be the editor must be a child of the Tree
 *           Text newEditor = new Text(tree, DWT.NONE);
 *           newEditor.setText(item.getText());
 *           newEditor.addModifyListener(new ModifyListener() {
 *               public void modifyText(ModifyEvent e) {
-*                   Text text = cast(Text)editor.getEditor();
+*                   Text text = (Text)editor.getEditor();
 *                   editor.getItem().setText(text.getText());
 *               }
 *           });
 *           newEditor.selectAll();
 *           newEditor.setFocus();
 *           editor.setEditor(newEditor, item);
 *       }
 *   });
 * </pre></code>
-*/
+*
-public class TreeEditor : ControlEditor {
+* @see <a href="http://www.eclipse.org/swt/snippets/#treeeditor">TreeEditor snippets</a>
+* @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
+*/
+public class TreeEditor : ControlEditor {
 Tree tree;
 TreeItem item;
 int column = 0;
 ControlListener columnListener;
 TreeListener treeListener;
 Runnable timer;
-static final int TIMEOUT = 1500;
+static const int TIMEOUT = 1500;
 /**
 * Creates a TreeEditor for the specified Tree.
 *
 * @param tree the Tree Control above which this editor will be displayed
 *
 */
 public this (Tree tree) {
 super(tree);
 this.tree = tree;
-columnListener = new ControlListener() {
+columnListener = new class() ControlListener {
 public void controlMoved(ControlEvent e){
 layout();
 }
 public void controlResized(ControlEvent e){
 layout();
 }
 };
-timer = new Runnable () {
+timer = new class() Runnable {
 public void run() {
 layout ();
 }
 };
-treeListener = new TreeListener () {
+treeListener = new class() TreeListener {
-final Runnable runnable = new Runnable() {
+Runnable runnable;
-public void run() {
+this(){
-if (editor is null || editor.isDisposed()) return;
+runnable = new class() Runnable {
-if (TreeEditor.this.tree.isDisposed()) return;
+public void run() {
-layout();
+if (this.outer.outer.editor is null || this.outer.outer.editor.isDisposed()) return;
-editor.setVisible(true);
+if (this.outer.outer.tree.isDisposed()) return;
-}
+layout();
-};
+this.outer.outer.editor.setVisible(true);
+}
+};
+}
 public void treeCollapsed(TreeEvent e) {
-if (editor is null || editor.isDisposed ()) return;
+if (this.outer.editor is null || this.outer.editor.isDisposed ()) return;
-editor.setVisible(false);
+this.outer.editor.setVisible(false);
 e.display.asyncExec(runnable);
 }
 public void treeExpanded(TreeEvent e) {
-if (editor is null || editor.isDisposed ()) return;
+if (this.outer.editor is null || this.outer.editor.isDisposed ()) return;
-editor.setVisible(false);
+this.outer.editor.setVisible(false);
 e.display.asyncExec(runnable);
 }
 };
 tree.addTreeListener(treeListener);
 // To be consistent with older versions of DWT, grabVertical defaults to true
 grabVertical = true;
 }
-Rectangle computeBounds () {
+override Rectangle computeBounds () {
 if (item is null || column is -1 || item.isDisposed()) return new Rectangle(0, 0, 0, 0);
 Rectangle cell = item.getBounds(column);
 Rectangle rect = item.getImageBounds(column);
 cell.x = rect.x + rect.width;
 cell.width -= rect.width;
 }
 Rectangle editorRect = new Rectangle(cell.x, cell.y, minimumWidth, minimumHeight);
 if (grabHorizontal) {
 if (tree.getColumnCount() is 0) {
 // Bounds of tree item only include the text area - stretch out to include
 // entire client area
 cell.width = area.x + area.width - cell.x;
 }
 editorRect.width = Math.max(cell.width, minimumWidth);
 }
 if (grabVertical) {
 editorRect.height = Math.max(cell.height, minimumHeight);
 }
 if (horizontalAlignment is DWT.RIGHT) {
 editorRect.x += cell.width - editorRect.width;
 } else if (horizontalAlignment is DWT.LEFT) {
 // do nothing - cell.x is the right answer
 } else { // default is CENTER
 editorRect.x += (cell.width - editorRect.width)/2;
 }
-// don't let the editor overlap with the +/- of the tree
+// don't let the editor overlap with the + / - of the tree
 editorRect.x = Math.max(cell.x, editorRect.x);
 if (verticalAlignment is DWT.BOTTOM) {
 editorRect.y += cell.height - editorRect.height;
 } else if (verticalAlignment is DWT.TOP) {
 // do nothing - cell.y is the right answer
 } else { // default is CENTER
 /**
 * Removes all associations between the TreeEditor and the row in the tree.  The
 * tree and the editor Control are <b>not</b> disposed.
 */
-public void dispose () {
+public override void dispose () {
 if (tree !is null && !tree.isDisposed()) {
 if (this.column > -1 && this.column < tree.getColumnCount()){
 TreeColumn treeColumn = tree.getColumn(this.column);
 treeColumn.removeControlListener(columnListener);
 }
 }
 }
 /**
 * Sets the zero based index of the column of the cell being tracked by this editor.
 *
 * @param column the zero based index of the column of the cell being tracked by this editor
 *
 * @since 3.1
 */
 public void setColumn(int column) {
 TreeColumn treeColumn = tree.getColumn(this.column);
 treeColumn.removeControlListener(columnListener);
 this.column = -1;
 }
 if (column < 0  || column >= tree.getColumnCount()) return;
 this.column = column;
 TreeColumn treeColumn = tree.getColumn(this.column);
 treeColumn.addControlListener(columnListener);
 resize();
 }
+/**
+* Specifies the <code>TreeItem</code> that is to be edited.
+*
+* @param item the item to be edited
+*/
 public void setItem (TreeItem item) {
 this.item = item;
 resize();
 }
 /**
 * Specify the Control that is to be displayed and the cell in the tree that it is to be positioned above.
 *
 * <p>Note: The Control provided as the editor <b>must</b> be created with its parent being the Tree control
 * specified in the TreeEditor constructor.
 *
 * @param editor the Control that is displayed above the cell being edited
 * @param item the TreeItem for the row of the cell being tracked by this editor
 * @param column the zero based index of the column of the cell being tracked by this editor
 *
 * @since 3.1
 public void setEditor (Control editor, TreeItem item, int column) {
 setItem(item);
 setColumn(column);
 setEditor(editor);
 }
-public void setEditor (Control editor) {
+public override void setEditor (Control editor) {
 super.setEditor(editor);
 resize();
 }
 /**
 * Specify the Control that is to be displayed and the cell in the tree that it is to be positioned above.
 *
 * <p>Note: The Control provided as the editor <b>must</b> be created with its parent being the Tree control
 * specified in the TreeEditor constructor.
 *
 * @param editor the Control that is displayed above the cell being edited
 * @param item the TreeItem for the row of the cell being tracked by this editor
 */
 public void setEditor (Control editor, TreeItem item) {
 setItem(item);
 setEditor(editor);
 }
-public void layout () {
+public override void layout () {
 if (tree is null || tree.isDisposed()) return;
 if (item is null || item.isDisposed()) return;
 int columnCount = tree.getColumnCount();
 if (columnCount is 0 && column !is 0) return;
 if (columnCount > 0 && (column < 0 || column >= columnCount)) return;
 super.layout();
 }
-}
+}

Mercurial > projects > dwt-mac

comparison dwt/custom/TreeEditor.d @ 41:6337764516f1