Attachment #179930 for bug #326159

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
* Copyright (c) 2008, 2010 EclipseSource 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

*
* Contributors:
*   EclipseSource - initial API and implementation
*******************************************************************************/
package org.eclipse.rap.internal.design.example.managers;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.internal.provisional.action.ToolBarManager2;
import org.eclipse.rwt.lifecycle.WidgetUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;


public class ViewToolBarManager extends ToolBarManager2 {
  
  private static final String STYLING_VARIANT = "viewToolbar"; //$NON-NLS-1$
  private ToolBar toolBar;
  private ToolBar fakeToolbar;

  private static final String STYLING_VARIANT = "viewToolbar"; //$NON-NLS-1$
  private ToolBar fakeToolBar;

  public ToolBar createControl( final Composite parent ) {
    fakeToolBar = new ToolBar( parent, SWT.NONE );
    fakeToolBar.setVisible( false );
    ToolBar toolBar = super.createControl( parent );
    toolBar.setData( WidgetUtil.CUSTOM_VARIANT, STYLING_VARIANT );
      // create the fake Toolbar
      fakeToolbar = new ToolBar( parent, SWT.NONE );
      fakeToolbar.setVisible( false );
      update( true );
    }
    return toolBar;
  }
  
  public ToolBar getControl() {
    return toolBar;
  }

  private Menu getContextMenuControl() {
    Menu result = null;
    if( ( getContextMenuManager() != null ) && ( toolBar != null ) ) {
      Menu menuWidget = getContextMenuManager().getMenu();
      if( ( menuWidget == null ) || ( menuWidget.isDisposed() ) ) {
        menuWidget = getContextMenuManager().createContextMenu( toolBar);
      }
      result = menuWidget;
    }
    return result;
  }
  
  private boolean toolBarExist() {
    return toolBar != null && !toolBar.isDisposed();
  }
  
  /*
   * (non-Javadoc) Method declared on IContributionManager.
   */
  public void update( boolean force ) {
    if( isDirty() || force ) {
      if( toolBarExist() ) {
        ToolBar toolBar = getControl();
        // clean contains all active items without double separators
        IContributionItem[] items = getItems();
        ArrayList clean = new ArrayList(items.length);
        IContributionItem separator = null;
        for( int i = 0; i < items.length; ++i ) {
          IContributionItem ci = items[ i ];
          if( ci.isSeparator() ) {
            separator = ci;
          } else {
            if( separator != null ) {
              if( clean.size() > 0 ) {
                clean.add( separator );
              }
              separator = null;
            }
            clean.add( ci );
          }
        }
        // determine obsolete items (removed or non active)
        ToolItem[] mi = toolBar.getItems();
        ArrayList toRemove = new ArrayList( mi.length );
        for( int i = 0; i < mi.length; i++ ) {
          // there may be null items in a toolbar
          if( mi[ i ] == null ) {
            continue;
          }
          Object data = mi[ i ].getData();
          if( data == null
              || !clean.contains( data )
              || ( data instanceof IContributionItem && ( ( IContributionItem ) data)
                  .isDynamic() ) ) {
            toRemove.add( mi[ i ] );
          }
        }

        // Turn redraw off if the number of items to be added
        // is above a certain threshold, to minimize flicker,
        // otherwise the toolbar can be seen to redraw after each item.

          if( useRedraw ) {
            toolBar.setRedraw( false );
          }

          // remove obsolete items
          for (int i = toRemove.size(); --i >= 0;) {
            ToolItem item = ( ToolItem )toRemove.get( i );
            if( !item.isDisposed() ) {
              Control ctrl = item.getControl();
              if( ctrl != null ) {

              item.dispose();
            }
          }

          // add new items
          IContributionItem src, dest;
          mi = toolBar.getItems();
          int srcIx = 0;
          int destIx = 0;
          
          for( Iterator e = clean.iterator(); e.hasNext(); ) {
            src = ( IContributionItem )e.next();

            // get corresponding item in SWT widget
            if( srcIx < mi.length ) {
              dest = ( IContributionItem )mi[ srcIx ].getData();
            } else {
              dest = null;
            }

            if( dest != null && src.equals( dest ) ) {
              srcIx++;
              destIx++;
              continue;
            }
            if( dest != null && dest.isSeparator() && src.isSeparator() ) {
            if(    dest != null && dest.isSeparator()
                && src.isSeparator() ) 
            {
              mi[ srcIx ].setData( src );
              srcIx++;
              destIx++;
              continue;
            }
            int start = toolBar.getItemCount();
            src.fill( toolBar, destIx );
            int newItems = toolBar.getItemCount() - start;
            for( int i = 0; i < newItems; i++ ) {
              ToolItem item = toolBar.getItem( destIx++ );
              item.setData( src );
            } else {
              src.fill( fakeToolbar, destIx );
              tempToolBar = fakeToolbar;
            }
            // check necessary for bug 306741
            if( destIx >= 0 && destIx < tempToolBar.getItemCount() - 1 ) {
              ToolItem toolItem = tempToolBar.getItem( destIx );
              toolItem.setData( src );
              toolItem.setData( WidgetUtil.CUSTOM_VARIANT, STYLING_VARIANT );
            }
          }

          // remove any old tool items not accounted for
          for( int i = mi.length; --i >= srcIx; ) {
            ToolItem item = mi[ i ];

              item.dispose();
            }
          }
          setDirty(false);
          updateFakeToolBar();
          disposeInvisibleItems();
        } finally {
          // turn redraw back on if we turned it off above
          if( useRedraw ) {

      }
    }
  }

  public ToolItem[] getToolItems() {
    return fakeToolBar.getItems();
  }

  private boolean toolBarExist() {
    ToolBar toolBar = getControl();
    return toolBar != null && !toolBar.isDisposed();
  }

  private void updateFakeToolBar() {
    ToolBar toolBar = getControl();
    ToolItem[] items = fakeToolBar.getItems();
    for( int i = 0; i < items.length; i++ ) {
      items[ i ].dispose();
    }
    items = toolBar.getItems();
    for( int i = 0; i < items.length; i++ ) {
      ToolItem item = new ToolItem( fakeToolBar, items[ i ].getStyle() );
      item.setText( items[ i ].getText() );
      item.setToolTipText( items[ i ].getToolTipText() );
      item.setImage( items[ i ].getImage() );
      item.setData( items[ i ].getData() );
    }
    return result;
  }

  private void disposeInvisibleItems() {
    ToolBar toolBar = getControl();
    ToolItem[] items = toolBar.getItems();
    for( int i = 0; i < items.length; i++ ) {
      ToolItem item = items[ i ];
      if( !item.isDisposed() ) {
        Object data = item.getData();
        if( data instanceof IContributionItem ) {
          IContributionItem itemData = ( IContributionItem )data;
          if( !itemData.isVisible() ) {
            Control ctrl = item.getControl();
            if( ctrl != null ) {
              item.setControl( null );
              ctrl.dispose();
            }
            item.dispose();
          }
        }
      }
    }
  }
}




      = ( ConfigurableStack ) action.getStackPresentation();
    IToolBarManager manager = stackPresentation.getPartToolBarManager();
    if( manager != null ) {
      manager.update( true );
    }
    action.fireToolBarChange();
    return super.close();

    fdOK.width = 90;
    ok.addSelectionListener( new SelectionAdapter() {
      public void widgetSelected( final SelectionEvent e ) {
        close( true );
      };
    } );
    ok.moveAbove( cancel );

      String paneId = stackPresentation.getPaneId( site );
      if( manager instanceof ViewToolBarManager ) {
        //manager.update( true );
        ToolItem[] toolItems = ( ( ViewToolBarManager) manager ).getToolItems();
        for( int i = 0; i < toolItems.length; i++ ) {
          ToolItem item = toolItems[ i ];
          if( item != null && !item.isDisposed() ) {
            // handle parameter
            IContributionItem contribItem
              = ( IContributionItem ) item.getData();
            String itemId = contribItem.getId();
            Image icon = item.getImage();

            } else {
              text = item.getToolTipText();
            }

            // render the dialog
            Label imageLabel = new Label( container, SWT.NONE );
            imageLabel.setImage( icon );

              lastImageLabel = imageLabel;
            }
            fdImageLabel.left = new FormAttachment( 0, OFFSET * 4 );

            Button check = new Button( container, SWT.CHECK );
            check.setText( text );
            check.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );

    }
  }

  public int open() {
    int result = super.open();
    Shell shell = getShell();
    shell.setData( WidgetUtil.CUSTOM_VARIANT, "confDialog" ); //$NON-NLS-1$
    shell.setBackgroundMode( SWT.INHERIT_NONE );
    shell.setText( Messages.get().ConfigurationDialog_ConfigurationFor
                   + site.getSelectedPart().getName() );
    String configDialogIcon = ILayoutSetConstants.CONFIG_DIALOG_ICON;
    shell.setImage( builder.getImage( configDialogIcon ) );

Return to bug 326159

Lines 112-118 Link Here

(-)src/org/eclipse/rap/internal/design/example/stacks/ConfigurationDialog.java (-10 / +10 lines)
112	= ( ConfigurableStack ) action.getStackPresentation();	112	= ( ConfigurableStack ) action.getStackPresentation();
113	IToolBarManager manager = stackPresentation.getPartToolBarManager();	113	IToolBarManager manager = stackPresentation.getPartToolBarManager();
114	if( manager != null ) {	114	if( manager != null ) {
115	manager.update( true );	115	manager.update( true );
116	}	116	}
117	action.fireToolBarChange();	117	action.fireToolBarChange();
118	return super.close();	118	return super.close();
Lines 161-167 Link Here
161	fdOK.width = 90;	161	fdOK.width = 90;
162	ok.addSelectionListener( new SelectionAdapter() {	162	ok.addSelectionListener( new SelectionAdapter() {
163	public void widgetSelected( final SelectionEvent e ) {	163	public void widgetSelected( final SelectionEvent e ) {
164	close( true );	164	close( true );
165	};	165	};
166	} );	166	} );
167	ok.moveAbove( cancel );	167	ok.moveAbove( cancel );
Lines 209-220 Link Here
209	String paneId = stackPresentation.getPaneId( site );	209	String paneId = stackPresentation.getPaneId( site );
210	if( manager instanceof ViewToolBarManager ) {	210	if( manager instanceof ViewToolBarManager ) {
211	//manager.update( true );	211	//manager.update( true );
212	List toolItems = ( ( ViewToolBarManager) manager ).getToolItems();	212	ToolItem[] toolItems = ( ( ViewToolBarManager) manager ).getToolItems();
213	for( int i = 0; i < toolItems.size(); i++ ) {	213	for( int i = 0; i < toolItems.length; i++ ) {
214	ToolItem item = ( ToolItem ) toolItems.get( i );	214	ToolItem item = toolItems[ i ];
215	if( item != null && !item.isDisposed() ) {	215	if( item != null && !item.isDisposed() ) {
216	// handle parameter	216	// handle parameter
217	IContributionItem contribItem	217	IContributionItem contribItem
218	= ( IContributionItem ) item.getData();	218	= ( IContributionItem ) item.getData();
219	String itemId = contribItem.getId();	219	String itemId = contribItem.getId();
220	Image icon = item.getImage();	220	Image icon = item.getImage();
Lines 224-230 Link Here
224	} else {	224	} else {
225	text = item.getToolTipText();	225	text = item.getToolTipText();
226	}	226	}
227		227
228	// render the dialog	228	// render the dialog
229	Label imageLabel = new Label( container, SWT.NONE );	229	Label imageLabel = new Label( container, SWT.NONE );
230	imageLabel.setImage( icon );	230	imageLabel.setImage( icon );
Lines 238-244 Link Here
238	lastImageLabel = imageLabel;	238	lastImageLabel = imageLabel;
239	}	239	}
240	fdImageLabel.left = new FormAttachment( 0, OFFSET * 4 );	240	fdImageLabel.left = new FormAttachment( 0, OFFSET * 4 );
241		241
242	Button check = new Button( container, SWT.CHECK );	242	Button check = new Button( container, SWT.CHECK );
243	check.setText( text );	243	check.setText( text );
244	check.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );	244	check.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );
Lines 259-270 Link Here
259	}	259	}
260	}	260	}
261		261
262	public int open() {	262	public int open() {
263	int result = super.open();	263	int result = super.open();
264	Shell shell = getShell();	264	Shell shell = getShell();
265	shell.setData( WidgetUtil.CUSTOM_VARIANT, "confDialog" ); //$NON-NLS-1$	265	shell.setData( WidgetUtil.CUSTOM_VARIANT, "confDialog" ); //$NON-NLS-1$
266	shell.setBackgroundMode( SWT.INHERIT_NONE );	266	shell.setBackgroundMode( SWT.INHERIT_NONE );
267	shell.setText( Messages.get().ConfigurationDialog_ConfigurationFor	267	shell.setText( Messages.get().ConfigurationDialog_ConfigurationFor
268	+ site.getSelectedPart().getName() );	268	+ site.getSelectedPart().getName() );
269	String configDialogIcon = ILayoutSetConstants.CONFIG_DIALOG_ICON;	269	String configDialogIcon = ILayoutSetConstants.CONFIG_DIALOG_ICON;
270	shell.setImage( builder.getImage( configDialogIcon ) );	270	shell.setImage( builder.getImage( configDialogIcon ) );

Lines 1-4 Link Here

(-)src/org/eclipse/rap/internal/design/example/managers/ViewToolBarManager.java (-93 / +92 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2010 EclipseSource and others. All rights reserved. This	2	* Copyright (c) 2008, 2010 EclipseSource and others. All rights reserved. This
3	* program and the accompanying materials are made available under the terms of	3	* program and the accompanying materials are made available under the terms of
4	* the Eclipse Public License v1.0 which accompanies this distribution, and is	4	* the Eclipse Public License v1.0 which accompanies this distribution, and is
Lines 6-96 Link Here
6	*	6	*
7	* Contributors:	7	* Contributors:
8	* EclipseSource - initial API and implementation	8	* EclipseSource - initial API and implementation
9	*******************************************************************************/	9	*******************************************************************************/
10	package org.eclipse.rap.internal.design.example.managers;	10	package org.eclipse.rap.internal.design.example.managers;
11		11
12	import java.util.ArrayList;	12	import java.util.ArrayList;
13	import java.util.Iterator;	13	import java.util.Iterator;
14	import java.util.List;
15
16	import org.eclipse.jface.action.IContributionItem;	14	import org.eclipse.jface.action.IContributionItem;
17	import org.eclipse.jface.internal.provisional.action.ToolBarManager2;	15	import org.eclipse.jface.internal.provisional.action.ToolBarManager2;
18	import org.eclipse.rwt.lifecycle.WidgetUtil;	16	import org.eclipse.rwt.lifecycle.WidgetUtil;
19	import org.eclipse.swt.SWT;	17	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.widgets.Composite;	18	import org.eclipse.swt.widgets.Composite;
21	import org.eclipse.swt.widgets.Control;	19	import org.eclipse.swt.widgets.Control;
22	import org.eclipse.swt.widgets.Menu;
23	import org.eclipse.swt.widgets.ToolBar;	20	import org.eclipse.swt.widgets.ToolBar;
24	import org.eclipse.swt.widgets.ToolItem;	21	import org.eclipse.swt.widgets.ToolItem;
25		22
26		23
27	public class ViewToolBarManager extends ToolBarManager2 {	24	public class ViewToolBarManager extends ToolBarManager2 {
28
29	private static final String STYLING_VARIANT = "viewToolbar"; //$NON-NLS-1$
30	private ToolBar toolBar;
31	private ToolBar fakeToolbar;
32		25
		26	private static final String STYLING_VARIANT = "viewToolbar"; //$NON-NLS-1$
		27	private ToolBar fakeToolBar;
33		28
34	public ToolBar createControl(Composite parent) {	29	public ToolBar createControl( final Composite parent ) {
35	if( !toolBarExist() && parent != null ) {	30	fakeToolBar = new ToolBar( parent, SWT.NONE );
36	toolBar = new ToolBar( parent, SWT.NONE );	31	fakeToolBar.setVisible( false );
37	toolBar.setData( WidgetUtil.CUSTOM_VARIANT, STYLING_VARIANT );	32	ToolBar toolBar = super.createControl( parent );
38	toolBar.setMenu( getContextMenuControl() );	33	toolBar.setData( WidgetUtil.CUSTOM_VARIANT, STYLING_VARIANT );
39	// create the fake Toolbar
40	fakeToolbar = new ToolBar( parent, SWT.NONE );
41	fakeToolbar.setVisible( false );
42	update( true );
43	}
44	return toolBar;
45	}
46
47	public ToolBar getControl() {
48	return toolBar;	34	return toolBar;
49	}	35	}
50		36
51	private Menu getContextMenuControl() {
52	Menu result = null;
53	if( ( getContextMenuManager() != null ) && ( toolBar != null ) ) {
54	Menu menuWidget = getContextMenuManager().getMenu();
55	if( ( menuWidget == null ) \|\| ( menuWidget.isDisposed() ) ) {
56	menuWidget = getContextMenuManager().createContextMenu( toolBar);
57	}
58	result = menuWidget;
59	}
60	return result;
61	}
62
63	private boolean toolBarExist() {
64	return toolBar != null && !toolBar.isDisposed();
65	}
66
67	/*
68	* (non-Javadoc) Method declared on IContributionManager.
69	*/
70	public void update( boolean force ) {	37	public void update( boolean force ) {
71	if( isDirty() \|\| force ) {	38	if( isDirty() \|\| force ) {
72	if( toolBarExist() ) {	39	if( toolBarExist() ) {
73		40	ToolBar toolBar = getControl();
74	// clean contains all active items without separators	41	// clean contains all active items without double separators
75	IContributionItem[] items = getItems();	42	IContributionItem[] items = getItems();
76	ArrayList clean = new ArrayList( items.length );	43	ArrayList clean = new ArrayList(items.length);
		44	IContributionItem separator = null;
77	for( int i = 0; i < items.length; ++i ) {	45	for( int i = 0; i < items.length; ++i ) {
78	IContributionItem ci = items[ i ];	46	IContributionItem ci = items[ i ];
79	if( !ci.isSeparator() ) {	47	if( ci.isSeparator() ) {
		48	separator = ci;
		49	} else {
		50	if( separator != null ) {
		51	if( clean.size() > 0 ) {
		52	clean.add( separator );
		53	}
		54	separator = null;
		55	}
80	clean.add( ci );	56	clean.add( ci );
81	}	57	}
82	}	58	}
83	// determine obsolete items (removed or non active)	59	// determine obsolete items (removed or non active)
84	ToolItem[] mi = toolBar.getItems();	60	ToolItem[] mi = toolBar.getItems();
85	ArrayList toRemove = new ArrayList();	61	ArrayList toRemove = new ArrayList( mi.length );
86	for( int i = 0; i < mi.length; i++ ) {	62	for( int i = 0; i < mi.length; i++ ) {
87	toRemove.add( mi[ i ] );	63	// there may be null items in a toolbar
88	}	64	if( mi[ i ] == null ) {
89	// add fake toolbar items to the items to remove	65	continue;
90	for( int i = 0; i < fakeToolbar.getItemCount(); i++ ) {	66	}
91	toRemove.add( fakeToolbar.getItem( i ) );	67	Object data = mi[ i ].getData();
		68	if( data == null
		69	\|\| !clean.contains( data )
		70	\|\| ( data instanceof IContributionItem && ( ( IContributionItem ) data)
		71	.isDynamic() ) ) {
		72	toRemove.add( mi[ i ] );
		73	}
92	}	74	}
93
94	// Turn redraw off if the number of items to be added	75	// Turn redraw off if the number of items to be added
95	// is above a certain threshold, to minimize flicker,	76	// is above a certain threshold, to minimize flicker,
96	// otherwise the toolbar can be seen to redraw after each item.	77	// otherwise the toolbar can be seen to redraw after each item.
Lines 102-111 Link Here
102	if( useRedraw ) {	83	if( useRedraw ) {
103	toolBar.setRedraw( false );	84	toolBar.setRedraw( false );
104	}	85	}
105
106	// remove obsolete items	86	// remove obsolete items
107	for( int i = toRemove.size(); --i >= 0; ) {	87	for (int i = toRemove.size(); --i >= 0;) {
108	ToolItem item = ( ToolItem ) toRemove.get(i);	88	ToolItem item = ( ToolItem )toRemove.get( i );
109	if( !item.isDisposed() ) {	89	if( !item.isDisposed() ) {
110	Control ctrl = item.getControl();	90	Control ctrl = item.getControl();
111	if( ctrl != null ) {	91	if( ctrl != null ) {
Lines 115-169 Link Here
115	item.dispose();	95	item.dispose();
116	}	96	}
117	}	97	}
118
119	// add new items	98	// add new items
120	IContributionItem src, dest;	99	IContributionItem src, dest;
121	mi = toolBar.getItems();	100	mi = toolBar.getItems();
122	int srcIx = 0;	101	int srcIx = 0;
123	int destIx = 0;	102	int destIx = 0;
124
125	for( Iterator e = clean.iterator(); e.hasNext(); ) {	103	for( Iterator e = clean.iterator(); e.hasNext(); ) {
126	src = ( IContributionItem )e.next();	104	src = ( IContributionItem )e.next();
127
128	// get corresponding item in SWT widget	105	// get corresponding item in SWT widget
129	if( srcIx < mi.length ) {	106	if( srcIx < mi.length ) {
130	dest = ( IContributionItem ) mi[ srcIx ].getData();	107	dest = ( IContributionItem )mi[ srcIx ].getData();
131	} else {	108	} else {
132	dest = null;	109	dest = null;
133	}	110	}
134
135	if( dest != null && src.equals( dest ) ) {	111	if( dest != null && src.equals( dest ) ) {
136	srcIx++;	112	srcIx++;
137	destIx++;	113	destIx++;
138	continue;	114	continue;
139	}	115	}
140		116	if( dest != null && dest.isSeparator() && src.isSeparator() ) {
141	if( dest != null && dest.isSeparator()
142	&& src.isSeparator() )
143	{
144	mi[ srcIx ].setData( src );	117	mi[ srcIx ].setData( src );
145	srcIx++;	118	srcIx++;
146	destIx++;	119	destIx++;
147	continue;	120	continue;
148	}	121	}
149		122	int start = toolBar.getItemCount();
150	// fill item if visible, if not fill it into the fake toolbar	123	src.fill( toolBar, destIx );
151	ToolBar tempToolBar = null;	124	int newItems = toolBar.getItemCount() - start;
152	if( src.isVisible() ) {	125	for( int i = 0; i < newItems; i++ ) {
153	src.fill( toolBar, destIx );	126	ToolItem item = toolBar.getItem( destIx++ );
154	tempToolBar = toolBar;	127	item.setData( src );
155	} else {
156	src.fill( fakeToolbar, destIx );
157	tempToolBar = fakeToolbar;
158	}
159	// check necessary for bug 306741
160	if( destIx >= 0 && destIx < tempToolBar.getItemCount() - 1 ) {
161	ToolItem toolItem = tempToolBar.getItem( destIx );
162	toolItem.setData( src );
163	toolItem.setData( WidgetUtil.CUSTOM_VARIANT, STYLING_VARIANT );
164	}	128	}
165	}	129	}
166
167	// remove any old tool items not accounted for	130	// remove any old tool items not accounted for
168	for( int i = mi.length; --i >= srcIx; ) {	131	for( int i = mi.length; --i >= srcIx; ) {
169	ToolItem item = mi[ i ];	132	ToolItem item = mi[ i ];
Lines 176-183 Link Here
176	item.dispose();	139	item.dispose();
177	}	140	}
178	}	141	}
179		142	setDirty(false);
180	setDirty( false );	143	updateFakeToolBar();
		144	disposeInvisibleItems();
181	} finally {	145	} finally {
182	// turn redraw back on if we turned it off above	146	// turn redraw back on if we turned it off above
183	if( useRedraw ) {	147	if( useRedraw ) {
Lines 187-202 Link Here
187	}	151	}
188	}	152	}
189	}	153	}
190		154
191	public List getToolItems() {	155	public ToolItem[] getToolItems() {
192	List result = new ArrayList();	156	return fakeToolBar.getItems();
193	for( int i = 0; i < toolBar.getItemCount(); i++ ) {	157	}
194	result.add( toolBar.getItem( i ) );	158
		159	private boolean toolBarExist() {
		160	ToolBar toolBar = getControl();
		161	return toolBar != null && !toolBar.isDisposed();
		162	}
		163
		164	private void updateFakeToolBar() {
		165	ToolBar toolBar = getControl();
		166	ToolItem[] items = fakeToolBar.getItems();
		167	for( int i = 0; i < items.length; i++ ) {
		168	items[ i ].dispose();
195	}	169	}
196	for( int i = 0; i < fakeToolbar.getItemCount(); i++ ) {	170	items = toolBar.getItems();
197	result.add( fakeToolbar.getItem( i ) );	171	for( int i = 0; i < items.length; i++ ) {
		172	ToolItem item = new ToolItem( fakeToolBar, items[ i ].getStyle() );
		173	item.setText( items[ i ].getText() );
		174	item.setToolTipText( items[ i ].getToolTipText() );
		175	item.setImage( items[ i ].getImage() );
		176	item.setData( items[ i ].getData() );
198	}	177	}
199	return result;
200	}	178	}
201		179
		180	private void disposeInvisibleItems() {
		181	ToolBar toolBar = getControl();
		182	ToolItem[] items = toolBar.getItems();
		183	for( int i = 0; i < items.length; i++ ) {
		184	ToolItem item = items[ i ];
		185	if( !item.isDisposed() ) {
		186	Object data = item.getData();
		187	if( data instanceof IContributionItem ) {
		188	IContributionItem itemData = ( IContributionItem )data;
		189	if( !itemData.isVisible() ) {
		190	Control ctrl = item.getControl();
		191	if( ctrl != null ) {
		192	item.setControl( null );
		193	ctrl.dispose();
		194	}
		195	item.dispose();
		196	}
		197	}
		198	}
		199	}
		200	}
202	}	201	}