Mercurial > projects > dwt2
changeset 31:5d87d4191adf
Added JFace Snippets sources
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet001TableViewer.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,110 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * wbaxter at gmail dot com + *******************************************************************************/ + +module snippets.viewers.Snippet001TableViewer; + +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.Viewer; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.DWT; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import dwtx.dwtxhelper.Collection; + +/** + * A simple TableViewer to demonstrate usage + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet001TableViewer { + private class MyContentProvider : IStructuredContentProvider { + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(ArrayList)inputElement).toArray; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + } + + public class MyModel { + public int counter; + + public this(int counter) { + this.counter = counter; + } + + public String toString() { + return "Item " ~ to!(char[])(this.counter); + } + } + + public this(Shell shell) { + final TableViewer v = new TableViewer(shell); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + ArrayList model = createModel(); + v.setInput(model); + v.getTable().setLinesVisible(true); + } + + private ArrayList createModel() { + ArrayList elements = new ArrayList(10); + + for( int i = 0; i < 10; i++ ) { + elements.add( new MyModel(i)); + } + + return elements; + } + +} + +void main() +{ + Display display = new Display (); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet001TableViewer(shell); + shell.open (); + + while (!shell.isDisposed ()) { + if (!display.readAndDispatch ()) display.sleep (); + } + + display.dispose (); + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet002TreeViewer.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,146 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * wbaxter at gmail dot com + *******************************************************************************/ + +module snippets.viewers.Snippet002TreeViewer; + +import dwt.DWT; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; + +import tango.util.Convert; + +/** + * A simple TreeViewer to demonstrate usage + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +class Snippet002TreeViewer { + private class MyContentProvider : ITreeContentProvider { + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(MyModel)inputElement).child/*.dup*/; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) + */ + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) + */ + public Object getParent(Object element) { + if( element is null) { + return null; + } + + return (cast(MyModel)element).parent; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) + */ + public bool hasChildren(Object element) { + return (cast(MyModel)element).child.length > 0; + } + + } + + public class MyModel { + public MyModel parent; + public MyModel[] child; + public int counter; + + public this(int counter, MyModel parent) { + this.parent = parent; + this.counter = counter; + } + + public String toString() { + String rv = "Item "; + if( parent !is null ) { + rv = parent.toString() ~ "."; + } + + rv ~= to!(char[])(counter); + + return rv; + } + } + + public this(Shell shell) { + TreeViewer v = new TreeViewer(shell); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.setInput(createModel()); + } + + private MyModel createModel() { + MyModel root = new MyModel(0,null); + root.counter = 0; + + MyModel tmp; + for( int i = 1; i < 10; i++ ) { + tmp = new MyModel(i, root); + root.child ~= tmp; + for( int j = 1; j < i; j++ ) { + tmp.child ~= new MyModel(j,tmp); + } + } + + return root; + } + +} + + +void main() { + Display display = new Display (); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet002TreeViewer(shell); + shell.open (); + + while (!shell.isDisposed ()) { + if (!display.readAndDispatch ()) display.sleep (); + } + + display.dispose (); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet004HideSelection.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,127 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * wbaxter at gmail dot com + *******************************************************************************/ + +module snippets.viewers.Snippet004HideSelection; + +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.StructuredSelection; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.events.MouseAdapter; +import dwt.events.MouseEvent; +import dwt.graphics.Point; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; +import dwtx.dwtxhelper.Collection; + +import tango.util.Convert; + +/** + * Snippet that hides the selection when nothing is selected. + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet004HideSelection { + private class MyContentProvider : IStructuredContentProvider { + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(ArrayList)inputElement).toArray; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + } + + public class MyModel { + public int counter; + + public this(int counter) { + this.counter = counter; + } + + public String toString() { + return "Item " ~ to!(char[])(this.counter); + } + } + + public this(Shell shell) { + final TableViewer v = new TableViewer(shell,DWT.BORDER|DWT.FULL_SELECTION); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + ArrayList model = createModel(); + v.setInput(model); + v.getTable().setLinesVisible(true); + v.getTable().addMouseListener(new class(v) MouseAdapter { + private TableViewer v; + this(TableViewer v_) { + this.v = v_; + } + + /* (non-Javadoc) + * @see org.eclipse.swt.events.MouseAdapter#mouseDown(org.eclipse.swt.events.MouseEvent) + */ + public void mouseDown(MouseEvent e) { + if( v.getTable().getItem(new Point(e.x,e.y)) is null ) { + v.setSelection(new StructuredSelection()); + } + } + + }); + } + + private ArrayList createModel() { + ArrayList elements = new ArrayList(10); + for( int i = 0; i < 10; i++ ) { + elements.add( new MyModel(i)); + } + + return elements; + } + +} + +static void main() { + Display display = new Display (); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet004HideSelection(shell); + shell.open (); + + while (!shell.isDisposed ()) { + if (!display.readAndDispatch ()) display.sleep (); + } + + display.dispose (); + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet005TreeCustomMenu.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,183 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * wbaxter at gmail dot com + *******************************************************************************/ + +module snippets.viewers.Snippet005TreeCustomMenu; + +import dwtx.jface.action.Action; +import dwtx.jface.action.IMenuListener; +import dwtx.jface.action.IMenuManager; +import dwtx.jface.action.MenuManager; +import dwtx.jface.viewers.IStructuredSelection; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.DWT; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import tango.io.Stdout; + +/** + * Customized context menu based on TreeItem-Selection + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet005TreeCustomMenu { + private class MyContentProvider : ITreeContentProvider { + + public Object[] getElements(Object inputElement) { + return (cast(MyModel) inputElement).child; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) + */ + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) + */ + public Object getParent(Object element) { + if (element is null) { + return null; + } + + return (cast(MyModel) element).parent; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) + */ + public bool hasChildren(Object element) { + return (cast(MyModel) element).child.length > 0; + } + + } + + public class MyModel { + public MyModel parent; + + public MyModel[] child; + + public int counter; + + public this(int counter, MyModel parent) { + this.parent = parent; + this.counter = counter; + } + + public String toString() { + String rv = "Item "; + if (parent !is null) { + rv = parent.toString() ~ "."; + } + + rv ~= to!(char[])(counter); + + return rv; + } + } + + public this(Shell shell) { + final TreeViewer v = new TreeViewer(shell); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.setInput(createModel()); + + final Action a = new class Action {}; + final MenuManager mgr = new MenuManager(); + mgr.setRemoveAllWhenShown(true); + + class MyMenuListener : IMenuListener { + TreeViewer v; + Action a; + MenuManager mgr; + + this(TreeViewer v_, Action a_, MenuManager mgr_) { + this.v = v_; this.a = a_; this.mgr = mgr_; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface.action.IMenuManager) + */ + public void menuAboutToShow(IMenuManager manager) { + IStructuredSelection selection = cast(IStructuredSelection) v + .getSelection(); + if (!selection.isEmpty()) { + a.setText("Action for " + ~ (cast(MyModel) selection.getFirstElement()) + .toString()); + mgr.add(a); + } + } + } + + mgr.addMenuListener(new MyMenuListener(v,a,mgr)); + v.getControl().setMenu(mgr.createContextMenu(v.getControl())); + } + + private MyModel createModel() { + + MyModel root = new MyModel(0, null); + root.counter = 0; + + MyModel tmp; + for (int i = 1; i < 10; i++) { + tmp = new MyModel(i, root); + root.child ~= tmp; + for (int j = 1; j < i; j++) { + tmp.child ~= new MyModel(j, tmp); + } + } + + return root; + } + +} + +void main() { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet005TreeCustomMenu(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet006TableMultiLineCells.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,255 @@ +/******************************************************************************* +* Copyright (c) 2005, 2007 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: +* yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) +*******************************************************************************/ +module snippets.viewers.Snippet006TableMultiLineCells; + + +// http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jface.snippets/Eclipse%20JFace%20Snippets/org/eclipse/jface/snippets/viewers/Snippet006TableMultiLineCells.java?view=markup + +import dwtx.jface.resource.JFaceResources; +import dwtx.jface.viewers.ColumnPixelData; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.OwnerDrawLabelProvider; +import dwtx.jface.viewers.StructuredSelection; +import dwtx.jface.viewers.TableLayout; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.viewers.TableViewer; +import dwt.DWT; +import dwt.graphics.Font; +import dwt.graphics.Point; +import dwt.layout.GridData; +import dwt.layout.GridLayout; +import dwt.widgets.Composite; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Shell; +import dwt.widgets.TableColumn; + +import dwt.dwthelper.utils; +version(JIVE){ + import jive.stacktrace; +} + +void main(String[] args) { + (new Snippet006TableMultiLineCells()).main(args); +} + +public class Snippet006TableMultiLineCells { + + public static void main(String[] args) { + + Display display = new Display(); + Shell shell = new Shell(display, DWT.CLOSE|DWT.RESIZE); + shell.setSize(400, 400); + shell.setLayout(new GridLayout()); + + Snippet006TableMultiLineCells example = new Snippet006TableMultiLineCells(); + example.createPartControl(shell); + + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + display.dispose(); + } + + class LineEntry { + + String line; + int columnWidth; + + /** + * Create a new instance of the receiver with name text constrained to a + * column of width. + * + * @param text + * @param width + */ + this(String text, int width) { + line = text; + columnWidth = width; + } + + /** + * Get the height of the event. + * + * @param index + * @return int + */ + public int getHeight(Event event) { + event.gc.setLineWidth(columnWidth); + return event.gc.textExtent(line).y; + } + + /** + * Get the width of the event. + * + * @param index + * @return + */ + public int getWidth(Event event) { + + return columnWidth; + } + + /** + * Get the font we are using. + * + * @return Font + */ + protected Font getFont() { + return JFaceResources.getFont(JFaceResources.HEADER_FONT); + } + + /** + * @param event + */ + public void draw(Event event) { + event.gc.drawText(line, event.x, event.y); + + } + } + + private TableViewer viewer; + + private LineEntry[] entries; + + public this() { + String[] lines = [ + "This day is called the feast of Crispian:", + "He that outlives this day, \n and comes safe home,", + "Will stand a tip-toe when the day is named,", + "And rouse him at the name of Crispian.", + "He that shall live this day,\n and see old age,", + "Will yearly on the vigil feast his neighbours,", + "And say 'To-morrow is Saint Crispian:'", + "Then will he strip his sleeve and show his scars.", + "And say 'These wounds I had on Crispin's day.'", + "Old men forget:\n yet all shall be forgot,", + "But he'll remember with advantages", + "What feats he did that day:\n then shall our names.", + "Familiar in his mouth as household words", + "Harry the king, Bedford and Exeter,", + "Warwick and Talbot,\n Salisbury and Gloucester,", + "Be in their flowing cups freshly remember'd.", + "This story shall the good man teach his son;", + "And Crispin Crispian shall ne'er go by,", + "From this day to the ending of the world,", + "But we in it shall be remember'd;", + "We few,\n we happy few,\n we band of brothers;", + "For he to-day that sheds his blood with me", + "Shall be my brother;\n be he ne'er so vile,", + "This day shall gentle his condition:", + "And gentlemen in England now a-bed", + "Shall think themselves accursed they were not here,", + "And hold their manhoods cheap whiles any speaks", + "That fought with us upon Saint Crispin's day." ]; + + entries = new LineEntry[lines.length]; + for (int i = 0; i < lines.length; i++) { + entries[i] = new LineEntry(lines[i], 35); + } + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(dwt.widgets.Composite) + */ + public void createPartControl(Composite parent) { + viewer = new TableViewer(parent, DWT.FULL_SELECTION); + + viewer.setContentProvider(new class() IStructuredContentProvider { + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return entries; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(dwtx.jface.viewers.Viewer.Viewer viewer, Object oldInput, Object newInput) { + } + }); + createColumns(); + + viewer.setLabelProvider(new class OwnerDrawLabelProvider { + /* (non-Javadoc) + * @see dwtx.jface.viewers.OwnerDrawLabelProvider#measure(dwt.widgets.Event, java.lang.Object) + */ + protected void measure(Event event, Object element) { + LineEntry line = cast(LineEntry) element; + Point size = event.gc.textExtent(line.line); + event.width = viewer.getTable().getColumn(event.index).getWidth(); + int lines = (event.width > 0 ? (size.x / event.width + 1) : 1); + event.height = size.y * lines; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.OwnerDrawLabelProvider#paint(dwt.widgets.Event, + * java.lang.Object) + */ + protected void paint(Event event, Object element) { + + LineEntry entry = cast(LineEntry) element; + event.gc.drawText(entry.line, event.x, event.y, true); + } + }); + viewer.setInput(this); + + GridData data = new GridData(GridData.GRAB_HORIZONTAL + | GridData.GRAB_VERTICAL | GridData.FILL_BOTH); + + viewer.getControl().setLayoutData(data); + OwnerDrawLabelProvider.setUpOwnerDraw(viewer); + + viewer.setSelection(new StructuredSelection(entries[1])); + } + + /** + * Create the columns to be used in the tree. + */ + private void createColumns() { + TableLayout layout = new TableLayout(); + viewer.getTable().setLayout(layout); + viewer.getTable().setHeaderVisible(true); + viewer.getTable().setLinesVisible(true); + + TableColumn tc = new TableColumn(viewer.getTable(), DWT.NONE, 0); + layout.addColumnData(new ColumnPixelData(350)); + tc.setText("Lines"); + + } + + public void setFocus() { + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet007FullSelection.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,163 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + *******************************************************************************/ + +module snippets.viewers.Snippet007FullSelection; + +import dwtx.jface.viewers.CellEditor; +import dwtx.jface.viewers.ICellModifier; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.TextCellEditor; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.graphics.Color; +import dwt.graphics.GC; +import dwt.graphics.Point; +import dwt.graphics.Rectangle; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Listener; +import dwt.widgets.Shell; +import dwt.widgets.TableColumn; +import dwt.widgets.TableItem; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import dwtx.dwtxhelper.Collection; + +/** + * TableViewer: Hide full selection + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet007FullSelection { + + private class MyContentProvider : IStructuredContentProvider { + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(ArrayList)inputElement).toArray; + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* (non-Javadoc) + * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + } + + public class MyModel { + public int counter; + + public this(int counter) { + this.counter = counter; + } + + public String toString() { + return "Item " ~ to!(char[])(this.counter); + } + } + + public this(Shell shell) { + final TableViewer v = new TableViewer(shell,DWT.BORDER|DWT.FULL_SELECTION); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.setCellModifier(new class(v) ICellModifier { + TableViewer v; + this(TableViewer v_) { this.v=v_; } + + public bool canModify(Object element, String property) { + return true; + } + + public Object getValue(Object element, String property) { + return new ArrayWrapperString( to!(char[])((cast(MyModel)element).counter) ); + } + + public void modify(Object element, String property, Object value) { + auto item = cast(TableItem)element; + auto valuestr = cast(ArrayWrapperString)value; + (cast(MyModel)item.getData()).counter = to!(int)(valuestr.array); + v.update(item.getData(), null); + } + + }); + v.setColumnProperties(["column1", "column2" ]); + v.setCellEditors([ new TextCellEditor(v.getTable()),new TextCellEditor(v.getTable()) ]); + + TableColumn column = new TableColumn(v.getTable(),DWT.NONE); + column.setWidth(100); + column.setText("Column 1"); + + column = new TableColumn(v.getTable(),DWT.NONE); + column.setWidth(100); + column.setText("Column 2"); + + ArrayList model = createModel(); + v.setInput(model); + v.getTable().setLinesVisible(true); + v.getTable().setHeaderVisible(true); + + v.getTable().addListener(DWT.EraseItem, new class Listener { + + /* (non-Javadoc) + * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event) + */ + public void handleEvent(Event event) { + event.detail &= ~DWT.SELECTED; + } + }); + + } + + private ArrayList createModel() { + auto elements = new ArrayList(10); + + for( int i = 0; i < 10; i++ ) { + elements.add( new MyModel(i)); + } + + return elements; + } + +} + + +void main() { + Display display = new Display (); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet007FullSelection(shell); + shell.open (); + + while (!shell.isDisposed ()) { + if (!display.readAndDispatch ()) display.sleep (); + } + + display.dispose (); + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet010OwnerDraw.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,434 @@ +/******************************************************************************* + * Copyright (c) 2006, 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 + * oliver.schaefer@mbtech-services.com - Fix for Bug 225051 [Snippets] Snippet010OwnerDraw - Wrong german flag + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ +module snippets.viewers.Snippet010OwnerDraw.d; + +import dwtx.jface.resource.JFaceResources; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.viewers.ColumnPixelData; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.OwnerDrawLabelProvider; +import dwtx.jface.viewers.StructuredSelection; +import dwtx.jface.viewers.TableLayout; +import dwtx.jface.viewers.TableViewer; +import dwt.DWT; +import dwt.graphics.Rectangle; +import dwt.graphics.TextLayout; +import dwt.graphics.TextStyle; +import dwt.layout.GridData; +import dwt.layout.GridLayout; +import dwt.widgets.Composite; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Shell; +import dwt.widgets.TableColumn; + +import dwt.dwthelper.utils; + +void main(String[] args) { + Snippet010OwnerDraw.main(args); +} + +public class Snippet010OwnerDraw { + + public static void main(String[] args) { + + Display display = new Display(); + Shell shell = new Shell(display, DWT.CLOSE); + shell.setSize(400, 400); + shell.setLayout(new GridLayout()); + + Snippet010OwnerDraw example = new Snippet010OwnerDraw(); + example.createPartControl(shell); + + shell.open(); + + while (!shell.isDisposed ()) { + if (!display.readAndDispatch ()) display.sleep (); + } + display.dispose(); + } + + private static int COLUMN_COUNT = 3; + + class CountryEntry { + + String name; + + String cupYear; + + private String baseName; + + /** + * Create a new instance of the receiver. + * + * @param countryName + * @param worldCupYear + */ + this(String countryName, String englishName, String worldCupYear) { + name = countryName; + cupYear = worldCupYear; + baseName = englishName; + } + + /** + * @param index + * @return + */ + public int getHeight(Event event) { + switch (event.index) { + case 0: + return event.gc.textExtent(name).y; + case 1: + return 50; + case 2: + return event.gc.textExtent(cupYear).y; + default: + return 10; + } + } + + /** + * @param index + * @return + */ + public int getWidth(Event event) { + + switch (event.index) { + case 0: + return event.gc.textExtent(getDisplayString().toString()).x + 4; + + case 1: + return 200; + + case 2: + return event.gc.textExtent(cupYear).x + 5; + + default: + return 10; + } + } + + /** + * Draw the flag in bounds. + * + * @param event + */ + protected void drawFlag(Event event) { + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_BLUE)); + + Rectangle bounds = event.getBounds(); + bounds.width += 100; + event.gc.fillRectangle(bounds); + } + + /** + * Draw the cup year + * + * @param event + */ + private void drawCupYear(Event event) { + event.gc.drawText(cupYear, event.x, event.y); + + } + + /** + * Draw the name of the receiver. + * + * @param event + */ + protected void drawName(Event event) { + + StringBuffer buffer = getDisplayString(); + + Display display = viewer.getControl().getDisplay(); + TextLayout layout = new TextLayout(display); + layout.setText(buffer.toString()); + + TextStyle plain = new TextStyle(JFaceResources + .getFont(JFaceResources.DEFAULT_FONT), display + .getSystemColor(DWT.COLOR_LIST_FOREGROUND), display + .getSystemColor(DWT.COLOR_LIST_BACKGROUND)); + + TextStyle italic = new TextStyle(JFaceResources.getFontRegistry() + .getItalic(JFaceResources.DEFAULT_FONT), display + .getSystemColor(DWT.COLOR_BLUE), display + .getSystemColor(DWT.COLOR_LIST_BACKGROUND)); + + layout.setStyle(plain, 0, name.length - 1); + layout.setStyle(italic, name.length, buffer.length - 1); + + layout.draw(event.gc, event.x, event.y); + + } + + /** + * @return + */ + private StringBuffer getDisplayString() { + StringBuffer buffer = new StringBuffer(); + buffer.append(name); + buffer.append(" ("); + buffer.append(baseName); + buffer.append(")"); + return buffer; + } + + /** + * @param event + */ + public void draw(Event event) { + + switch (event.index) { + case 0: + drawName(event); + break; + case 1: + drawFlag(event); + break; + case 2: + drawCupYear(event); + break; + + default: + break; + } + + } + } + + private class GermanyEntry : CountryEntry { + + this() { + super("Deutschland", "Germany", "1954 1974 1990"); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.tests.viewers.OwnerDrawExample.CountryEntry#drawFlag(dwt.widgets.Event) + */ + protected void drawFlag(Event event) { + + Rectangle bounds = event.getBounds(); + bounds.width += 100; + int stripeHeight = bounds.height / 3; + Rectangle stripe = new Rectangle(bounds.x, bounds.y, bounds.width, + stripeHeight); + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_BLACK)); + event.gc.fillRectangle(stripe); + + stripe.y += stripeHeight; + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_RED)); + event.gc.fillRectangle(stripe); + + stripe.y += stripeHeight; + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_YELLOW)); + event.gc.fillRectangle(stripe); + + } + + } + + private class AustriaEntry : CountryEntry { + + this() { + super("\u00D6sterreich", "Austria", "TBD"); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.tests.viewers.OwnerDrawExample.CountryEntry#drawFlag(dwt.widgets.Event) + */ + protected void drawFlag(Event event) { + + Rectangle bounds = event.getBounds(); + bounds.width += 100; + int stripeHeight = bounds.height / 3; + Rectangle stripe = new Rectangle(bounds.x, bounds.y, bounds.width, + stripeHeight); + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_RED)); + event.gc.fillRectangle(stripe); + + stripe.y += stripeHeight; + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_WHITE)); + event.gc.fillRectangle(stripe); + + stripe.y += stripeHeight; + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_RED)); + event.gc.fillRectangle(stripe); + + } + } + + private class EnglandEntry : CountryEntry { + this() { + super("Blighty", "England", "1966"); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.tests.viewers.OwnerDrawExample.CountryEntry#drawFlag(dwt.widgets.Event) + */ + protected void drawFlag(Event event) { + + Rectangle bounds = event.getBounds(); + bounds.width += 100; + + event.gc.setBackground(viewer.getControl().getDisplay() + .getSystemColor(DWT.COLOR_RED)); + event.gc.fillRectangle(new Rectangle(bounds.width / 2 + bounds.x + - 5, bounds.y, 10, bounds.height)); + event.gc.fillRectangle(new Rectangle(bounds.x, bounds.height / 2 + + bounds.y - 5, bounds.width, 10)); + + } + } + + private TableViewer viewer; + + private CountryEntry[] entries; + + public this() { + entries = new CountryEntry[3]; + entries[0] = new AustriaEntry(); + entries[1] = new GermanyEntry(); + entries[2] = new EnglandEntry(); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(dwt.widgets.Composite) + */ + public void createPartControl(Composite parent) { + viewer = new TableViewer(parent, DWT.FULL_SELECTION); + + viewer.setContentProvider(new class() IStructuredContentProvider { + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + }; + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(Snippet010OwnerDraw) inputElement).entries; + }; + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, + Object oldInput, Object newInput) { + } + + }); + createColumns(); + + viewer.setLabelProvider(new class() OwnerDrawLabelProvider { + + + protected void measure(Event event, Object element) { + CountryEntry country = cast(CountryEntry) element; + + event.setBounds(new Rectangle(event.x, event.y, country.getWidth(event), + country.getHeight(event))); + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.OwnerDrawLabelProvider#paint(dwt.widgets.Event, + * java.lang.Object) + */ + protected void paint(Event event, Object element) { + CountryEntry entry = cast(CountryEntry) element; + entry.draw(event); + + } + }); + + OwnerDrawLabelProvider.setUpOwnerDraw(viewer); + viewer.setInput(this); + GridData data = new GridData(GridData.GRAB_HORIZONTAL + | GridData.GRAB_VERTICAL | GridData.FILL_BOTH); + + viewer.getControl().setLayoutData(data); + + viewer.setSelection(new StructuredSelection(entries[1])); + } + + /** + * Create the columns to be used in the tree. + */ + private void createColumns() { + TableLayout layout = new TableLayout(); + viewer.getTable().setLayout(layout); + viewer.getTable().setHeaderVisible(true); + viewer.getTable().setLinesVisible(true); + + for (int i = 0; i < COLUMN_COUNT; i++) { + TableColumn tc = new TableColumn(viewer.getTable(), DWT.NONE, i); + layout.addColumnData(new ColumnPixelData(100)); + tc.setText(getTitleFor(i)); + } + ; + } + + /** + * @param i + * @return + */ + private String getTitleFor(int i) { + switch (i) { + case 0: + return "Name"; + case 1: + return "Flag"; + case 2: + return "World Cup Year"; + } + return "Unknown"; + } + + public void setFocus() { + + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet011CustomTooltips.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * IBM - Improvement for Bug 159625 [Snippets] Update Snippet011CustomTooltips to reflect new API + *******************************************************************************/ + +module org.eclipse.jface.snippets.viewers.Snippet011CustomTooltips; + +import dwt.dwthelper.utils; + +import dwtx.jface.viewers.CellLabelProvider; +import dwtx.jface.viewers.ColumnViewerToolTipSupport; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.TableViewerColumn; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.viewers.ViewerCell; +import dwtx.jface.window.ToolTip; +import dwt.DWT; +import dwt.graphics.Point; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; + +/** + * Explore New API: JFace custom tooltips drawing. + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * @since 3.3 + */ +public class Snippet011CustomTooltips { + private static class MyContentProvider : + IStructuredContentProvider { + + public Object[] getElements(Object inputElement) { + return stringcast( [ "one", "two", "three", "four", "five", "six", + "seven", "eight", "nine", "ten" ]); + } + + public void dispose() { + + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + } + + /** + * @param args + */ + public static void main(char[][] args) { + final Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + + TableViewer v = new TableViewer(shell, DWT.FULL_SELECTION); + v.getTable().setLinesVisible(true); + v.getTable().setHeaderVisible(true); + v.setContentProvider(new MyContentProvider()); + ColumnViewerToolTipSupport.enableFor(v,ToolTip.NO_RECREATE); + + CellLabelProvider labelProvider = new class CellLabelProvider { + + public char[] getToolTipText(Object element) { + return "Tooltip (" ~ stringcast(element) ~ ")"; + } + + public Point getToolTipShift(Object object) { + return new Point(5, 5); + } + + public int getToolTipDisplayDelayTime(Object object) { + return 2000; + } + + public int getToolTipTimeDisplayed(Object object) { + return 5000; + } + + public void update(ViewerCell cell) { + cell.setText( cell.getElement().toString()); + + } + }; + + TableViewerColumn column = new TableViewerColumn(v, DWT.NONE); + column.setLabelProvider(labelProvider); + column.getColumn().setText("Column 1"); + column.getColumn().setWidth(100); + + v.setInput( new Object() ); + + shell.setSize(200, 200); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) { + display.sleep(); + } + } + + display.dispose(); + } + +} + +void main(){ + Snippet011CustomTooltips.main( null ); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet014TreeViewerNoMandatoryLabelProvider.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,228 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet014TreeViewerNoMandatoryLabelProvider; + + +import dwtx.jface.resource.FontRegistry; +import dwtx.jface.viewers.ITableColorProvider; +import dwtx.jface.viewers.ITableFontProvider; +import dwtx.jface.viewers.ITableLabelProvider; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.graphics.Color; +import dwt.graphics.Font; +import dwt.graphics.Image; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.widgets.TreeColumn; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import tango.util.container.LinkedList; + +version(JIVE) import jive.stacktrace; + + +void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet014TreeViewerNoMandatoryLabelProvider(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); +} + +/** + * A simple TreeViewer to demonstrate usage + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet014TreeViewerNoMandatoryLabelProvider { + alias LinkedList!(MyModel) ArrayList; + + private class MyContentProvider : ITreeContentProvider { + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(MyModel) inputElement).child.toArray(); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) + */ + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) + */ + public Object getParent(Object element) { + if (element is null) { + return null; + } + + return (cast(MyModel) element).parent; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) + */ + public bool hasChildren(Object element) { + return (cast(MyModel) element).child.size() > 0; + } + + } + + public class MyModel { + public MyModel parent; + + public ArrayList child; + + public int counter; + + public this(int counter, MyModel parent) { + this.parent = parent; + this.counter = counter; + child = new ArrayList(); + } + + public String toString() { + String rv = "Item "; + if (parent !is null) { + rv = parent.toString() ~ "."; + } + + rv ~= to!(String)(counter); + + return rv; + } + } + + public class MyLabelProvider : LabelProvider, + ITableLabelProvider, ITableFontProvider, ITableColorProvider { + FontRegistry registry; + this() + { + registry = new FontRegistry(); + } + + public Image getColumnImage(Object element, int columnIndex) { + return null; + } + + public String getColumnText(Object element, int columnIndex) { + return "Column " ~ to!(String)(columnIndex) ~ " => " ~ element.toString(); + } + + public Font getFont(Object element, int columnIndex) { + if ((cast(MyModel) element).counter % 2 == 0) { + return registry.getBold(Display.getCurrent().getSystemFont() + .getFontData()[0].getName()); + } + return null; + } + + public Color getBackground(Object element, int columnIndex) { + if ((cast(MyModel) element).counter % 2 == 0) { + return Display.getCurrent().getSystemColor(DWT.COLOR_RED); + } + return null; + } + + public Color getForeground(Object element, int columnIndex) { + if ((cast(MyModel) element).counter % 2 == 1) { + return Display.getCurrent().getSystemColor(DWT.COLOR_RED); + } + return null; + } + + } + + public this(Shell shell) { + final TreeViewer v = new TreeViewer(shell); + + TreeColumn column = new TreeColumn(v.getTree(),DWT.NONE); + column.setWidth(200); + column.setText("Column 1"); + + column = new TreeColumn(v.getTree(),DWT.NONE); + column.setWidth(200); + column.setText("Column 2"); + + v.setLabelProvider(new MyLabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.setInput(createModel()); + } + + private MyModel createModel() { + + MyModel root = new MyModel(0, null); + root.counter = 0; + + MyModel tmp; + for (int i = 1; i < 10; i++) { + tmp = new MyModel(i, root); + root.child.add(tmp); + for (int j = 1; j < i; j++) { + tmp.child.add(new MyModel(j, tmp)); + } + } + + return root; + } + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet016TableLayout.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,156 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet016TableLayout; + + +import dwtx.jface.layout.TableColumnLayout; +import dwtx.jface.viewers.ColumnWeightData; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.ITableLabelProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.graphics.Image; +import dwt.layout.FillLayout; +import dwt.widgets.Composite; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.widgets.Table; +import dwt.widgets.TableColumn; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +/** + * @param args + */ +void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + //shell.setSize(400, 150); + shell.setLayout(new FillLayout()); + + new Snippet016TableLayout(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + +} + +/** + * A simple TableViewer to demonstrate usage + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * @since 3.3M3 + */ +public class Snippet016TableLayout { + private class MyContentProvider : IStructuredContentProvider { + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(ArrayWrapperObject) inputElement).array; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + } + + private class MyLabelProvider : LabelProvider, ITableLabelProvider { + + public Image getColumnImage(Object element, int columnIndex) { + return null; + } + + public String getColumnText(Object element, int columnIndex) { + return to!(char[])(columnIndex) ~ " - " ~ element.toString(); + } + + } + + public class MyModel { + public int counter; + + public this(int counter) { + this.counter = counter; + } + + public String toString() { + return "Item " ~ to!(char[])(this.counter); + } + } + + public this(Composite comp) { + final TableViewer v = new TableViewer(new Table(comp, DWT.BORDER)); + v.setLabelProvider(new MyLabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.getTable().setHeaderVisible(true); + + TableColumnLayout ad = new TableColumnLayout(); + comp.setLayout(ad); + + TableColumn column = new TableColumn(v.getTable(), DWT.NONE); + column.setText("Column 1"); + column.setMoveable(true); + ad.setColumnData(column, new ColumnWeightData(90, 290)); + + column = new TableColumn(v.getTable(), DWT.NONE); + column.setText("Column 2"); + column.setMoveable(true); + ad.setColumnData(column, new ColumnWeightData(10, 200)); + + MyModel[] model = createModel(); + v.setInput(new ArrayWrapperObject(model)); + v.getTable().setLinesVisible(true); + } + + private MyModel[] createModel() { + MyModel[] elements = new MyModel[10]; + + for (int i = 0; i < 10; i++) { + elements[i] = new MyModel(i); + } + + return elements; + } + + + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet019TableViewerAddRemoveColumnsWithEditingNewAPI.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,334 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + *******************************************************************************/ + +module snippets.viewers.Snippet019TableViewerAddRemoveColumnsWithEditingNewAPI; + + +import dwtx.jface.action.Action; +import dwtx.jface.action.IMenuListener; +import dwtx.jface.action.IMenuManager; +import dwtx.jface.action.MenuManager; +import dwtx.jface.internal.ConfigureColumnsDialog; +import dwtx.jface.viewers.CellEditor; +import dwtx.jface.viewers.ColumnLabelProvider; +import dwtx.jface.viewers.EditingSupport; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.TableViewerColumn; +import dwtx.jface.viewers.TextCellEditor; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.window.SameShellProvider; +import dwt.DWT; +import dwt.events.MouseAdapter; +import dwt.events.MouseEvent; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.dwthelper.utils; +import dwtx.jface.window.IShellProvider; + +/** + * Explore the new API added in 3.3 and see how easily you can create reusable + * components + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * @since 3.2 + */ +public class Snippet019TableViewerAddRemoveColumnsWithEditingNewAPI { + + public class Person { + public String givenname; + + public String surname; + + public String email; + + public this(String givenname, String surname, String email) { + this.givenname = givenname; + this.surname = surname; + this.email = email; + } + } + + private class MyContentProvider : IStructuredContentProvider { + + public Object[] getElements(Object inputElement) { + return arrayFromObject!(Person)( inputElement ); + } + + public void dispose() { + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + } + + + + private class GivenNameLabelProvider : ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).givenname; + } + } + + private class GivenNameEditing : EditingSupport { + private TextCellEditor cellEditor; + + public this(TableViewer viewer) { + super(viewer); + cellEditor = new TextCellEditor(viewer.getTable()); + } + + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return cellEditor; + } + + protected Object getValue(Object element) { + return stringcast((cast(Person) element).givenname); + } + + protected void setValue(Object element, Object value) { + (cast(Person) element).givenname = stringcast(value); + getViewer().update(element, null); + } + } + + private class SurNameLabelProvider : ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).surname; + } + } + + private class SurNameEditing : EditingSupport { + private TextCellEditor cellEditor; + + public this( TableViewer viewer ) { + super(viewer); + cellEditor = new TextCellEditor(viewer.getTable()); + } + + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return cellEditor; + } + + protected Object getValue(Object element) { + return stringcast((cast(Person) element).surname); + } + + protected void setValue(Object element, Object value) { + (cast(Person) element).surname = stringcast(value); + getViewer().update(element, null); + } + } + + private class EmailLabelProvider : ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).email; + } + } + + private class EmailEditing : EditingSupport { + private TextCellEditor cellEditor; + + public this( TableViewer viewer ) { + super(viewer); + cellEditor = new TextCellEditor(viewer.getTable()); + } + + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return cellEditor; + } + + protected Object getValue(Object element) { + return stringcast((cast(Person) element).email); + } + + protected void setValue(Object element, Object value) { + (cast(Person) element).email = stringcast(value); + getViewer().update(element, null); + } + } + + private int activeColumn = -1; + + private TableViewerColumn column; + TableViewer v; + public this(Shell shell) { + v = new TableViewer(shell, DWT.BORDER + | DWT.FULL_SELECTION); + + TableViewerColumn column = new TableViewerColumn(v,DWT.NONE); + column.setLabelProvider(new GivenNameLabelProvider()); + column.setEditingSupport(new GivenNameEditing(v)); + + column.getColumn().setWidth(200); + column.getColumn().setText("Givenname"); + column.getColumn().setMoveable(true); + + column = new TableViewerColumn(v,DWT.NONE); + column.setLabelProvider(new SurNameLabelProvider()); + column.setEditingSupport(new SurNameEditing(v)); + column.getColumn().setWidth(200); + column.getColumn().setText("Surname"); + column.getColumn().setMoveable(true); + + Person[] model = createModel(); + + v.setContentProvider(new MyContentProvider()); + v.setInput(new ArrayWrapperObject(model)); + v.getTable().setLinesVisible(true); + v.getTable().setHeaderVisible(true); + + addMenu(); + triggerColumnSelectedColumn(); + } + + private void triggerColumnSelectedColumn() { + v.getTable().addMouseListener(new class() MouseAdapter { + + public void mouseDown(MouseEvent e) { + int x = 0; + for (int i = 0; i < v.getTable().getColumnCount(); i++) { + x += v.getTable().getColumn(i).getWidth(); + if (e.x <= x) { + activeColumn = i; + break; + } + } + } + + }); + } + + private void removeEmailColumn() { + column.getColumn().dispose(); + v.refresh(); + } + + private void addEmailColumn(int columnIndex) { + column = new TableViewerColumn(v, DWT.NONE, columnIndex); + column.setLabelProvider(new EmailLabelProvider()); + column.setEditingSupport(new EmailEditing(v)); + column.getColumn().setText("E-Mail"); + column.getColumn().setResizable(false); + + v.refresh(); + + column.getColumn().setWidth(200); + + } + + private Action insertEmailBefore; + private Action insertEmailAfter; + private Action removeEmail; + private Action configureColumns; + + private void addMenu() { + MenuManager mgr = new MenuManager(); + + insertEmailBefore = new class("Insert E-Mail before") Action { + this(String name){ super(name); } + public void run() { + addEmailColumn(activeColumn); + } + }; + + insertEmailAfter = new class("Insert E-Mail after") Action { + this(String name){ super(name); } + public void run() { + addEmailColumn(activeColumn + 1); + } + }; + + removeEmail = new class("Remove E-Mail") Action { + this(String name){ super(name); } + public void run() { + removeEmailColumn(); + } + }; + + configureColumns = new class("Configure Columns...") Action { + this(String name){ super(name); } + public void run() { + // Note: the following is not API! + (new ConfigureColumnsDialog(cast(IShellProvider)new SameShellProvider(v.getControl()), v.getTable())).open(); + } + }; + + mgr.setRemoveAllWhenShown(true); + mgr.addMenuListener(new class() IMenuListener { + + public void menuAboutToShow(IMenuManager manager) { + if (v.getTable().getColumnCount() == 2) { + manager.add(insertEmailBefore); + manager.add(insertEmailAfter); + } else { + manager.add(removeEmail); + } + manager.add(configureColumns); + } + + }); + + v.getControl().setMenu(mgr.createContextMenu(v.getControl())); + } + + private Person[] createModel() { + Person[] persons = new Person[3]; + persons[0] = new Person("Tom", "Schindl", "tom.schindl@bestsolution.at"); + persons[1] = new Person("Boris", "Bokowski", + "boris_bokowski@ca.ibm.com"); + persons[2] = new Person("Tod", "Creasey", "tod_creasey@ca.ibm.com"); + + return persons; + } + + /** + * @param args + */ + public static void main(String[] args) { + Display display = new Display(); + + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet019TableViewerAddRemoveColumnsWithEditingNewAPI(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + + } + +} + +void main(){ + Snippet019TableViewerAddRemoveColumnsWithEditingNewAPI.main(null); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet026TreeViewerTabEditing.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,295 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet026TreeViewerTabEditing; + + +import dwtx.jface.viewers.CellEditor; +import dwtx.jface.viewers.ColumnLabelProvider; +import dwtx.jface.viewers.ColumnViewerEditor; +import dwtx.jface.viewers.ColumnViewer; +import dwtx.jface.viewers.ColumnViewerEditorActivationStrategy; +import dwtx.jface.viewers.EditingSupport; +import dwtx.jface.viewers.ColumnViewerEditorActivationEvent; +import dwtx.jface.viewers.FocusCellOwnerDrawHighlighter; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.TextCellEditor; +import dwtx.jface.viewers.TreePath; +import dwtx.jface.viewers.TreeViewerFocusCellManager; +import dwtx.jface.viewers.TreeViewerEditor; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.TreeViewerColumn; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.events.SelectionEvent; +import dwt.events.SelectionListener; +import dwt.layout.FillLayout; +import dwt.widgets.Button; +import dwt.widgets.Display; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; +import dwtx.dwtxhelper.Collection; + +import tango.util.Convert; + +version(JIVE) import jive.stacktrace; + + +void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet026TreeViewerTabEditing(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); +} + +/** + * A simple TreeViewer to demonstrate usage + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet026TreeViewerTabEditing { + public this(Shell shell) { + Button b = new Button(shell,DWT.PUSH); + b.setText("Remove column"); + final TreeViewer v = new TreeViewer(shell, DWT.BORDER + | DWT.FULL_SELECTION); + v.getTree().setLinesVisible(true); + v.getTree().setHeaderVisible(true); + b.addSelectionListener(new class(v) SelectionListener { + TreeViewer v; + this(TreeViewer v_) + { + this.v = v_; + } + public void widgetDefaultSelected(SelectionEvent e) { + + } + + public void widgetSelected(SelectionEvent e) { + v.getTree().getColumn(1).dispose(); + } + + }); + + TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager(v,new FocusCellOwnerDrawHighlighter(v)); + ColumnViewerEditorActivationStrategy actSupport = new class(v) ColumnViewerEditorActivationStrategy { + this(ColumnViewer v_) + { + super(v_); + } + protected bool isEditorActivationEvent( + ColumnViewerEditorActivationEvent event) { + return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL + || event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION + || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == DWT.CR) + || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC; + } + }; + + TreeViewerEditor.create(v, focusCellManager, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL + | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR + | ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION); + + final TextCellEditor textCellEditor = new TextCellEditor(v.getTree()); + + TreeViewerColumn column = new TreeViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setMoveable(true); + column.getColumn().setText("Column 1"); + column.setLabelProvider(new class() ColumnLabelProvider { + + public String getText(Object element) { + return "Column 1 => " ~ element.toString(); + } + + }); + column.setEditingSupport(new class(v) EditingSupport { + this(ColumnViewer v_) + { + super(v_); + } + protected bool canEdit(Object element) { + return false; + } + + protected CellEditor getCellEditor(Object element) { + return textCellEditor; + } + + protected Object getValue(Object element) { + return stringcast( (to!(String)((cast(MyModel) element).counter)) ); + } + + protected void setValue(Object element, Object value) { + (cast(MyModel) element).counter = Integer.parseInt(value.toString()); + v.update(element, null); + } + }); + + column = new TreeViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setMoveable(true); + column.getColumn().setText("Column 2"); + column.setLabelProvider(new class() ColumnLabelProvider { + + public String getText(Object element) { + return "Column 2 => " ~ element.toString(); + } + + }); + column.setEditingSupport(new class(v) EditingSupport { + this(ColumnViewer v_) + { + super(v_); + } + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return textCellEditor; + } + + protected Object getValue(Object element) { + return stringcast( to!(String)((cast(MyModel) element).counter) ); + } + + protected void setValue(Object element, Object value) { + (cast(MyModel) element).counter = Integer.parseInt(value.toString()); + v.update(element, null); + } + }); + + column = new TreeViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setMoveable(true); + column.getColumn().setText("Column 3"); + column.setLabelProvider(new class() ColumnLabelProvider { + public String getText(Object element) { + return "Column 3 => " ~ element.toString(); + } + + }); + column.setEditingSupport(new class(v) EditingSupport { + this(ColumnViewer v_) + { + super(v_); + } + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return textCellEditor; + } + + protected Object getValue(Object element) { + return stringcast( to!(String)((cast(MyModel) element).counter) ); + } + + protected void setValue(Object element, Object value) { + (cast(MyModel) element).counter = Integer.parseInt(value.toString()); + v.update(element, null); + } + }); + + v.setContentProvider(new MyContentProvider()); + + v.setInput(createModel()); + } + + private MyModel createModel() { + + MyModel root = new MyModel(0, null); + root.counter = 0; + + MyModel tmp; + MyModel subItem; + for (int i = 1; i < 10; i++) { + tmp = new MyModel(i, root); + root.child.add(tmp); + for (int j = 1; j < i; j++) { + subItem = new MyModel(j, tmp); + subItem.child.add(new MyModel(j * 100, subItem)); + tmp.child.add(subItem); + } + } + + return root; + } + + private class MyContentProvider : ITreeContentProvider { + + public Object[] getElements(Object inputElement) { + return (cast(MyModel) inputElement).child.toArray(); + } + + public void dispose() { + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + } + + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + public Object getParent(Object element) { + if (element is null) { + return null; + } + return (cast(MyModel) element).parent; + } + + public bool hasChildren(Object element) { + return (cast(MyModel) element).child.size() > 0; + } + + } + + public class MyModel { + public MyModel parent; + + public ArrayList child; + + public int counter; + + public this(int counter, MyModel parent) { + this.parent = parent; + this.counter = counter; + child = new ArrayList(); + } + + public String toString() { + String rv = "Item "; + if (parent !is null) { + rv = parent.toString() ~ "."; + } + + rv ~= to!(String)(counter); + + return rv; + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet031TableViewerCustomTooltipsMultiSelection.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,310 @@ +/******************************************************************************* + * Copyright (c) 2007 Adam Neal 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: + * Adam Neal - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet031TableViewerCustomTooltipsMultiSelection; + +// http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jface.snippets/Eclipse%20JFace%20Snippets/org/eclipse/jface/snippets/viewers/Snippet031TableViewerCustomTooltipsMultiSelection.java?view=markup + +import dwtx.dwtxhelper.Collection; +import tango.util.Convert; + +import dwtx.jface.viewers.ArrayContentProvider; +import dwtx.jface.viewers.ILabelProviderListener; +import dwtx.jface.viewers.ITableLabelProvider; +import dwtx.jface.viewers.TableViewer; +import dwt.DWT; +import dwt.graphics.Image; +import dwt.graphics.Point; +import dwt.graphics.Rectangle; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Label; +import dwt.widgets.Listener; +import dwt.widgets.Shell; +import dwt.widgets.Table; +import dwt.widgets.TableColumn; +import dwt.widgets.TableItem; +import dwt.dwthelper.System; +import dwt.widgets.Listener; + +alias char[] String; +void main(String[] args) +{ + Snippet031TableViewerCustomTooltipsMultiSelection.main(args); +} + +/** + * A simple TableViewer to demonstrate how custom tooltips could be created easily while preserving + * the multiple selection. + * + * This is a modified example taken from Tom Schindl's Snippet023TreeViewerCustomTooltips.java + * + * This code is for users pre 3.3 others could use newly added tooltip support in {@link CellLabelProvider} + * @author Adam Neal <Adam_Neal@ca.ibm.com> + * + */ +public class Snippet031TableViewerCustomTooltipsMultiSelection { + public class MyLableProvider : ITableLabelProvider { + + public Image getColumnImage(Object element, int columnIndex) { + return null; + } + + public String getColumnText(Object element, int columnIndex) { + //if (element instanceof MyModel) { + switch (columnIndex) { + case 0: return (cast(MyModel)element).col1; + case 1: return (cast(MyModel)element).col2; + } + //} + + return ""; + } + + public void addListener(ILabelProviderListener listener) { + /* Ignore */ + } + + public void dispose() { + /* Ignore */ + } + + public bool isLabelProperty(Object element, String property) { + return false; + } + + public void removeListener(ILabelProviderListener listener) { + /* Ignore */ + } + + } + + + + public this(Shell shell) { + + + final Table table = new Table(shell, DWT.H_SCROLL | DWT.V_SCROLL | DWT.MULTI | DWT.FULL_SELECTION); + table.setHeaderVisible(true); + table.setLinesVisible(true); + + final TableViewer v = new TableViewer(table); + TableColumn tableColumn1 = new TableColumn(table, DWT.NONE); + TableColumn tableColumn2 = new TableColumn(table, DWT.NONE); + + String column1 = "Column 1", column2 = "Column 2"; + /* Setup the table columns */ + tableColumn1.setText(column1); + tableColumn2.setText(column2); + tableColumn1.pack(); + tableColumn2.pack(); + + v.setColumnProperties([ column1, column2 ]); + v.setLabelProvider(new MyLableProvider()); + v.setContentProvider(new ArrayContentProvider!(MyModel)); + v.setInput(createModel()); + + tooltipLabelListener = new TooltipLabelListener(); + + /** + * The listener that gets added to the table. This listener is responsible for creating the tooltips + * when hovering over a cell item. This listener will listen for the following events: + * <li>DWT.KeyDown - to remove the tooltip</li> + * <li>DWT.Dispose - to remove the tooltip</li> + * <li>DWT.MouseMove - to remove the tooltip</li> + * <li>DWT.MouseHover - to set the tooltip</li> + */ + + Listener tableListener = dgListener(&handleTableListener, table); + + table.addListener (DWT.Dispose, tableListener); + table.addListener (DWT.KeyDown, tableListener); + table.addListener (DWT.MouseMove, tableListener); + table.addListener (DWT.MouseHover, tableListener); + } + + void handleTableListener(Event event, Table table) + { + Shell tooltip = null; + Label label = null; + + /* + * (non-Javadoc) + * @see dwt.widgets.Listener#handleEvent(dwt.widgets.Event) + */ + switch (event.type) { + case DWT.KeyDown: + case DWT.Dispose: + case DWT.MouseMove: { + if (tooltip is null) break; + tooltip.dispose (); + tooltip = null; + label = null; + break; + } + case DWT.MouseHover: { + Point coords = new Point(event.x, event.y); + TableItem item = table.getItem(coords); + if (item !is null) { + int columnCount = table.getColumnCount(); + for (int columnIndex = 0; columnIndex < columnCount; columnIndex++) { + if (item.getBounds(columnIndex).contains(coords)) { + /* Dispose of the old tooltip (if one exists */ + if (tooltip !is null && !tooltip.isDisposed ()) tooltip.dispose (); + + /* Create a new Tooltip */ + tooltip = new Shell (table.getShell(), DWT.ON_TOP | DWT.NO_FOCUS | DWT.TOOL); + tooltip.setBackground (table.getDisplay().getSystemColor (DWT.COLOR_INFO_BACKGROUND)); + FillLayout layout = new FillLayout (); + layout.marginWidth = 2; + tooltip.setLayout (layout); + label = new Label (tooltip, DWT.NONE); + label.setForeground (table.getDisplay().getSystemColor (DWT.COLOR_INFO_FOREGROUND)); + label.setBackground (table.getDisplay().getSystemColor (DWT.COLOR_INFO_BACKGROUND)); + + /* Store the TableItem with the label so we can pass the mouse event later */ + label.setData ("_TableItem_", item); + + /* Set the tooltip text */ + label.setText("Tooltip: " ~ to!(char[])(item.getData()) ~ " : " ~ to!(char[])(columnIndex)); + + /* Setup Listeners to remove the tooltip and transfer the received mouse events */ + label.addListener (DWT.MouseExit, tooltipLabelListener); + label.addListener (DWT.MouseDown, tooltipLabelListener); + + /* Set the size and position of the tooltip */ + Point size = tooltip.computeSize (DWT.DEFAULT, DWT.DEFAULT); + Rectangle rect = item.getBounds (columnIndex); + Point pt = table.toDisplay (rect.x, rect.y); + tooltip.setBounds (pt.x, pt.y, size.x, size.y); + + /* Show it */ + tooltip.setVisible (true); + break; + } + } + } + } + } + } + + /** + * This listener is added to the tooltip so that it can either dispose itself if the mouse + * exits the tooltip or so it can pass the selection event through to the table. + */ + final TooltipLabelListener tooltipLabelListener; + final class TooltipLabelListener : Listener { + private bool isCTRLDown(Event e) { + return (e.stateMask & DWT.CTRL) != 0; + } + /* + * (non-Javadoc) + * @see dwt.widgets.Listener#handleEvent(dwt.widgets.Event) + */ + public void handleEvent (Event event) { + Label label = cast(Label)event.widget; + Shell shell = label.getShell (); + switch (event.type) { + case DWT.MouseDown: /* Handle a user Click */ + /* Extract our Data */ + Event e = new Event (); + e.item = cast(TableItem) label.getData ("_TableItem_"); + Table table = (cast(TableItem) e.item).getParent(); + + /* Construct the new Selection[] to show */ + TableItem [] newSelection = null; + if (isCTRLDown(event)) { + /* We have 2 scenario's. + * 1) We are selecting an already selected element - so remove it from the selected indices + * 2) We are selecting a non-selected element - so add it to the selected indices + */ + TableItem[] sel = table.getSelection(); + for (int i = 0; i < sel.length; ++i) { + //if (e.item.equals(sel[i])) { + if (e.item is sel[i]) { + // We are de-selecting this element + newSelection = new TableItem[sel.length - 1]; + System.arraycopy(sel, 0, newSelection, 0, i); + System.arraycopy(sel, i+1, newSelection, i, sel.length - i - 1); + break; + } + } + + /* + * If we haven't created the newSelection[] yet, than we are adding the newly selected element + * into the list of selected indicies + */ + if (newSelection is null) { + newSelection = new TableItem[sel.length + 1]; + System.arraycopy(sel, 0, newSelection, 0, sel.length); + newSelection[sel.length] = cast(TableItem) e.item; + } + + } else { + /* CTRL is not down, so we simply select the single element */ + newSelection = [ cast(TableItem) e.item ]; + } + /* Set the new selection of the table and notify the listeners */ + table.setSelection (newSelection); + table.notifyListeners (DWT.Selection, e); + + /* Remove the Tooltip */ + shell.dispose (); + table.setFocus(); + break; + case DWT.MouseExit: + shell.dispose (); + break; + } + } + } + + + private ArrayList createModel() { + ArrayList list = new ArrayList; + list.add(new MyModel("A", "B")); + list.add(new MyModel("C", "D")); + list.add(new MyModel("E", "F")); + return list; + } + + public static void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet031TableViewerCustomTooltipsMultiSelection(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + } +} + +public class MyModel { + public String col1, col2; + + public this(String c1, String c2) { + col1 = c1; + col2 = c2; + } + + public String toString() { + return col1 ~ col2; + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet040TableViewerSorting.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,312 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ +module snippets.viewers.Snippet040TableViewerSorting; + +// http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jface.snippets/Eclipse%20JFace%20Snippets/org/eclipse/jface/snippets/viewers/Snippet040TableViewerSorting.java?view=markup + +import dwtx.jface.viewers.CellEditor; +import dwtx.jface.viewers.ColumnLabelProvider; +import dwtx.jface.viewers.ColumnViewer; +import dwtx.jface.viewers.EditingSupport; +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.TableViewerColumn; +import dwtx.jface.viewers.TextCellEditor; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.viewers.ViewerComparator; +import dwt.DWT; +import dwt.events.SelectionAdapter; +import dwt.events.SelectionEvent; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.dwthelper.utils; + +version(JIVE) import jive.stacktrace; + +/** + * Example usage of ViewerComparator in tables to allow sorting + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ + +void main(String[] args) { + Snippet040TableViewerSorting.main(args); +} + + private class MyContentProvider : IStructuredContentProvider { + + public Object[] getElements(Object inputElement) { + return (cast(ArrayWrapperT!(Person)) inputElement).array; + } + + public void dispose() { + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + } + + } + + public class Person { + public String givenname; + public String surname; + public String email; + + public this(String givenname, String surname, String email) { + this.givenname = givenname; + this.surname = surname; + this.email = email; + } + + } + + protected abstract class AbstractEditingSupport : EditingSupport { + private TextCellEditor editor; + + public this(TableViewer viewer) { + super(viewer); + this.editor = new TextCellEditor(viewer.getTable()); + } + + protected bool canEdit(Object element) { + return true; + } + + protected CellEditor getCellEditor(Object element) { + return editor; + } + + protected void setValue(Object element, Object value) { + doSetValue(element, value); + getViewer().update(element, null); + } + + protected abstract void doSetValue(Object element, Object value); + } + + private abstract class ColumnViewerSorter : ViewerComparator { + public static final int ASC = 1; + + public static final int NONE = 0; + + public static final int DESC = -1; + + private int direction = 0; + + private TableViewerColumn column; + + private ColumnViewer viewer; + + public this(ColumnViewer viewer_, TableViewerColumn column_) { + this.column = column_; + this.viewer = viewer_; + this.column.getColumn().addSelectionListener(new class() SelectionAdapter { + public void widgetSelected(SelectionEvent e) { + this.outer.widgetSelected(e); + } + }); + } + + private void widgetSelected(SelectionEvent e){ + if( viewer.getComparator() !is null ) { + if( viewer.getComparator() is this ) { + int tdirection = direction; + + if( tdirection is ASC ) { + setSorter(this, DESC); + } else if( tdirection is DESC ) { + setSorter(this, NONE); + } + } else { + setSorter(this, ASC); + } + } else { + setSorter(this, ASC); + } + } + public void setSorter(ColumnViewerSorter sorter, int direction) { + if( direction is NONE ) { + column.getColumn().getParent().setSortColumn(null); + column.getColumn().getParent().setSortDirection(DWT.NONE); + viewer.setComparator(null); + } else { + column.getColumn().getParent().setSortColumn(column.getColumn()); + sorter.direction = direction; + + if( direction is ASC ) { + column.getColumn().getParent().setSortDirection(DWT.DOWN); + } else { + column.getColumn().getParent().setSortDirection(DWT.UP); + } + + if( viewer.getComparator() is sorter ) { + viewer.refresh(); + } else { + viewer.setComparator(sorter); + } + + } + } + + public int compare(Viewer viewer, Object e1, Object e2) { + return direction * doCompare(viewer, e1, e2); + } + + protected abstract int doCompare(Viewer viewer, Object e1, Object e2); + } + +public class Snippet040TableViewerSorting { + + + public this(Shell shell) { + TableViewer v = new TableViewer(shell, DWT.BORDER | DWT.FULL_SELECTION); + v.setContentProvider(new MyContentProvider()); + + TableViewerColumn column = new TableViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setText("Givenname"); + column.getColumn().setMoveable(true); + column.setLabelProvider(new class() ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).givenname; + } + }); + + column.setEditingSupport(new class(v) AbstractEditingSupport { + public this(TableViewer t ){ + super(t); + } + protected Object getValue(Object element) { + return new ArrayWrapperString((cast(Person) element).givenname); + } + protected void doSetValue(Object element, Object value) { + (cast(Person) element).givenname = stringcast(value); + } + }); + + ColumnViewerSorter cSorter = new class(v,column) ColumnViewerSorter { + this(TableViewer t, TableViewerColumn c ){ + super(t,c); + } + protected int doCompare(Viewer viewer, Object e1, Object e2) { + Person p1 = cast(Person) e1; + Person p2 = cast(Person) e2; + return p1.givenname.compareToIgnoreCase(p2.givenname); + } + }; + + column = new TableViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setText("Surname"); + column.getColumn().setMoveable(true); + column.setLabelProvider(new class() ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).surname; + } + }); + + column.setEditingSupport(new class(v) AbstractEditingSupport { + this(TableViewer t ){ + super(t); + } + protected Object getValue(Object element) { + return stringcast((cast(Person) element).surname); + } + protected void doSetValue(Object element, Object value) { + (cast(Person) element).surname = stringcast(value); + } + }); + + new class(v,column) ColumnViewerSorter { + this(TableViewer t, TableViewerColumn c ){ + super(t,c); + } + protected int doCompare(Viewer viewer, Object e1, Object e2) { + Person p1 = cast(Person) e1; + Person p2 = cast(Person) e2; + return p1.surname.compareToIgnoreCase(p2.surname); + } + }; + + column = new TableViewerColumn(v, DWT.NONE); + column.getColumn().setWidth(200); + column.getColumn().setText("E-Mail"); + column.getColumn().setMoveable(true); + column.setLabelProvider(new class() ColumnLabelProvider { + public String getText(Object element) { + return (cast(Person) element).email; + } + }); + + column.setEditingSupport(new class(v) AbstractEditingSupport { + this(TableViewer t ){ + super(t); + } + protected Object getValue(Object element) { + return stringcast((cast(Person) element).email); + } + protected void doSetValue(Object element, Object value) { + (cast(Person) element).email = stringcast(value); + } + }); + new class(v,column) ColumnViewerSorter { + this(TableViewer t, TableViewerColumn c ){ + super(t,c); + } + protected int doCompare(Viewer viewer, Object e1, Object e2) { + Person p1 = cast(Person) e1; + Person p2 = cast(Person) e2; + return p1.email.compareToIgnoreCase(p2.email); + } + }; + + Person[] model = createModel(); + v.setInput( new ArrayWrapperT!(Person)(model)); + v.getTable().setLinesVisible(true); + v.getTable().setHeaderVisible(true); + cSorter.setSorter(cSorter, ColumnViewerSorter.ASC); + } + + private Person[] createModel() { + Person[] elements = new Person[4]; + elements[0] = new Person("Tom", "Schindl", + "tom.schindl@bestsolution.at"); + elements[1] = new Person("Boris", "Bokowski", + "Boris_Bokowski@ca.ibm.com"); + elements[2] = new Person("Tod", "Creasey", "Tod_Creasey@ca.ibm.com"); + elements[3] = new Person("Wayne", "Beaton", "wayne@eclipse.org"); + + return elements; + } + + /** + * @param args + */ + public static void main(String[] args) { + Display display = new Display(); + + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet040TableViewerSorting(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + display.dispose(); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet043NoColumnTreeViewerKeyboardEditing.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,222 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet043NoColumnTreeViewerKeyboardEditing; + +import dwtx.jface.viewers.CellEditor; +import dwtx.jface.viewers.ColumnViewerEditor; +import dwtx.jface.viewers.ColumnViewer; +import dwtx.jface.viewers.ColumnViewerEditorActivationStrategy; +import dwtx.jface.viewers.ColumnViewerEditorActivationEvent; +import dwtx.jface.viewers.FocusCellOwnerDrawHighlighter; +import dwtx.jface.viewers.ICellModifier; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.TextCellEditor; +import dwtx.jface.viewers.TreePath; +import dwtx.jface.viewers.TreeViewerFocusCellManager; +import dwtx.jface.viewers.TreeViewerEditor; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.events.SelectionEvent; +import dwt.events.SelectionListener; +import dwt.layout.FillLayout; +import dwt.widgets.Button; +import dwt.widgets.Display; +import dwt.widgets.Item; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import tango.util.container.LinkedList; + +version(JIVE) import jive.stacktrace; + + +void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet043NoColumnTreeViewerKeyboardEditing(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); +} + +/** + * Demonstrates how to use keyboard-editing support in a TreeViewer with no column + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet043NoColumnTreeViewerKeyboardEditing { + alias LinkedList!(MyModel) ArrayList; + public this(Shell shell) { + Button b = new Button(shell, DWT.PUSH); + b.setText("BBB"); + final TreeViewer v = new TreeViewer(shell, DWT.BORDER + | DWT.FULL_SELECTION); + b.addSelectionListener(new class(v) SelectionListener { + TreeViewer v; + this(TreeViewer v_) + { + this.v = v_; + } + + public void widgetDefaultSelected(SelectionEvent e) { + + } + + public void widgetSelected(SelectionEvent e) { + MyModel root = cast(MyModel) v.getInput(); + TreePath path = new TreePath([ root, root.child.get(1), + (cast(MyModel) root.child.get(1)).child.get(0)] ); + v.editElement(path, 0); + } + + }); + + v.setCellEditors([ new TextCellEditor(v.getTree()) ]); + v.setColumnProperties(["col1"]); + v.setCellModifier(new class(v) ICellModifier { + TreeViewer v; + this(TreeViewer v_) + { + this.v = v_; + } + public bool canModify(Object element, String property) { + return true; + } + + public Object getValue(Object element, String property) { + return stringcast( to!(String)((cast(MyModel) element).counter) ~ "" ); + } + + public void modify(Object element, String property, Object value) { + element = (cast(Item) element).getData(); + (cast(MyModel) element).counter = Integer.parseInt(value.toString()); + v.update(element, null); + } + + }); + + TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager( + v, new FocusCellOwnerDrawHighlighter(v)); + ColumnViewerEditorActivationStrategy actSupport = new class(v) ColumnViewerEditorActivationStrategy { + this(ColumnViewer v) + { + super(v); + } + protected bool isEditorActivationEvent( + ColumnViewerEditorActivationEvent event) { + return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL + || event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION + || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == DWT.CR) + || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC; + } + }; + + TreeViewerEditor.create(v, focusCellManager, actSupport, + ColumnViewerEditor.TABBING_HORIZONTAL + | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR + | ColumnViewerEditor.TABBING_VERTICAL + | ColumnViewerEditor.KEYBOARD_ACTIVATION); + + v.setContentProvider(new MyContentProvider()); + + v.setInput(createModel()); + } + + private MyModel createModel() { + + MyModel root = new MyModel(0, null); + root.counter = 0; + + MyModel tmp; + MyModel subItem; + for (int i = 1; i < 10; i++) { + tmp = new MyModel(i, root); + root.child.add(tmp); + for (int j = 1; j < i; j++) { + subItem = new MyModel(j, tmp); + subItem.child.add(new MyModel(j * 100, subItem)); + tmp.child.add(subItem); + } + } + + return root; + } + + + + private class MyContentProvider : ITreeContentProvider { + + public Object[] getElements(Object inputElement) { + return (cast(MyModel) inputElement).child.toArray(); + } + + public void dispose() { + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + } + + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + public Object getParent(Object element) { + if (element is null) { + return null; + } + return (cast(MyModel) element).parent; + } + + public bool hasChildren(Object element) { + return (cast(MyModel) element).child.size() > 0; + } + + } + + public class MyModel { + public MyModel parent; + + public ArrayList child; + + public int counter; + + public this(int counter_, MyModel parent_) { + this.parent = parent_; + this.counter = counter_; + child = new ArrayList(); + } + + public String toString() { + String rv = "Item "; + if (parent !is null) { + rv = parent.toString() ~ "."; + } + + rv ~= to!(String)(counter); + + return rv; + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/viewers/Snippet047VirtualLazyTreeViewer.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,186 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + * Port to the D programming language: + * yidabu at gmail dot com ( D China http://www.d-programming-language-china.org/ ) + *******************************************************************************/ + +module snippets.viewers.Snippet047VirtualLazyTreeViewer; + +import dwtx.jface.viewers.ILazyTreeContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; + +import tango.util.Convert; +import tango.util.container.LinkedList; + +version(JIVE) import jive.stacktrace; + + +/** + * @param args + */ +void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet047VirtualLazyTreeViewer(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + +} + +/** + * A simple TreeViewer to demonstrate usage of an ILazyContentProvider. + * + */ +public class Snippet047VirtualLazyTreeViewer { + alias ArrayWrapperT!(IntermediateNode) ArrayWrapperIntermediateNode; + alias ArrayWrapperT!(LeafNode) ArrayWrapperLeafNode; + + private class MyContentProvider : ILazyTreeContentProvider { + private TreeViewer viewer; + private IntermediateNode[] elements; + + public this(TreeViewer viewer) { + this.viewer = viewer; + } + + public void dispose() { + + } + + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + if(cast(ArrayWrapperIntermediateNode) newInput) + this.elements = (cast(ArrayWrapperIntermediateNode) newInput).array; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ILazyTreeContentProvider#getParent(java.lang.Object) + */ + public Object getParent(Object element) { + if (cast(LeafNode)element) + return (cast(LeafNode) element).parent; + return new ArrayWrapperIntermediateNode(elements); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ILazyTreeContentProvider#updateChildCount(java.lang.Object, + * int) + */ + public void updateChildCount(Object element, int currentChildCount) { + + int length = 0; + if (cast(IntermediateNode)element) { + IntermediateNode node = cast(IntermediateNode) element; + length = node.children.length; + } + /// TODO: fix me access violation here + if(element !is null && elements !is null && (cast(ArrayWrapperIntermediateNode)element) && (cast(ArrayWrapperIntermediateNode)element).array is elements) + length = elements.length; + viewer.setChildCount(element, length); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ILazyTreeContentProvider#updateElement(java.lang.Object, + * int) + */ + public void updateElement(Object parent, int index) { + + Object element; + if (cast(IntermediateNode)parent) + element = (cast(IntermediateNode) parent).children[index]; + + else + element = elements[index]; + viewer.replace(parent, index, element); + updateChildCount(element, -1); + + } + + } + + public class LeafNode { + public int counter; + public IntermediateNode parent; + + public this(int counter, IntermediateNode parent) { + this.counter = counter; + this.parent = parent; + } + + public String toString() { + return "Leaf " ~ to!(String)(this.counter); + } + } + + public class IntermediateNode { + public int counter; + public LeafNode[] children; + + public this(int counter) { + this.counter = counter; + children = new LeafNode[0]; + } + + public String toString() { + return "Node " ~ to!(String)(this.counter); + } + + public void generateChildren(int i) { + children = new LeafNode[i]; + for (int j = 0; j < i; j++) { + children[j] = new LeafNode(j, this); + } + + } + } + + public this(Shell shell) { + final TreeViewer v = new TreeViewer(shell, DWT.VIRTUAL | DWT.BORDER); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider(v)); + v.setUseHashlookup(true); + IntermediateNode[] model = createModel(); + v.setInput(new ArrayWrapperIntermediateNode(model)); + v.getTree().setItemCount(model.length); + + } + + private IntermediateNode[] createModel() { + IntermediateNode[] elements = new IntermediateNode[10]; + + for (int i = 0; i < 10; i++) { + elements[i] = new IntermediateNode(i); + elements[i].generateChildren(1000); + } + + return elements; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/window/Snippet020CustomizedControlTooltips.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,261 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + *******************************************************************************/ + +module dwtx.jface.snippets.window.Snippet020CustomizedControlTooltips; + + +import dwtx.jface.resource.ImageDescriptor; +import dwtx.jface.resource.JFaceResources; +import dwtx.jface.util.Policy; +import dwtx.jface.window.DefaultToolTip; +import dwtx.jface.window.ToolTip; +import dwt.DWT; +import dwt.events.MouseAdapter; +import dwt.events.MouseEvent; +import dwt.events.SelectionAdapter; +import dwt.events.SelectionEvent; +import dwt.events.SelectionListener; +import dwt.graphics.Point; +import dwt.graphics.RGB; +import dwt.layout.FillLayout; +import dwt.layout.GridData; +import dwt.layout.GridLayout; +import dwt.layout.RowLayout; +import dwt.widgets.Button; +import dwt.widgets.Composite; +import dwt.widgets.Control; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Label; +import dwt.widgets.Link; +import dwt.widgets.MessageBox; +import dwt.widgets.Shell; +import dwt.widgets.Text; + +import dwt.dwthelper.utils; +version(JIVE) import jive.stacktrace; + +/** + * Demonstrate usage of custom toolstips for controls + * + * @author Tom Schindl + * + */ +public class Snippet020CustomizedControlTooltips { + protected class MyToolTip : ToolTip { + + private Shell parentShell; + + private String headerText = "ToolTip-Header"; + + public static const String HEADER_BG_COLOR = Policy.JFACE ~ ".TOOLTIP_HEAD_BG_COLOR"; + + public static const String HEADER_FG_COLOR = Policy.JFACE ~ ".TOOLTIP_HEAD_FG_COLOR"; + + public static const String HEADER_FONT = Policy.JFACE ~ ".TOOLTIP_HEAD_FONT"; + + public static const String HEADER_CLOSE_ICON = Policy.JFACE ~ ".TOOLTIP_CLOSE_ICON"; + public static const String HEADER_HELP_ICON = Policy.JFACE ~ ".TOOLTIP_HELP_ICON"; + + public this(Control control) { + super(control); + this.parentShell = control.getShell(); + } + + protected Composite createToolTipContentArea(Event event, + Composite parent) { + Composite comp = new Composite(parent,DWT.NONE); + + GridLayout gl = new GridLayout(1,false); + gl.marginBottom=0; + gl.marginTop=0; + gl.marginHeight=0; + gl.marginWidth=0; + gl.marginLeft=0; + gl.marginRight=0; + gl.verticalSpacing=1; + comp.setLayout(gl); + + Composite topArea = new Composite(comp,DWT.NONE); + GridData data = new GridData(DWT.FILL,DWT.FILL,true,false); + data.widthHint=200; + topArea.setLayoutData(data); + topArea.setBackground(JFaceResources.getColorRegistry().get(HEADER_BG_COLOR)); + + gl = new GridLayout(2,false); + gl.marginBottom=2; + gl.marginTop=2; + gl.marginHeight=0; + gl.marginWidth=0; + gl.marginLeft=5; + gl.marginRight=2; + + topArea.setLayout(gl); + + Label l = new Label(topArea,DWT.NONE); + l.setText(headerText); + l.setBackground(JFaceResources.getColorRegistry().get(HEADER_BG_COLOR)); + l.setFont(JFaceResources.getFontRegistry().get(HEADER_FONT)); + l.setForeground(JFaceResources.getColorRegistry().get(HEADER_FG_COLOR)); + l.setLayoutData(new GridData(GridData.FILL_BOTH)); + + Composite iconComp = new Composite(topArea,DWT.NONE); + iconComp.setLayoutData(new GridData()); + iconComp.setLayout(new GridLayout(2,false)); + iconComp.setBackground(JFaceResources.getColorRegistry().get(HEADER_BG_COLOR)); + + gl = new GridLayout(2,false); + gl.marginBottom=0; + gl.marginTop=0; + gl.marginHeight=0; + gl.marginWidth=0; + gl.marginLeft=0; + gl.marginRight=0; + iconComp.setLayout(gl); + + Label helpIcon = new Label(iconComp,DWT.NONE); + helpIcon.setBackground(JFaceResources.getColorRegistry().get(HEADER_BG_COLOR)); + helpIcon.setImage(JFaceResources.getImage(HEADER_HELP_ICON)); + helpIcon.addMouseListener(new class MouseAdapter { + + public void mouseDown(MouseEvent e) { + hide(); + openHelp(); + } + }); + + + Label closeIcon = new Label(iconComp,DWT.NONE); + closeIcon.setBackground(JFaceResources.getColorRegistry().get(HEADER_BG_COLOR)); + closeIcon.setImage(JFaceResources.getImage(HEADER_CLOSE_ICON)); + closeIcon.addMouseListener(new class MouseAdapter { + + public void mouseDown(MouseEvent e) { + parentShell.setFocus(); + hide(); + } + }); + + createContentArea(comp).setLayoutData(new GridData(GridData.FILL_BOTH)); + + return comp; + } + + protected Composite createContentArea(Composite parent) { + return new Composite(parent,DWT.NONE); + } + + protected void openHelp() { + parentShell.setFocus(); + } + } + + class MyToolTip2 : MyToolTip { + public this(Control control) { + super(control); + } + protected Composite createContentArea(Composite parent) { + Composite comp = super.createContentArea(parent); + comp.setBackground(parent.getDisplay().getSystemColor(DWT.COLOR_INFO_BACKGROUND)); + FillLayout layout = new FillLayout(); + layout.marginWidth=5; + comp.setLayout(layout); + Link l = new Link(comp,DWT.NONE); + l.setText("This a custom tooltip you can: \n- pop up any control you want\n- define delays\n - ... \nGo and get Eclipse M4 from <a>http://www.eclipse.org</a>"); + l.setBackground(parent.getDisplay().getSystemColor(DWT.COLOR_INFO_BACKGROUND)); + l.addSelectionListener(new class SelectionAdapter { + public void widgetSelected(SelectionEvent e) { + openURL(); + } + }); + return comp; + } + + protected void openURL() { + MessageBox box = new MessageBox(parent,DWT.ICON_INFORMATION); + box.setText("Eclipse.org"); + box.setMessage("Here is where we'd open the URL."); + box.open(); + } + + protected void openHelp() { + MessageBox box = new MessageBox(parent,DWT.ICON_INFORMATION); + box.setText("Info"); + box.setMessage("Here is where we'd show some information."); + box.open(); + } + + }; + Shell parent; + DefaultToolTip toolTipDelayed; + + public this(Shell parent_) { + this.parent = parent_; + JFaceResources.getColorRegistry().put(MyToolTip.HEADER_BG_COLOR, new RGB(255,255,255)); + JFaceResources.getFontRegistry().put(MyToolTip.HEADER_FONT, JFaceResources.getFontRegistry().getBold(JFaceResources.getDefaultFont().getFontData()[0].getName()).getFontData()); + + + JFaceResources.getImageRegistry().put(MyToolTip.HEADER_CLOSE_ICON,ImageDescriptor.createFromFile(getImportData!("jface.snippets.showerr_tsk.gif"))); + JFaceResources.getImageRegistry().put(MyToolTip.HEADER_HELP_ICON,ImageDescriptor.createFromFile(getImportData!("jface.snippets.linkto_help.gif"))); + + Text text = new Text(parent,DWT.BORDER); + text.setText("Hello World"); + + MyToolTip myTooltipLabel = new MyToolTip2(text); + myTooltipLabel.setShift(new Point(-5, -5)); + myTooltipLabel.setHideOnMouseDown(false); + myTooltipLabel.activate(); + + text = new Text(parent,DWT.BORDER); + text.setText("Hello World"); + DefaultToolTip toolTip = new DefaultToolTip(text); + toolTip.setText("Hello World\nHello World"); + toolTip.setBackgroundColor(parent.getDisplay().getSystemColor(DWT.COLOR_RED)); + + Button b = new Button(parent,DWT.PUSH); + b.setText("Popup on press"); + + toolTipDelayed = new DefaultToolTip(b,ToolTip.RECREATE,true); + toolTipDelayed.setText("Hello World\nHello World"); + toolTipDelayed.setBackgroundColor(parent.getDisplay().getSystemColor(DWT.COLOR_RED)); + toolTipDelayed.setHideDelay(2000); + + b.addSelectionListener(new class SelectionAdapter { + public void widgetSelected(SelectionEvent e) { + toolTipDelayed.show(new Point(0,0)); + } + }); + + + } + + public static void main(String[] args) { + Display display = new Display(); + + Shell shell = new Shell(display); + shell.setLayout(new RowLayout()); + new Snippet020CustomizedControlTooltips(shell); + + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + } +} + +void main(){ + Snippet020CustomizedControlTooltips.main(null); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/window/Snippet023TreeViewerCustomTooltips.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,253 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + *******************************************************************************/ + +module dwtx.jface.snippets.window.Snippet023TreeViewerCustomTooltips; + +import dwtx.jface.viewers.CellLabelProvider; +import dwtx.jface.viewers.ITreeContentProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TreeViewer; +import dwtx.jface.viewers.Viewer; +import dwt.DWT; +import dwt.graphics.Point; +import dwt.graphics.Rectangle; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Event; +import dwt.widgets.Label; +import dwt.widgets.Listener; +import dwt.widgets.Shell; +import dwt.widgets.TreeItem; + +import dwtx.dwtxhelper.Collection; +import dwt.dwthelper.utils; +import tango.text.convert.Format; +import tango.util.log.Trace; + +/** + * A simple TreeViewer to demonstrate how custom tooltips could be created + * easily. This is an extended version from + * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/dwt.snippets/src/org/eclipse/swt/snippets/Snippet125.java + * + * This code is for users pre 3.3 others could use newly added tooltip support in + * {@link CellLabelProvider} + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet023TreeViewerCustomTooltips { + private class MyContentProvider : ITreeContentProvider { + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return (cast(MyModel) inputElement).child.toArray(); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object) + */ + public Object[] getChildren(Object parentElement) { + return getElements(parentElement); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#getParent(java.lang.Object) + */ + public Object getParent(Object element) { + if (element is null) { + return null; + } + + return (cast(MyModel) element).parent; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object) + */ + public bool hasChildren(Object element) { + return (cast(MyModel) element).child.size() > 0; + } + + } + + public class MyModel { + public MyModel parent; + + public ArrayList child; + + public int counter; + + public this(int counter, MyModel parent) { + this.parent = parent; + this.counter = counter; + child = new ArrayList(); + } + + public String toString() { + return Format( "Item {}{}", (parent !is null) ? "." : "", counter ); + } + } + + TreeViewer v; + Listener labelListener; + + public this(Shell shell) { + v = new TreeViewer(shell); + v.setLabelProvider(new LabelProvider()); + v.setContentProvider(new MyContentProvider()); + v.setInput(createModel()); + v.getTree().setToolTipText(""); + + labelListener = dgListener ( (Event event){ + Label label = cast(Label)event.widget; + Shell shell_ = label.getShell (); + switch (event.type) { + case DWT.MouseDown: + Event e = new Event (); + e.item = cast(TreeItem) label.getData ("_TABLEITEM"); + // Assuming table is single select, set the selection as if + // the mouse down event went through to the table + v.getTree().setSelection ([cast(TreeItem) e.item]); + v.getTree().notifyListeners (DWT.Selection, e); + shell_.dispose (); + v.getTree().setFocus(); + break; + case DWT.MouseExit: + shell_.dispose (); + break; + default: + } + }); + + Listener treeListener = new MyTreeListener(); + v.getTree().addListener (DWT.Dispose, treeListener); + v.getTree().addListener (DWT.KeyDown, treeListener); + v.getTree().addListener (DWT.MouseMove, treeListener); + v.getTree().addListener (DWT.MouseHover, treeListener); + } + + class MyTreeListener : Listener { + Shell tip = null; + Label label = null; + public void handleEvent (Event event) { + switch (event.type) { + case DWT.Dispose: + case DWT.KeyDown: + case DWT.MouseMove: { + if (tip is null) break; + tip.dispose (); + tip = null; + label = null; + break; + } + case DWT.MouseHover: { + Point coords = new Point(event.x, event.y); + TreeItem item = v.getTree().getItem(coords); + if (item !is null) { + int columns = v.getTree().getColumnCount(); + + for (int i = 0; i < columns || i is 0; i++) { + if (item.getBounds(i).contains(coords)) { + if (tip !is null && !tip.isDisposed ()) tip.dispose (); + tip = new Shell (v.getTree().getShell(), DWT.ON_TOP | DWT.NO_FOCUS | DWT.TOOL); + tip.setBackground (v.getTree().getDisplay().getSystemColor (DWT.COLOR_INFO_BACKGROUND)); + FillLayout layout = new FillLayout (); + layout.marginWidth = 2; + tip.setLayout (layout); + label = new Label (tip, DWT.NONE); + label.setForeground (v.getTree().getDisplay().getSystemColor (DWT.COLOR_INFO_FOREGROUND)); + label.setBackground (v.getTree().getDisplay().getSystemColor (DWT.COLOR_INFO_BACKGROUND)); + label.setData ("_TABLEITEM", item); + label.setText (Format("Tooltip: {} => {}", item.getData(), i)); + label.addListener (DWT.MouseExit, labelListener); + label.addListener (DWT.MouseDown, labelListener); + Point size = tip.computeSize (DWT.DEFAULT, DWT.DEFAULT); + Rectangle rect = item.getBounds (i); + Point pt = v.getTree().toDisplay (rect.x, rect.y); + tip.setBounds (pt.x, pt.y, size.x, size.y); + tip.setVisible (true); + break; + } + } + } + } + default: + } + } + }; + + private MyModel createModel() { + + MyModel root = new MyModel(0, null); + root.counter = 0; + + MyModel tmp; + for (int i = 1; i < 10; i++) { + tmp = new MyModel(i, root); + root.child.add(tmp); + for (int j = 1; j < i; j++) { + tmp.child.add(new MyModel(j, tmp)); + } + } + + return root; + } + + public static void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet023TreeViewerCustomTooltips(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + } +} + +void main(){ + Snippet023TreeViewerCustomTooltips.main(null); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/window/Snippet031TableStaticTooltip.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,190 @@ +/******************************************************************************* + * Copyright (c) 2006 Tom Schindl 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: + * Tom Schindl - initial API and implementation + *******************************************************************************/ + +module dwtx.jface.snippets.window.Snippet031TableStaticTooltip; + +import dwtx.jface.viewers.IStructuredContentProvider; +import dwtx.jface.viewers.ITableLabelProvider; +import dwtx.jface.viewers.LabelProvider; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.viewers.Viewer; +import dwtx.jface.window.DefaultToolTip; +import dwtx.jface.window.ToolTip; +import dwt.DWT; +import dwt.graphics.Color; +import dwt.graphics.GC; +import dwt.graphics.Image; +import dwt.graphics.Point; +import dwt.layout.FillLayout; +import dwt.widgets.Display; +import dwt.widgets.Shell; +import dwt.widgets.TableColumn; + +import dwt.dwthelper.utils; +import tango.text.convert.Format; + + +/** + * Example how one can create a tooltip which is not recreated for every table + * cell + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * + */ +public class Snippet031TableStaticTooltip { + private static Image[] images; + + private class MyContentProvider : IStructuredContentProvider { + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) + */ + public Object[] getElements(Object inputElement) { + return arrayFromObject!(MyModel)( inputElement ); + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#dispose() + */ + public void dispose() { + + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, + * java.lang.Object, java.lang.Object) + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + + } + + } + + public class MyModel { + public int counter; + + public this(int counter) { + this.counter = counter; + } + + public String toString() { + return Format("Item {}", this.counter ); + } + } + + public class MyLabelProvider : LabelProvider, + ITableLabelProvider { + + public Image getColumnImage(Object element, int columnIndex) { + if (columnIndex == 1) { + return images[(cast(MyModel) element).counter % 4]; + } + + return null; + } + + public String getColumnText(Object element, int columnIndex) { + return Format("Column {} => {}", columnIndex, element.toString()); + } + + } + + private static Image createImage(Display display, int red, int green, + int blue) { + Color color = new Color(display, red, green, blue); + Image image = new Image(display, 10, 10); + GC gc = new GC(image); + gc.setBackground(color); + gc.fillRectangle(0, 0, 10, 10); + gc.dispose(); + + return image; + } + + TableViewer v; + public this(Shell shell) { + v = new TableViewer(shell, DWT.BORDER + | DWT.FULL_SELECTION); + v.setLabelProvider(new MyLabelProvider()); + v.setContentProvider(new MyContentProvider()); + + TableColumn column = new TableColumn(v.getTable(), DWT.NONE); + column.setWidth(200); + column.setText("Column 1"); + + column = new TableColumn(v.getTable(), DWT.NONE); + column.setWidth(200); + column.setText("Column 2"); + + MyModel[] model = createModel(); + v.setInput(new ArrayWrapperObject(arraycast!(Object)(model))); + v.getTable().setLinesVisible(true); + v.getTable().setHeaderVisible(true); + + DefaultToolTip toolTip = new DefaultToolTip(v.getControl(), + ToolTip.NO_RECREATE, false); + toolTip.setText("Hello World\nHello World"); + toolTip.setBackgroundColor(v.getTable().getDisplay().getSystemColor( + DWT.COLOR_RED)); + toolTip.setShift(new Point(10, 5)); + } + + private MyModel[] createModel() { + MyModel[] elements = new MyModel[10]; + + for (int i = 0; i < 10; i++) { + elements[i] = new MyModel(i); + } + + return elements; + } + + /** + * @param args + */ + public static void main(String[] args) { + Display display = new Display(); + + images = new Image[4]; + images[0] = createImage(display, 0, 0, 255); + images[1] = createImage(display, 0, 255, 255); + images[2] = createImage(display, 0, 255, 0); + images[3] = createImage(display, 255, 0, 255); + + Shell shell = new Shell(display); + shell.setLayout(new FillLayout()); + new Snippet031TableStaticTooltip(shell); + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + for (int i = 0; i < images.length; i++) { + images[i].dispose(); + } + + display.dispose(); + + } + +} + +void main(){ + Snippet031TableStaticTooltip.main(null); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface.snippets/EclipseJfaceSnippets/org/eclipse/jface/snippets/wizard/Snippet047WizardWithLongRunningOperation.d Mon Mar 23 11:16:06 2009 +0100 @@ -0,0 +1,285 @@ +/******************************************************************************* + * Copyright (c) 2005, 2007 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 jface.snippets.wizard.Snippet047WizardWithLongRunningOperation; + +import dwtx.jface.viewers.ArrayContentProvider; +import dwtx.jface.viewers.ISelectionChangedListener; +import dwtx.jface.viewers.SelectionChangedEvent; +import dwtx.jface.viewers.TableViewer; +import dwtx.jface.wizard.IWizardPage; +import dwtx.jface.wizard.Wizard; +import dwtx.jface.wizard.WizardDialog; +import dwtx.jface.wizard.WizardPage; +import dwt.DWT; +import dwt.events.SelectionAdapter; +import dwt.events.SelectionEvent; +import dwt.layout.FillLayout; +import dwt.layout.GridData; +import dwt.layout.GridLayout; +import dwt.widgets.Button; +import dwt.widgets.Composite; +import dwt.widgets.Display; +import dwt.widgets.Label; +import dwt.widgets.ProgressBar; +import dwt.widgets.Shell; + +import dwt.dwthelper.utils; +import dwt.dwthelper.Runnable; +import dwtx.dwtxhelper.Collection; +import tango.core.Thread; +import tango.text.convert.Format; +import tango.util.log.Trace; + +import dwtx.jface.operation.ModalContext; + +/** + * Example how to load data from a background thread into a TableViewer + * + * @author Tom Schindl <tom.schindl@bestsolution.at> + * @since 1.0 + */ +public class Snippet047WizardWithLongRunningOperation { + + private static class MyWizard : Wizard { + + private int loadingType; + + public this(int loadingType) { + this.loadingType = loadingType; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.wizard.Wizard#addPages() + */ + public void addPages() { + addPage(new MyWizardPageThread("Thread Page", loadingType)); + addPage(new MyWizardPage("Standard Page")); + } + + public bool performFinish() { + return true; + } + + /* + * (non-Javadoc) + * + * @see dwtx.jface.wizard.Wizard#canFinish() + */ + public bool canFinish() { + IWizardPage[] pages = getPages(); + for (int i = 0; i < pages.length; i++) { + if (!pages[i].isPageComplete()) { + return false; + } + } + + return true; + } + + }; + + private static class MyWizardPage : WizardPage { + + protected this(String pageName) { + super(pageName); + setTitle(pageName); + } + + public /+override+/ void createControl(Composite parent) { + Composite comp = new Composite(parent, DWT.NONE); + setControl(comp); + } + } + + private static class MyWizardPageThread : WizardPage { + private int loadingType; + private bool loading = true; + private TableViewer v; + + protected this(String pageName, int loadingType) { + super(pageName); + this.loadingType = loadingType; + setTitle(pageName); + } + + public /+override+/ void createControl(Composite parent) { + auto mt = new MyThread(); + mt.parent = parent; + + mt.comp = new Composite(parent, DWT.NONE); + mt.comp.setLayout(new GridLayout(1, false)); + + v = new TableViewer(mt.comp, DWT.FULL_SELECTION); + v.setContentProvider(new ArrayContentProvider!(Object)()); + v.getTable().setLayoutData(new GridData(GridData.FILL_BOTH)); + v.addSelectionChangedListener(new class ISelectionChangedListener { + + public void selectionChanged(SelectionChangedEvent event) { + getWizard().getContainer().updateButtons(); + } + + }); + + mt.barContainer = new Composite(mt.comp, DWT.NONE); + mt.barContainer.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); + mt.barContainer.setLayout(new GridLayout(2, false)); + + Label l = new Label(mt.barContainer, DWT.NONE); + l.setText("Loading Data"); + + mt.bar = new ProgressBar(mt.barContainer, + (loadingType == 1) ? DWT.INDETERMINATE : DWT.NONE); + mt.bar.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); + + if (loadingType == 2) { + mt.bar.setMaximum(10); + } + + setControl(mt.comp); + + ModalContext.run( dgRunnable(&mt.threadWork), true, getProgressMonitor(), getShell().getDisplay() ); + + //Thread t = new Thread(&mt.threadWork); + + // t.start(); + } + class MyThread { + private Composite parent; + private Composite barContainer; + private Composite comp; + private ProgressBar bar; + + private void threadWork(){ + if (loadingType == 1) { + try { + Thread.sleep(10.000); + ArrayList ms = new ArrayList(); + for (int i = 0; i < 10; i++) { + ms.add(new MyModel(i)); + } + + if (v.getTable().isDisposed()) { + return; + } + + parent.getDisplay().asyncExec(dgRunnable((ArrayList ms_){ + v.setInput(ms_); + (cast(GridData) barContainer.getLayoutData()).exclude = true; + comp.layout(true); + }, ms )); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + ExceptionPrintStackTrace(e); + } + } else { + ArrayList ms = new ArrayList(); + parent.getDisplay().syncExec( dgRunnable( (ArrayList ms_){ + v.setInput(ms_); + }, ms )); + + for (int i = 0; i < 10; i++) { + int j = i; + if (v.getTable().isDisposed()) { + return; + } + parent.getDisplay().asyncExec( dgRunnable( (int j_){ + MyModel tmp = new MyModel(j_); + v.add(tmp); + ms.add(tmp); + bar.setSelection(j_ + 1); + }, j )); + + try { + Thread.sleep(1.000); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + ExceptionPrintStackTrace(e); + } + } + + parent.getDisplay().asyncExec(dgRunnable( { + + (cast(GridData) barContainer.getLayoutData()).exclude = true; + comp.layout(true); + })); + } + + parent.getDisplay().syncExec(dgRunnable( { + loading = false; + getWizard().getContainer().updateButtons(); + })); + } + } + public bool isPageComplete() { + return !loading && !v.getSelection().isEmpty(); + } + + } + + private static class MyModel { + private int index; + + public this(int index) { + this.index = index; + } + + public String toString() { + return Format("Item-{}", index); + } + } + + static Shell shell; + public static void main(String[] args) { + Display display = new Display(); + + shell = new Shell(display); + shell.setLayout(new FillLayout()); + + Button b = new Button(shell, DWT.PUSH); + b.setText("Load in one Chunk"); + b.addSelectionListener(new class SelectionAdapter { + + public void widgetSelected(SelectionEvent e) { + WizardDialog dialog = new WizardDialog(shell, new MyWizard(1)); + dialog.open(); + } + + }); + + b = new Button(shell, DWT.PUSH); + b.setText("Load Item by Item"); + b.addSelectionListener(new class SelectionAdapter { + + public void widgetSelected(SelectionEvent e) { + WizardDialog dialog = new WizardDialog(shell, new MyWizard(2)); + dialog.open(); + } + + }); + + shell.open(); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + + display.dispose(); + } +} + +void main(){ + Snippet047WizardWithLongRunningOperation.main(null); +}