org.eclipse.swt.widgets.Layout#org.eclipse.swt.events.ControlEvent源码实例Demo

/**
 * Create the composite.
 * @param parent
 * @param style
 */
public DetailsTabView() {
	super(SWT.NONE);
	setBackground(SWTResourceManager.getColor(SWT.COLOR_WHITE));
	FillLayout fillLayout = new FillLayout(SWT.HORIZONTAL);
	fillLayout.marginWidth = 5;
	fillLayout.marginHeight = 5;
	setLayout(fillLayout);
	
	scrolledComposite = new ScrolledComposite(this, SWT.BORDER | SWT.V_SCROLL);
	scrolledComposite.addControlListener(new ControlAdapter() {
		@Override
		public void controlResized(ControlEvent e) {
			ScrolledComposites.updateOnlyVerticalScrollableComposite(scrolledComposite);
		}
	});
	scrolledComposite.setAlwaysShowScrollBars(true);
	scrolledComposite.setExpandHorizontal(true);
	scrolledComposite.setExpandVertical(true);
}
 

/**
 * Creates a new <code>TableLayoutComposite</code>.
 * 
 * @param parent
 *            the parent composite
 * @param style
 *            the SWT style
 */
public TableLayoutComposite(Composite parent, int style) {
	super(parent, style);
	addControlListener(new ControlAdapter() {
		@Override
		public void controlResized(ControlEvent e) {
			Rectangle area = getClientArea();
			Table table = (Table) getChildren()[0];
			Point preferredSize = computeTableSize(table);
			int width = area.width - 2 * table.getBorderWidth();
			if (preferredSize.y > area.height) {
				// Subtract the scrollbar width from the total column
				// width
				// if a vertical scrollbar will be required
				Point vBarSize = table.getVerticalBar().getSize();
				width -= vBarSize.x;
			}
			layoutTable(table, width, area,
					table.getSize().x < area.width);
		}
	});
}
 

/**
 * Do layout. Several magic #s in here...
 * 
 * @param scrolledComposite
 */
private void setupScrolledComposite() {
  setAlwaysShowScrollBars(true);

  scrolledCanvas = new Composite(this, SWT.NONE);
  GridLayoutFactory.fillDefaults().spacing(0, 0).applyTo(scrolledCanvas);

  setMinWidth(100);
  setMinHeight(100);
  setExpandHorizontal(true);
  setExpandVertical(true);
  setMinHeight(1);

  Point size = scrolledCanvas.computeSize(getParent().getSize().x,
      SWT.DEFAULT, true);
  scrolledCanvas.setSize(size);

  addControlListener(new ControlAdapter() {
    @Override
    public void controlResized(ControlEvent e) {
      doUpdateContentSize();
      updateScrollIncrements();
    }
  });
  setContent(scrolledCanvas);
}
 

/**
 * @param tb
 */
public void install(final GamaToolbar2 tb) {

	// We add a control listener to the toolbar in order to install the
	// gesture once the control to resize have been created.
	tb.addControlListener(new ControlAdapter() {

		@Override
		public void controlResized(final ControlEvent e) {
			final Control c = view.getSizableFontControl();
			if (c != null) {
				c.addGestureListener(gl);
				// once installed the listener removes itself from the
				// toolbar
				tb.removeControlListener(this);
			}
		}

	});
	tb.button("console.increase2", "Increase font size", "Increase font size", e -> changeFontSize(2), SWT.RIGHT);
	tb.button("console.decrease2", "Decrease font size", "Decrease font size", e -> changeFontSize(-2), SWT.RIGHT);

	tb.sep(16, SWT.RIGHT);

}
 

/**
 * Creates a new <code>TableLayoutComposite</code>.
 *
 * @param parent the parent composite
 * @param style the SWT style
 */
