| org.eclipse.ui.ISizeProvider
All known Subclasses: org.eclipse.ui.internal.WorkbenchPartReference, org.eclipse.ui.presentations.StackPresentation, org.eclipse.ui.internal.LayoutPart, org.eclipse.ui.internal.LayoutTree,
| ISizeProvider | | public interface ISizeProvider (Code) | | Interface implemented by objects that are capable of computing
a preferred size
since:
3.1 |
| Field Summary | |
| final public static int | INFINITE
Constant used to indicate infinite size. |
| Method Summary | |
| public int | computePreferredSize(boolean width, int availableParallel, int availablePerpendicular, int preferredResult)
Returns the best size for this part, given the available width and height and the workbench's
preferred size for the part. | | public int | getSizeFlags(boolean width)
Returns a bitwise combination of flags indicating how and when computePreferredSize should
be used. |
| INFINITE | | final public static int INFINITE(Code) | | Constant used to indicate infinite size. This is equal to Integer.MAX_VALUE, ensuring
that it is greater than any other integer.
|
| computePreferredSize | | public int computePreferredSize(boolean width, int availableParallel, int availablePerpendicular, int preferredResult)(Code) | |
Returns the best size for this part, given the available width and height and the workbench's
preferred size for the part. Parts can overload this to enforce a minimum size, maximum size,
or a quantized set of preferred sizes. If width == true, this method computes a width in pixels.
If width == false, this method computes a height. availableParallel and availablePerpendicular
contain the space available, and preferredParallel contains the preferred result.
This method returns an answer that is less than or equal to availableParallel and as
close to preferredParallel as possible. Return values larger than availableParallel will
be truncated.
Most presentations will define a minimum size at all times, and a maximum size that only applies
when maximized.
The getSizeFlags method controls how frequently this method will be called and what information
will be available when it is. Any subclass that specializes this method should also specialize
getSizeFlags. computePreferredSize(width, INFINITE, someSize, 0) returns
the minimum size of the control (if any). computePreferredSize(width, INFINITE, someSize,
INFINITE) returns the maximum size of the control.
Examples:
- To maintain a constant size of 100x300 pixels: {return width ? 100 : 300}, getSizeFlags(boolean) must
return SWT.MIN | SWT.MAX
- To grow without constraints: {return preferredResult;}, getSizeFlags(boolean) must return 0.
- To enforce a width that is always a multiple of 100 pixels, to a minimum of 100 pixels:
{
if (width && preferredResult != INFINITE) {
int result = preferredResult - ((preferredResult + 50) % 100) + 50;
result = Math.max(100, Math.min(result, availableParallel - (availableParallel % 100)));
return result;
}
return preferredResult;
}
In this case, getSizeFlags(boolean width) must return (width ? SWT.FILL | SWT.MIN: 0)
To maintain a minimum area of 100000 pixels:
{return availablePerpendicular < 100 ? 1000 : 100000 / availablePerpendicular;}
getSizeFlags(boolean width) must return SWT.WRAP | SWT.MIN;
Parameters:
width - indicates whether a width (=true) or a height (=false) is being computed
Parameters:
availableParallel - available space. This is a width (pixels) if width == true, and a height (pixels)if width == false. A return value larger than this will be ignored.
Parameters:
availablePerpendicular - available space perpendicular to the direction being measuredor INFINITE if unbounded (pixels). Thisis a height if width == true, or a height if width == false. Implementations will generally ignore thisargument unless they contain wrapping widgets. Note this argument will only contain meaningful informationif the part returns the SWT.WRAP flag from getSizeFlags(width)
Parameters:
preferredResult - preferred size of the control (pixels, <= availableParallel). Set to INFINITE if unknown or unbounded. returns the preferred size of the control (pixels). This is a width if width == true or a height if width == false. Callers are responsible for rounding down the return value if it is larger thanavailableParallel. If availableParallel is INFINITE, then a return value of INFINITEis permitted, indicating that the preferred size of the control is unbounded.
See Also: ISizeProvider.getSizeFlags(boolean)
See Also: |
| getSizeFlags | | public int getSizeFlags(boolean width)(Code) | | Returns a bitwise combination of flags indicating how and when computePreferredSize should
be used. When called with horizontal=true, this indicates the usage of computePreferredSize(true,...)
for computing widths. When called with horizontal=false, this indicates the usage of computeSize(false,...)
for computing heights. These flags are used for optimization. Each flag gives the part more control
over its preferred size but slows down the layout algorithm. Parts should return the minimum set
of flags necessary to specify their constraints.
If the return value of this function ever changes, the part must call flushLayout before
the changes will take effect.
- SWT.MAX: The part has a maximum size that will be returned by computePreferredSize(horizontal,
INFINITE, someWidth, INFINITE)
- SWT.MIN: The part has a minimum size that will be returned by computePreferredSize(horizontal,
INFINITE, someWidth, 0)
- SWT.WRAP: Indicates that computePreferredSize makes use of the availablePerpendicular argument. If this
flag is not specified, then the third argument to computePreferredSize will always be set to
INFINITE. The perpendicular size is expensive to compute, and it is usually only used
for wrapping parts.
- SWT.FILL: The part may not return the preferred size verbatim when computePreferredSize is
is given a value between the minimum and maximum sizes. This is commonly used if the part
wants to use a set of predetermined sizes instead of using the workbench-provided size.
For example, computePreferredSize(horizontal, availableSpace, someWidth,
preferredSize) may return the nearest predetermined size. Note that this flag should
be used sparingly. It can prevent layout caching and cause the workbench layout algorithm
to degrade to exponential worst-case runtime. If this flag is omitted, then
computePreferredSize may be used to compute the minimum and maximum sizes, but not for
anything in between.
Parameters:
width - a value of true or false determines whether the return value applies when computingwidths or heights respectively. That is, getSizeFlags(true) will be used when calling computePreferredSize(true,...) any bitwise combination of SWT.MAX, SWT.MIN, SWT.WRAP, and SWT.FILL |
|
|