| /******************************************************************************* |
| * Copyright (c) 2000, 2006 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 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.presentations.r21.widgets; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.SWTException; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.PaintEvent; |
| import org.eclipse.swt.events.PaintListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Layout; |
| import org.eclipse.swt.widgets.Listener; |
| |
| /** |
| * Instances of this class implement a Composite that lays out three |
| * children horizontally and allows programmatic control of layout and |
| * border parameters. ViewForm is used in the workbench to implement a |
| * view's label/menu/toolbar local bar. |
| * <p> |
| * Note that although this class is a subclass of <code>Composite</code>, |
| * it does not make sense to set a layout on it. |
| * </p><p> |
| * <dl> |
| * <dt><b>Styles:</b></dt> |
| * <dd>BORDER, FLAT</dd> |
| * <dt><b>Events:</b></dt> |
| * <dd>(None)</dd> |
| * </dl> |
| * <p> |
| * IMPORTANT: This class is <em>not</em> intended to be subclassed. |
| * </p> |
| */ |
| |
| public class ViewForm extends Composite { |
| |
| /** |
| * marginWidth specifies the number of pixels of horizontal margin |
| * that will be placed along the left and right edges of the form. |
| * |
| * The default value is 0. |
| */ |
| public int marginWidth = 0; |
| |
| /** |
| * marginHeight specifies the number of pixels of vertical margin |
| * that will be placed along the top and bottom edges of the form. |
| * |
| * The default value is 0. |
| */ |
| public int marginHeight = 0; |
| |
| /** |
| * Color of innermost line of drop shadow border. |
| */ |
| public static RGB borderInsideRGB = new RGB(132, 130, 132); |
| |
| /** |
| * Color of middle line of drop shadow border. |
| */ |
| public static RGB borderMiddleRGB = new RGB(143, 141, 138); |
| |
| /** |
| * Color of outermost line of drop shadow border. |
| */ |
| public static RGB borderOutsideRGB = new RGB(171, 168, 165); |
| |
| // SWT widgets |
| private Control topLeft; |
| |
| private Control topCenter; |
| |
| private Control topRight; |
| |
| private Control content; |
| |
| // Configuration and state info |
| private boolean separateTopCenter = false; |
| |
| private int drawLine1 = -1; |
| |
| private int drawLine2 = -1; |
| |
| private boolean showBorder = false; |
| |
| private int BORDER_TOP = 0; |
| |
| private int BORDER_BOTTOM = 0; |
| |
| private int BORDER_LEFT = 0; |
| |
| private int BORDER_RIGHT = 0; |
| |
| private Color borderColor1; |
| |
| private Color borderColor2; |
| |
| private Color borderColor3; |
| |
| private Rectangle oldArea; |
| |
| private static final int OFFSCREEN = -200; |
| |
| /** |
| * Constructs a new instance of this class given its parent |
| * and a style value describing its behavior and appearance. |
| * <p> |
| * The style value is either one of the style constants defined in |
| * class <code>SWT</code> which is applicable to instances of this |
| * class, or must be built by <em>bitwise OR</em>'ing together |
| * (that is, using the <code>int</code> "|" operator) two or more |
| * of those <code>SWT</code> style constants. The class description |
| * lists the style constants that are applicable to the class. |
| * Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parent a widget which will be the parent of the new instance (cannot be null) |
| * @param style the style of widget to construct |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> |
| * </ul> |
| * |
| * @see SWT#BORDER |
| * @see SWT#FLAT |
| * @see #getStyle() |
| */ |
| public ViewForm(Composite parent, int style) { |
| super(parent, checkStyle(style)); |
| |
| borderColor1 = new Color(getDisplay(), borderInsideRGB); |
| borderColor2 = new Color(getDisplay(), borderMiddleRGB); |
| borderColor3 = new Color(getDisplay(), borderOutsideRGB); |
| setBorderVisible((style & SWT.BORDER) != 0); |
| |
| addPaintListener(new PaintListener() { |
| public void paintControl(PaintEvent event) { |
| onPaint(event.gc); |
| } |
| }); |
| addControlListener(new ControlAdapter() { |
| public void controlResized(ControlEvent e) { |
| onResize(); |
| } |
| }); |
| |
| addListener(SWT.Dispose, new Listener() { |
| public void handleEvent(Event e) { |
| onDispose(); |
| } |
| }); |
| } |
| |
| /** |
| * Check the style bits to ensure that no invalid styles are applied. |
| * @private |
| */ |
| private static int checkStyle(int style) { |
| int mask = SWT.FLAT | SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT; |
| return style & mask | SWT.NO_REDRAW_RESIZE; |
| } |
| |
| public Point computeSize(int wHint, int hHint, boolean changed) { |
| checkWidget(); |
| // size of title bar area |
| Point leftSize = new Point(0, 0); |
| if (topLeft != null) { |
| leftSize = topLeft.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| leftSize.x += 1; // +1 for highlight line |
| } |
| Point centerSize = new Point(0, 0); |
| if (topCenter != null) { |
| centerSize = topCenter.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| Point rightSize = new Point(0, 0); |
| if (topRight != null) { |
| rightSize = topRight.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| Point size = new Point(0, 0); |
| // calculate width of title bar |
| if (separateTopCenter |
| || (wHint != SWT.DEFAULT && leftSize.x + centerSize.x |
| + rightSize.x > wHint)) { |
| size.x = leftSize.x + rightSize.x; |
| size.x = Math.max(centerSize.x, size.x); |
| size.y = Math.max(leftSize.y, rightSize.y) + 1; // +1 for highlight line |
| if (topCenter != null) { |
| size.y += centerSize.y; |
| } |
| } else { |
| size.x = leftSize.x + centerSize.x + rightSize.x; |
| size.y = Math.max(leftSize.y, Math.max(centerSize.y, rightSize.y)) + 1; // +1 for highlight line |
| } |
| |
| if (content != null) { |
| Point contentSize = new Point(0, 0); |
| contentSize = content.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| size.x = Math.max(size.x, contentSize.x); |
| size.y += contentSize.y + 1; // +1 for line bewteen content and header |
| } |
| |
| size.x += 2 * marginWidth; |
| size.y += 2 * marginHeight; |
| |
| if (wHint != SWT.DEFAULT) { |
| size.x = wHint; |
| } |
| if (hHint != SWT.DEFAULT) { |
| size.y = hHint; |
| } |
| |
| Rectangle trim = computeTrim(0, 0, size.x, size.y); |
| return new Point(trim.width, trim.height); |
| } |
| |
| public Rectangle computeTrim(int x, int y, int width, int height) { |
| checkWidget(); |
| int trimX = x - BORDER_LEFT; |
| int trimY = y - BORDER_TOP; |
| int trimWidth = width + BORDER_LEFT + BORDER_RIGHT; |
| int trimHeight = height + BORDER_TOP + BORDER_BOTTOM; |
| return new Rectangle(trimX, trimY, trimWidth, trimHeight); |
| } |
| |
| public Rectangle getClientArea() { |
| checkWidget(); |
| Rectangle clientArea = super.getClientArea(); |
| clientArea.x += BORDER_LEFT; |
| clientArea.y += BORDER_TOP; |
| clientArea.width -= BORDER_LEFT + BORDER_RIGHT; |
| clientArea.height -= BORDER_TOP + BORDER_BOTTOM; |
| return clientArea; |
| } |
| |
| /** |
| * Returns the content area. |
| * |
| * @return the control in the content area of the pane or null |
| */ |
| public Control getContent() { |
| //checkWidget(); |
| return content; |
| } |
| |
| /** |
| * Returns Control that appears in the top center of the pane. |
| * Typically this is a toolbar. |
| * |
| * @return the control in the top center of the pane or null |
| */ |
| public Control getTopCenter() { |
| //checkWidget(); |
| return topCenter; |
| } |
| |
| /** |
| * Returns the Control that appears in the top left corner of the pane. |
| * Typically this is a label such as CLabel. |
| * |
| * @return the control in the top left corner of the pane or null |
| */ |
| public Control getTopLeft() { |
| //checkWidget(); |
| return topLeft; |
| } |
| |
| /** |
| * Returns the control in the top right corner of the pane. |
| * Typically this is a Close button or a composite with a Menu and Close button. |
| * |
| * @return the control in the top right corner of the pane or null |
| */ |
| public Control getTopRight() { |
| //checkWidget(); |
| return topRight; |
| } |
| |
| public void layout(boolean changed) { |
| checkWidget(); |
| Rectangle rect = getClientArea(); |
| |
| drawLine1 = -1; |
| drawLine2 = -1; |
| |
| Point leftSize = new Point(0, 0); |
| if (topLeft != null && !topLeft.isDisposed()) { |
| leftSize = topLeft.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| Point centerSize = new Point(0, 0); |
| if (topCenter != null && !topCenter.isDisposed()) { |
| centerSize = topCenter.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| Point rightSize = new Point(0, 0); |
| if (topRight != null && !topRight.isDisposed()) { |
| rightSize = topRight.computeSize(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| |
| int minTopWidth = leftSize.x + centerSize.x + rightSize.x + 2 |
| * marginWidth + 1; // +1 for highlight line |
| int height = rect.y + marginHeight; |
| |
| boolean top = false; |
| if (separateTopCenter || minTopWidth > rect.width) { |
| int topHeight = Math.max(rightSize.y, leftSize.y); |
| if (topRight != null && !topRight.isDisposed()) { |
| top = true; |
| topRight.setBounds(rect.x + rect.width - marginWidth |
| - rightSize.x, rect.y + 1 + marginHeight, rightSize.x, |
| topHeight); |
| height += 1 + topHeight; // +1 for highlight line |
| } |
| if (topLeft != null && !topLeft.isDisposed()) { |
| top = true; |
| leftSize = topLeft.computeSize(rect.width - 2 * marginWidth |
| - rightSize.x - 1, SWT.DEFAULT); |
| topLeft.setBounds(rect.x + 1 + marginWidth, rect.y + 1 |
| + marginHeight, leftSize.x, topHeight); |
| height = Math |
| .max(height, rect.y + marginHeight + 1 + topHeight); // +1 for highlight line |
| } |
| if (topCenter != null && !topCenter.isDisposed()) { |
| top = true; |
| if (height > rect.y + marginHeight) { |
| drawLine1 = height; |
| height += 1; // +1 for divider line |
| } |
| centerSize = topCenter.computeSize( |
| rect.width - 2 * marginWidth, SWT.DEFAULT); |
| topCenter.setBounds(rect.x + rect.width - marginWidth |
| - centerSize.x, height, centerSize.x, centerSize.y); |
| height += centerSize.y; |
| |
| } |
| } else { |
| int topHeight = Math.max(rightSize.y, Math.max(centerSize.y, |
| leftSize.y)); |
| if (topRight != null && !topRight.isDisposed()) { |
| top = true; |
| topRight.setBounds(rect.x + rect.width - marginWidth |
| - rightSize.x, rect.y + marginHeight + 1, // +1 for highlight line |
| rightSize.x, topHeight); |
| height += 1 + topHeight; // +1 for highlight line |
| } |
| if (topCenter != null && !topCenter.isDisposed()) { |
| top = true; |
| topCenter.setBounds(rect.x + rect.width - marginWidth |
| - rightSize.x - centerSize.x, |
| rect.y + marginHeight + 1, // +1 for highlight line |
| centerSize.x, topHeight); |
| height = Math |
| .max(height, rect.y + marginHeight + 1 + topHeight); // +1 for highlight line |
| } |
| if (topLeft != null && !topLeft.isDisposed()) { |
| top = true; |
| leftSize = topLeft.computeSize(rect.width - 2 * marginWidth |
| - rightSize.x - centerSize.x - 1, topHeight); |
| topLeft.setBounds(rect.x + marginWidth + 1, // +1 for highlight line |
| rect.y + marginHeight + 1, // +1 for highlight line |
| leftSize.x, topHeight); |
| height = Math |
| .max(height, rect.y + marginHeight + 1 + topHeight); // +1 for highlight line |
| } |
| } |
| |
| if (content != null && !content.isDisposed()) { |
| if (top) { |
| drawLine2 = height; |
| height += 1; // +1 for divider line |
| } |
| content |
| .setBounds(rect.x + marginWidth, height, rect.width - 2 |
| * marginWidth, rect.y + rect.height - height |
| - marginHeight); |
| } |
| } |
| |
| private void onDispose() { |
| if (borderColor1 != null) { |
| borderColor1.dispose(); |
| } |
| borderColor1 = null; |
| |
| if (borderColor2 != null) { |
| borderColor2.dispose(); |
| } |
| borderColor2 = null; |
| |
| if (borderColor3 != null) { |
| borderColor3.dispose(); |
| } |
| borderColor3 = null; |
| |
| topLeft = null; |
| topCenter = null; |
| topRight = null; |
| content = null; |
| oldArea = null; |
| } |
| |
| /** |
| * Draws the focus border. |
| */ |
| private void onPaint(GC gc) { |
| Rectangle d = super.getClientArea(); |
| |
| if (showBorder) { |
| if ((getStyle() & SWT.FLAT) != 0) { |
| gc.setForeground(borderColor1); |
| gc.drawRectangle(d.x, d.y, d.x + d.width - 1, d.y + d.height |
| - 1); |
| } else { |
| gc.setForeground(borderColor1); |
| gc.drawRectangle(d.x, d.y, d.x + d.width - 3, d.y + d.height |
| - 3); |
| |
| gc.setForeground(borderColor2); |
| gc.drawLine(d.x + 1, d.y + d.height - 2, d.x + d.width - 1, d.y |
| + d.height - 2); |
| gc.drawLine(d.x + d.width - 2, d.y + 1, d.x + d.width - 2, d.y |
| + d.height - 1); |
| |
| gc.setForeground(borderColor3); |
| gc.drawLine(d.x + 2, d.y + d.height - 1, d.x + d.width - 2, d.y |
| + d.height - 1); |
| gc.drawLine(d.x + d.width - 1, d.y + 2, d.x + d.width - 1, d.y |
| + d.height - 2); |
| } |
| } |
| |
| if (drawLine1 != -1) { |
| // top seperator line |
| gc.setForeground(borderColor1); |
| gc.drawLine(d.x + BORDER_LEFT, drawLine1, d.x + d.width |
| - BORDER_RIGHT, drawLine1); |
| } |
| if (drawLine2 != -1) { |
| // content separator line |
| gc.setForeground(borderColor1); |
| gc.drawLine(d.x + BORDER_LEFT, drawLine2, d.x + d.width |
| - BORDER_RIGHT, drawLine2); |
| } |
| // highlight on top |
| int y = drawLine1; |
| if (y == -1) { |
| y = drawLine2; |
| } |
| if (y != -1) { |
| gc.setForeground(getDisplay().getSystemColor( |
| SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW)); |
| gc.drawLine(d.x + BORDER_LEFT + marginWidth, d.y + BORDER_TOP |
| + marginHeight, d.x + BORDER_LEFT + marginWidth, y - 1); |
| gc.drawLine(d.x + BORDER_LEFT + marginWidth, d.y + BORDER_TOP |
| + marginHeight, d.x + d.width - BORDER_RIGHT - marginWidth |
| - 1, d.y + BORDER_TOP + marginHeight); |
| } |
| |
| gc.setForeground(getForeground()); |
| } |
| |
| private void onResize() { |
| layout(); |
| |
| Rectangle area = super.getClientArea(); |
| if (oldArea == null || oldArea.width == 0 || oldArea.height == 0) { |
| redraw(); |
| } else { |
| int width = 0; |
| if (oldArea.width < area.width) { |
| width = area.width - oldArea.width + BORDER_RIGHT; |
| } else if (oldArea.width > area.width) { |
| width = BORDER_RIGHT; |
| } |
| redraw(area.x + area.width - width, area.y, width, area.height, |
| false); |
| |
| int height = 0; |
| if (oldArea.height < area.height) { |
| height = area.height - oldArea.height + BORDER_BOTTOM; |
| } |
| if (oldArea.height > area.height) { |
| height = BORDER_BOTTOM; |
| } |
| redraw(area.x, area.y + area.height - height, area.width, height, |
| false); |
| } |
| oldArea = area; |
| } |
| |
| /** |
| * Sets the content. |
| * Setting the content to null will remove it from |
| * the pane - however, the creator of the content must dispose of the content. |
| * |
| * @param content the control to be displayed in the content area or null |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setContent(Control content) { |
| checkWidget(); |
| if (content != null && content.getParent() != this) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| if (this.content != null && !this.content.isDisposed()) { |
| this.content.setBounds(OFFSCREEN, OFFSCREEN, 0, 0); |
| } |
| this.content = content; |
| layout(); |
| } |
| |
| /** |
| * Set the widget font. |
| * This will apply the font to the topLeft, topRight and topCenter widgets. |
| */ |
| public void setFont(Font f) { |
| super.setFont(f); |
| if (topLeft != null && !topLeft.isDisposed()) { |
| topLeft.setFont(f); |
| } |
| if (topCenter != null && !topCenter.isDisposed()) { |
| topCenter.setFont(f); |
| } |
| if (topRight != null && !topRight.isDisposed()) { |
| topRight.setFont(f); |
| } |
| |
| layout(); |
| } |
| |
| /** |
| * Sets the layout which is associated with the receiver to be |
| * the argument which may be null. |
| * <p> |
| * Note : ViewForm does not use a layout class to size and position its children. |
| * </p> |
| * |
| * @param layout the receiver's new layout or null |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setLayout(Layout layout) { |
| checkWidget(); |
| return; |
| } |
| |
| /** |
| * Set the control that appears in the top center of the pane. |
| * Typically this is a toolbar. |
| * The topCenter is optional. Setting the topCenter to null will remove it from |
| * the pane - however, the creator of the topCenter must dispose of the topCenter. |
| * |
| * @param topCenter the control to be displayed in the top center or null |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setTopCenter(Control topCenter) { |
| checkWidget(); |
| if (topCenter != null && topCenter.getParent() != this) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| if (this.topCenter != null && !this.topCenter.isDisposed()) { |
| this.topCenter.setBounds(OFFSCREEN, OFFSCREEN, 0, 0); |
| } |
| this.topCenter = topCenter; |
| layout(); |
| } |
| |
| /** |
| * Set the control that appears in the top left corner of the pane. |
| * Typically this is a label such as CLabel. |
| * The topLeft is optional. Setting the top left control to null will remove it from |
| * the pane - however, the creator of the control must dispose of the control. |
| * |
| * @param c the control to be displayed in the top left corner or null |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setTopLeft(Control c) { |
| checkWidget(); |
| if (c != null && c.getParent() != this) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| if (this.topLeft != null && !this.topLeft.isDisposed()) { |
| this.topLeft.setBounds(OFFSCREEN, OFFSCREEN, 0, 0); |
| } |
| this.topLeft = c; |
| layout(); |
| } |
| |
| /** |
| * Set the control that appears in the top right corner of the pane. |
| * Typically this is a Close button or a composite with a Menu and Close button. |
| * The topRight is optional. Setting the top right control to null will remove it from |
| * the pane - however, the creator of the control must dispose of the control. |
| * |
| * @param c the control to be displayed in the top right corner or null |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * <li>ERROR_INVALID_ARGUMENT - if the control is not a child of this ViewForm</li> |
| * </ul> |
| */ |
| public void setTopRight(Control c) { |
| checkWidget(); |
| if (c != null && c.getParent() != this) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| if (this.topRight != null && !this.topRight.isDisposed()) { |
| this.topRight.setBounds(OFFSCREEN, OFFSCREEN, 0, 0); |
| } |
| this.topRight = c; |
| layout(); |
| } |
| |
| /** |
| * Specify whether the border should be displayed or not. |
| * |
| * @param show true if the border should be displayed |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setBorderVisible(boolean show) { |
| checkWidget(); |
| if (showBorder == show) { |
| return; |
| } |
| |
| showBorder = show; |
| if (showBorder) { |
| if ((getStyle() & SWT.FLAT) != 0) { |
| BORDER_LEFT = BORDER_TOP = BORDER_RIGHT = BORDER_BOTTOM = 1; |
| } else { |
| BORDER_LEFT = BORDER_TOP = 1; |
| BORDER_RIGHT = BORDER_BOTTOM = 3; |
| } |
| } else { |
| BORDER_BOTTOM = BORDER_TOP = BORDER_LEFT = BORDER_RIGHT = 0; |
| } |
| |
| layout(); |
| redraw(); |
| } |
| |
| /** |
| * If true, the topCenter will always appear on a separate line by itself, otherwise the |
| * topCenter will appear in the top row if there is room and will be moved to the second row if |
| * required. |
| * |
| * @param show true if the topCenter will always appear on a separate line by itself |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setTopCenterSeparate(boolean show) { |
| checkWidget(); |
| separateTopCenter = show; |
| layout(); |
| } |
| |
| } |