public TableLayoutComposite(Composite parent, int style) {
	super(parent, style);
       addControlListener(new ControlAdapter() {
           @Override
		public void controlResized(ControlEvent e) {
               Rectangle area= getClientArea();
               Table table= (Table)getChildren()[0];
               Point preferredSize= computeTableSize(table);
               int width= area.width - 2 * table.getBorderWidth();
               if (preferredSize.y > area.height) {
                   // Subtract the scrollbar width from the total column width
                   // if a vertical scrollbar will be required
                   Point vBarSize = table.getVerticalBar().getSize();
                   width -= vBarSize.x;
               }
               layoutTable(table, width, area, table.getSize().x < area.width);
           }
       });
}
 

public void controlResized( ControlEvent arg0 )
{
	updateScrollBar( );
	if ( imgBuffer != null )
	{
		gc.dispose( );
		imgBuffer.dispose( );
		gc = null;
		imgBuffer = null;
	}

	if ( coEditor != null )
	{
		final Rectangle rCA = coPaletteEntries.getClientArea( );
		coEditor.setSize( rCA.width - 6, ITEM_HEIGHT - 6 );
	}
}
 

public void controlResized(ControlEvent e) {
          Point size = hScroller.getSize();

	int preferredWidth = controlHolder.computeSize(SWT.DEFAULT, 
                  SWT.DEFAULT, true).x;

	if (preferredWidth > size.x && !isHSliderVisible()) {
		setHSliderVisible(true);
	}
	if (preferredWidth <= size.x && isHSliderVisible()) {
		setHSliderVisible(false);
	}

	if (preferredWidth <= size.x) {
		controlHolder.setBounds(0, 0, size.x, size.y);
		return;
	}

	if (isHSliderVisible()) {
		hSlider.setMaximum(preferredWidth);
		hSlider.setPageIncrement(size.x);
		hSlider.setThumb(preferredWidth - (preferredWidth - size.x));
		int currentSelection = hSlider.getSelection();
		if (preferredWidth - currentSelection < size.x) {
			hSlider.setSelection(preferredWidth - size.x);
		}
	}
	hSlider.notifyListeners(SWT.Selection, new Event());
}
 

public void controlMoved(ControlEvent e) {
    // Eat the move event that is fired after resize events
    if (wasResized) {
        wasResized = false;
        return;
    }
    Table table = header.headerTable;
    fireColumnMovedEvent(table.getColumnOrder());
    storeLastWidths(table);
}
 

public void controlResized(ControlEvent e) {
    if (lastWidths == null) return;
    wasResized = true;
    if (!layingOut) {
        layingOut = true;
        try {
            TableColumn tableColumn = (TableColumn) e.widget;
            AbstractNativeHeader header = asHeader(tableColumn.getParent().getParent());
            adjustWeights(header, tableColumn);
            storeLastWidths(tableColumn.getParent());
        } finally {
            layingOut = false;
        }
    }
}
 

public void buildUI( Composite parent )
{
	container = new ScrolledComposite( parent, SWT.V_SCROLL | SWT.H_SCROLL );
	container.setLayoutData( new GridData( GridData.FILL_BOTH ) );
	( (ScrolledComposite) container ).setExpandHorizontal( true );
	( (ScrolledComposite) container ).setExpandVertical( true );
	container.addControlListener( new ControlAdapter( ) {

		public void controlResized( ControlEvent e )
		{
			computeSize( );
		}
	} );

	composite = new Composite( container, SWT.NONE );
	composite.setLayoutData( new GridData( GridData.FILL_BOTH ) );

	if ( sections == null )
		sections = new SortMap( );
	composite.setLayout( WidgetUtil.createGridLayout( 1 ) );

	previewSection = new PreviewSection( provider.getDisplayName( ),
			composite,
			true,
			isTabbed );
	previewSection.setPreview( preview );
	previewSection.setProvider( provider );
	previewSection.setHeight( 160 );
	previewSection.setFillPreview( true );
	addSection( PageSectionId.PREVIEW_PREVIEW, previewSection );

	createSections( );
	layoutSections( );

	( (ScrolledComposite) container ).setContent( composite );
}
 

@Override
public void controlResized(ControlEvent e) {
  // update the internal bounds
  Shell shell = (Shell) e.getSource();
  mMaximized = shell.getMaximized();
  mMinimized = shell.getMinimized();

  // only store new bounds if the shell is not minimized or maximized.
  // This way the original size (before minimizing/maximizing will be
  // remembered.
  if (!mMinimized && !mMaximized) {
    mNewBounds = shell.getBounds();
  }
}
 

protected FigureCanvas createCanvas ()
{
    final FigureCanvas canvas = new FigureCanvas ( this, SWT.H_SCROLL | SWT.V_SCROLL | SWT.NO_REDRAW_RESIZE );

    addControlListener ( new ControlAdapter () {
        @Override
        public void controlResized ( final ControlEvent e )
        {
            handleResize ( getBounds () );
        }
    } );

    return canvas;
}
 

private ContainerCheckedTreeViewer createTree(Composite parent, int style) {
    final ContainerCheckedTreeViewer viewer = new ContainerCheckedTreeViewer(parent, style | SWT.SINGLE | SWT.BORDER
            | SWT.V_SCROLL | SWT.H_SCROLL | SWT.RESIZE) {
        /**
         * Overriden to re-set checked state of elements after filter change
         */
        @Override
        public void refresh(boolean updateLabels) {
            super.refresh(updateLabels);
            setCheckedElements(checkedElements);
        }
    };

    viewer.setContentProvider(contentProvider);
    viewer.setLabelProvider(labelProvider);
    viewer.setInput(allowedTypes);
    Object[] preselected = getPreselected();
    viewer.setCheckedElements(preselected);
    viewer.addPostSelectionChangedListener(new TreeSelectionChangedListener());
    viewer.getTree().addControlListener(new ControlAdapter() {
        @Override
        public void controlResized(ControlEvent e) {
            updateDescription((IStructuredSelection) viewer.getSelection());
        }
    });
    viewer.addCheckStateListener(new TreeCheckStateListener());
    return viewer;
}
 

@Override
public void controlResized(final ControlEvent e) {
          inControlResized = true;

          final int treeWidth = computeMaximumWidthOfAllColumns();
          final int firstColWidth = Math.round(Math.round(firstColumnPercentageWidth * treeWidth));
          final int secondColWidth = treeWidth - firstColWidth;
          columns[0].setWidth(firstColWidth);
          columns[1].setWidth(secondColWidth);
          
          inControlResized = false;
      }
 

/**
 * Maximize a workbench part and wait for one of its controls to be resized.
 * Calling this a second time will "un-maximize" the part.
 *
 * @param partReference
 *            the {@link IWorkbenchPartReference} which contains the control
 * @param controlBot
 *            a control that should be resized
 */
public static void maximize(IWorkbenchPartReference partReference, AbstractSWTBotControl<?> controlBot) {
    final AtomicBoolean controlResized = new AtomicBoolean();
    Control control = controlBot.widget;
    assertNotNull(control);
    UIThreadRunnable.syncExec(new VoidResult() {
        @Override
        public void run() {
            control.addControlListener(new ControlAdapter() {
                @Override
                public void controlResized(ControlEvent e) {
                    control.removeControlListener(this);
                    controlResized.set(true);
                }
            });
        }
    });
    IWorkbenchPart part = partReference.getPart(false);
    assertNotNull(part);
    maximize(part);
    new SWTBot().waitUntil(new DefaultCondition() {
        @Override
        public boolean test() throws Exception {
            return controlResized.get();
        }

        @Override
        public String getFailureMessage() {
            return "Control was not resized";
        }
    });
}
 

@Override
public void controlResized(@Nullable ControlEvent e) {
    /* Refresh titles */
    refreshDisplayTitles();

    /* Refresh the Axis labels to fit the current chart size */
    refreshDisplayLabels();

    /* Relocate the close button */
    fCloseButton.setLocation(fChart.getSize().x - fCloseButton.getSize().x - CLOSE_BUTTON_MARGIN, CLOSE_BUTTON_MARGIN);
}
 

@Override
public void controlResized(ControlEvent event) {
    int areaHeight = fScrolledComposite.getSize().y;
    if (fScrolledComposite.getHorizontalBar() != null) {
        areaHeight -= fScrolledComposite.getHorizontalBar().getSize().y;
    }
    int lineHeight = fStyledText.getLineHeight();
    fNumVisibleLines = Math.max((areaHeight + lineHeight - 1) / lineHeight, 1);

    if (fBottomContext != null) {
        loadLineData();
        fillTextArea();
    }
}
 

@Override
public void controlMoved(ControlEvent e) {
    int[] order = fTable.getColumnOrder();
    if (order[0] != MARGIN_COLUMN_INDEX) {
        for (int i = order.length - 1; i > 0; i--) {
            if (order[i] == MARGIN_COLUMN_INDEX) {
                order[i] = order[i - 1];
                order[i - 1] = MARGIN_COLUMN_INDEX;
            }
        }
        fTable.setColumnOrder(order);
    }
    fColumnOrder = order;
    fTable.layout();
}
 

@Override
public void controlResized(ControlEvent e) {
    TableColumn column = (TableColumn) e.widget;
    if (fPacking) {
        /* Don't update column width if resize due to packing */
        return;
    }
    if (column.getResizable() && !isExpanded(column)) {
        int index = (int) column.getData(Key.INDEX);
        fColumnSize[index] = column.getWidth();
        /* Turns off AutoFit */
        column.setData(Key.WIDTH, fColumnSize[index]);
    }
}
 

public Control createPageControl( Composite parent )
{
	sComposite = new ScrolledComposite( parent, SWT.H_SCROLL
			| SWT.V_SCROLL );
	sComposite.setLayoutData( new GridData( GridData.FILL_BOTH ) );
	sComposite.setExpandHorizontal( true );
	sComposite.setExpandVertical( true );
	sComposite.addControlListener( new ControlAdapter( ) {

		public void controlResized( ControlEvent e )
		{
			computeSize( );
		}
	} );
	
	composite = new Composite( sComposite, SWT.NONE );
	GridLayout layout = new GridLayout( );
	layout.marginWidth = 0;
	layout.marginHeight = 0;
	composite.setLayout( layout );
	if ( getPageDescription( ) != null )
	{
		pageDescription = new Label( composite, SWT.NONE );
		pageDescription.setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );
		pageDescription.setText( getPageDescription( ) );
		pageDescription.setToolTipText( getPageDescription( ) );
	}
	GridData data = new GridData( GridData.FILL_BOTH );
	Control control = createContents( composite );
	control.setLayoutData( data );

	sComposite.setContent( composite );

	return sComposite;
}
 

private void createScrolledArea() {
	fScrolledPageContent= new ScrolledPageContent(fParentComposite);
	fScrolledPageContent.addControlListener(new ControlAdapter() {
		@Override
		public void controlResized(ControlEvent e) {
			fScrolledPageContent.getVerticalBar().setVisible(true);
		}
	});
}
 

@Override
public void controlResized(ControlEvent event) {
    if (event.widget == _tableViewer.getTable()) {
        Table table = (Table) event.widget;
        table.getColumn(2).setWidth(table.getClientArea().width - table.getColumn(0).getWidth() - table.getColumn(1).getWidth());
    }
}
 

public void controlResized( ControlEvent e )
{
	if ( preview != null && !preview.isDisposed( ) )
	{
		updateBuffer( );
		preview.redraw( );
	}
}
 

public void controlResized(ControlEvent e)
{
    if (imgBuffer != null)
    {
        gcBuffer.dispose();
        imgBuffer.dispose();
        gcBuffer = null;
        imgBuffer = null;
    }
}
 

public static void main(String[] args) {
	Display display = new Display();
	Shell shell = new Shell(display);
	shell.setLayout(new FillLayout());

	fGrid = new Grid(shell, SWT.BORDER | SWT.V_SCROLL);

	fGrid.setTreeLinesVisible(false);
	fGrid.setWordWrapHeader(true);
	fGrid.setHeaderVisible(true);
	GridColumn column = new GridColumn(fGrid, SWT.NONE);
	column.setWordWrap(true);
	column.setText("Column 1");
	column.setWidth(100);
	GridColumn column2 = new GridColumn(fGrid, SWT.NONE);
	column2.setText("Column 2");
	column2.setWidth(100);

	GridItem item1 = new GridItem(fGrid, SWT.NONE);
	item1.setText("First Item. First Item. First Item.");
	item1.setText(1, "xxxxxxx");

	System.out.println("item2");
	final GridItem item2 = new GridItem(fGrid, SWT.NONE);
	item2.setText("This cell contains a lot of text. This cell contains a lot of text");
	item2.setText(1, "xxxxxxx");
	column.addControlListener(new ControlAdapter() {
		@Override
		public void controlResized(ControlEvent e) {
			calculateHeight();
		}
	});

	GridItem item3 = new GridItem(fGrid, SWT.NONE);
	item3.setText("Third Item. Third Item. Third Item. Third Item. Third Item. ");
	item3.setText(1, "xxxxxxx");

	calculateHeight();

	shell.setSize(200, 200);
	shell.open();
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	display.dispose();
}
 

protected Control createDialogArea( Composite parent )
{
	Composite composite = (Composite) super.createDialogArea( parent );

	createSelectionArea( composite );
	new Label( composite, SWT.SEPARATOR | SWT.HORIZONTAL ).setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );

	scrollContent = new ScrolledComposite( composite, SWT.H_SCROLL
			| SWT.V_SCROLL );
	scrollContent.setLayoutData( new GridData( GridData.FILL_BOTH ) );
	scrollContent.setExpandHorizontal( true );
	scrollContent.setExpandVertical( true );

	scrollContent.addControlListener( new ControlAdapter( ) {

		public void controlResized( ControlEvent e )
		{
			computeSize( );
		}
	} );

	Shell shell = PlatformUI.getWorkbench( )
			.getActiveWorkbenchWindow( )
			.getShell( );

	int height = shell.getBounds( ).height < 510 + 200 ? shell.getBounds( ).height - 200
			: 510;
	if ( !bTargetEnabled )
	{
		height -= 70;
	}
	if ( !bTooltipEnabled )
	{
		height -= 50;
	}

	GridData gd = new GridData( GridData.FILL_BOTH );
	gd.minimumWidth = 600;
	gd.minimumHeight = height;
	scrollContent.setLayoutData( gd );

	displayArea = new Composite( scrollContent, SWT.NONE );
	displayArea.setLayout( new GridLayout( 3, false ) );
	displayArea.setLayoutData( new GridData( GridData.FILL_BOTH ) );

	scrollContent.setContent( displayArea );

	new Label( composite, SWT.SEPARATOR | SWT.HORIZONTAL ).setLayoutData( new GridData( GridData.FILL_HORIZONTAL ) );

	UIUtil.bindHelp( parent, IHelpContextIds.HYPERLINK_BUILDER_ID );

	return composite;
}
 

public void controlResized(ControlEvent e) {
	resize();
}
 

public void controlResized(ControlEvent e) {
    Point size = AbstractNativeHeader.this.getSize();
    headerTable.setBounds(0, 0, size.x, size.y);
}
 

public void controlResized(ControlEvent e) {
    for (Iterator i = columnControlListeners.iterator(); i.hasNext();) {
        ControlListener listener = (ControlListener) i.next();
        listener.controlResized(e);
    }
}
 

public void controlMoved(ControlEvent e) {
    for (Iterator i = columnControlListeners.iterator(); i.hasNext();) {
        ControlListener listener = (ControlListener) i.next();
        listener.controlMoved(e);
    }
}