java类org.eclipse.swt.widgets.Slider的实例源码

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

/**
 * <p>
 * Tells whether the SWT Browser widget and hence this information control is
 * available.
 * </p>
 * 
 * @param parent the parent component used for checking or <code>null</code> if
 * none
 * 
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent) {
    if (!fgAvailabilityChecked) {
        try {
            Browser browser= new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable= true;

            Slider sliderV= new Slider(parent, SWT.VERTICAL);
            Slider sliderH= new Slider(parent, SWT.HORIZONTAL);
            int width= sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height= sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize= new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        } catch (SWTError er) {
            fgIsAvailable= false;
        } finally {
            fgAvailabilityChecked= true;
        }
    }

    return fgIsAvailable;
}

public void setSlider(Slider slider) {
    if (b.text != null && !b.text.isDisposed()) {
        sliderListener = new Listener() {

            @Override
            public void handleEvent(Event arg0) {
                // TODO Auto-generated method stub
                if (slider != null && !slider.isDisposed()) {
                    ScrollBar vb = b.text.getVerticalBar();
                    slider.setValues(vb.getSelection(), vb.getMinimum(), vb.getMaximum(), vb.getThumb(),
                            vb.getIncrement(), vb.getPageIncrement());
                }
            }
        };
        b.text.addListener(SWT.Paint, sliderListener);
    }
}

private void startSliderUpdateConditional(final Slider sliderStartDate, final Label startDateLabel, Slider sliderEndDate,  Label endDateLabel) {

        synchronized (sliderEndDate) {
            sliderSelection = true;
        }

        Integer startSliderValue = sliderStartDate.getSelection();

        if (sliderEndDate.getSelection() - sliderStartDate.getSelection() <= MINSLIDERVALUE) {
            if (sliderEndDate.getSelection() <= 100-MINSLIDERVALUE) {
                int endValue = startSliderValue+MINSLIDERVALUE;
                sliderEndDate.setSelection(endValue);
                endSliderUpdate(sliderEndDate, endDateLabel, endValue);
            } else {
                sliderEndDate.setSelection(99);
                endSliderUpdate(sliderEndDate, endDateLabel, 99);
                startSliderValue=100-MINSLIDERVALUE;
                sliderStartDate.setSelection(100-MINSLIDERVALUE);
            }

        }

        startSliderUpdate(sliderStartDate, startDateLabel, startSliderValue);

        slidingGroup.layout();
    }

private void startSliderUpdate(final Slider sliderStartDate, final Label startDateLabel, Integer sliderValue) {

        Date maxDate= maxDate();
        Date minDate= minimumDate();
        Integer maxSlider= 100;
        Integer minSlider= 0;
        Integer perCentValue = sliderValue*100/(maxSlider - minSlider - sliderStartDate.getThumb());

        Long diffDateInDays = (maxDate.getTime() - minDate.getTime())/(1000*3600*24);
        Long nbDaySinceMin  = perCentValue * diffDateInDays /100;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(minDate);
        calendar.add(Calendar.DAY_OF_YEAR, nbDaySinceMin.intValue());
        slidingStartDate = DateFactory.midnithDate(calendar.getTime());

        startDateLabel.setText(DateFormat.getDateInstance(DateFormat.MEDIUM).format(slidingStartDate));
        startDateLabel.setFont(MainGui.DEFAULTFONT);
    }

private void endSliderUpdateConditional( Slider sliderEndDate,  Label endDateLabel,  Slider sliderStartDate, Label startDateLabel) {

        synchronized (sliderEndDate) {
            sliderSelection = true;
        }


        Integer sliderValue = sliderEndDate.getSelection();

        if (sliderEndDate.getSelection() - sliderStartDate.getSelection() <= MINSLIDERVALUE) {
            if (sliderStartDate.getSelection() >= MINSLIDERVALUE) {
                int startValue = sliderValue-MINSLIDERVALUE;
                sliderStartDate.setSelection(startValue);
                startSliderUpdate(sliderStartDate, startDateLabel, startValue);
            } else {
                sliderStartDate.setSelection(0);
                startSliderUpdate(sliderStartDate, startDateLabel, 0);
                sliderValue = MINSLIDERVALUE;
                sliderEndDate.setSelection(MINSLIDERVALUE);
            }
        }

        endSliderUpdate(sliderEndDate, endDateLabel, sliderValue);

        slidingGroup.layout();
    }

private void endSliderUpdate(Slider sliderEndDate, Label endDateLabel, Integer sliderValue) {

        Date maxDate= maxDate();
        Date minDate= minimumDate();
        Integer maxSlider= 100;
        Integer minSlider= 0;
        Integer perCentValue = sliderValue*100/ (maxSlider - minSlider - sliderEndDate.getThumb());

        Long diffDate = (maxDate.getTime() - minDate.getTime())/(1000*3600*24);
        Long nbDaySinceMin  = perCentValue * diffDate /100;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(minDate);
        calendar.add(Calendar.DAY_OF_YEAR, nbDaySinceMin.intValue());
        slidingEndDate = DateFactory.midnithDate(calendar.getTime());

        endDateLabel.setText(DateFormat.getDateInstance(DateFormat.MEDIUM).format(slidingEndDate));
        endDateLabel.setFont(MainGui.DEFAULTFONT);

    }

@Test
public void updateScrollBarSelection() {
  FlatScrollBar scrollBar = createScrollBar();
  SelectionListener listener = equipScrollBarWithListener( scrollBar );
  MouseWheelSupport mouseWheelSupport = new MouseWheelSupport( scrollBar );
  mouseWheelSupport.create();
  Slider slider = ( Slider )mouseWheelSupport.getControl();
  slider.setSelection( 10 );

  mouseWheelSupport.updateScrollBarSelection( direction );

  SelectionEvent event = verifyNotification( listener );
  assertThat( event.widget ).isSameAs( scrollBar );
  assertThat( event.detail ).isEqualTo( direction );
  assertThat( scrollBar.getSelection() ).isEqualTo( 10 );
}

/**
 * Tells whether this control is available for given parent composite
 * 
 * @param parent
 *            the parent component used for checking or <code>null</code> if
 *            none
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailableFor(Composite parent) {
    if (!browserAvailabilityChecked) {
        try {
            Browser browser = new Browser(parent, SWT.NONE);
            browser.dispose();
            swtBrowserCanBeUsed = true;

            /* compute scrollbar size */
            Slider sliderV = new Slider(parent, SWT.VERTICAL);
            Slider sliderH = new Slider(parent, SWT.HORIZONTAL);

            int width = sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height = sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;

            cachedScrollBarSize = new Point(width, height);

            sliderV.dispose();
            sliderH.dispose();

        } catch (SWTError er) {
            swtBrowserCanBeUsed = false;
        } finally {
            browserAvailabilityChecked = true;
        }
    }

    return swtBrowserCanBeUsed;
}

FrameView(Composite parent) {
    super(parent, SWT.NONE);
    GridLayout layout = new GridLayout();
    setLayout(layout);
    setBackground(ColorConstants.white);
    header = new Label(this, SWT.BORDER);
    header.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));

    FontManager.setFont(header, Constants.MESSAGE_FONT_SIZE);

    viewer = new FrameViewer(this);

    slider = new Slider(this, SWT.HORIZONTAL | SWT.BORDER);
    slider.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));

    slider.setMinimum(1);
    slider.setMaximum(1);
    slider.setIncrement(1);
    slider.addSelectionListener(new SelectionAdapter() {
        int sel = slider.getSelection();
        @Override
        public void widgetSelected(SelectionEvent e) {
            if(slider.getSelection() != sel) {
                model.setStep(slider.getSelection()-1);
                sel = slider.getSelection();
                PandionJUI.navigateToLine(model.getSourceFile(), model.getStepLine());
                //              slider.setToolTipText(slider.getSelection() + "/" + slider.getMaximum());
            }
        }
    });
    slider.setVisible(false);
}

/**
 * Tells whether this control is available for given parent composite
 * 
 * @param parent
 *            the parent component used for checking or <code>null</code> if
 *            none
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailableFor(Composite parent) {
    if (!browserAvailabilityChecked) {
        try {
            Browser browser = new Browser(parent, SWT.NONE);
            browser.dispose();
            swtBrowserCanBeUsed = true;

            /* compute scrollbar size */
            Slider sliderV = new Slider(parent, SWT.VERTICAL);
            Slider sliderH = new Slider(parent, SWT.HORIZONTAL);

            int width = sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height = sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;

            cachedScrollBarSize = new Point(width, height);

            sliderV.dispose();
            sliderH.dispose();

        } catch (SWTError er) {
            swtBrowserCanBeUsed = false;
        } finally {
            browserAvailabilityChecked = true;
        }
    }

    return swtBrowserCanBeUsed;
}

/**
     * Create contents of the dialog.
     * @param parent
     */
    @Override protected Control createDialogArea(Composite parent) {
        Composite container = (Composite) super.createDialogArea(parent);
        container.setLayout(new GridLayout(5, false));

        Label gl = new Label(container, 0);
        gl.setText("Gamma correction: ");

        gammaSlider = new Slider(container, SWT.HORIZONTAL);
        gammaSlider.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        gammaSlider.setIncrement(1);
        gammaSlider.setValues(1, 1, 100, 1, 1, 1);
        gammaSlider.setSelection(50);
        gammaSlider.addSelectionListener(new SelectionAdapter() {           
            @Override public void widgetSelected(SelectionEvent e) {
                updateGammaValue();
            }
        });

        gammaValueLabel = new Label(container, 0);

        applyGammaBtn = new Button(container, SWT.PUSH);
        applyGammaBtn.setText("Apply");

        defaultGammaBtn = new Button(container, SWT.PUSH);
        defaultGammaBtn.setText("Default");
//      defaultGammaBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, true, false, 1, 1));

        updateSliderValueFromGamma();

        addListener();

        return container;
    }

private int getResizeHandleSize(Composite parent)
{
    if (fResizeHandleSize == -1)
    {
        Slider sliderV = new Slider(parent, SWT.VERTICAL);
        Slider sliderH = new Slider(parent, SWT.HORIZONTAL);
        int width = sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
        int height = sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
        sliderV.dispose();
        sliderH.dispose();
        fResizeHandleSize = Math.min(width, height);
    }

    return fResizeHandleSize;
}

/**
 * Tells whether the SWT Browser widget and hence this information control is available.
 * 
 * @param parent
 *            the parent component used for checking or <code>null</code> if none
 * @return <code>true</code> if this control is available
 */
public static boolean isAvailable(Composite parent)
{
    if (!fgAvailabilityChecked)
    {
        try
        {
            Browser browser = new Browser(parent, SWT.NONE);
            browser.dispose();
            fgIsAvailable = true;

            Slider sliderV = new Slider(parent, SWT.VERTICAL);
            Slider sliderH = new Slider(parent, SWT.HORIZONTAL);
            int width = sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
            int height = sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
            fgScrollBarSize = new Point(width, height);
            sliderV.dispose();
            sliderH.dispose();
        }
        catch (SWTError er)
        {
            fgIsAvailable = false;
        }
        finally
        {
            fgAvailabilityChecked = true;
        }
    }

    return fgIsAvailable;
}

protected void placeComponents( int style )
{
    GridLayout gl = new GridLayout( 1, false );
    gl.marginBottom = 0;
    gl.marginHeight = 0;
    gl.marginLeft = 0;
    gl.marginRight = 0;
    gl.marginTop = 0;
    gl.marginWidth = 0;
    this.setLayout( gl );

    slider = new Slider( this, style );
    GridData gd = new GridData( GridData.FILL_BOTH );
    slider.setLayoutData( gd );
}

@Test
public void getControl() {
  FlatScrollBar scrollBar = createScrollBar();
  MouseWheelSupport mouseWheelSupport = new MouseWheelSupport( scrollBar );
  mouseWheelSupport.create();

  Control actual = mouseWheelSupport.getControl();

  assertThat( actual ).isInstanceOf( Slider.class );
}

@Test
public void copySettingsIfSliderHasLayoutData() {
  FlatScrollBar scrollBar = createScrollBar();
  Rectangle expected = new Rectangle( 10, 20, 30, 40 );
  scrollBar.setBounds( expected );
  MouseWheelSupport mouseWheelSupport = new MouseWheelSupport( scrollBar );
  mouseWheelSupport.create();
  Slider slider = ( Slider )mouseWheelSupport.getControl();
  slider.setLayoutData( new FormData() );
  scrollBar.setBounds( new Rectangle( 50, 60, 70, 80 ) );

  mouseWheelSupport.copySettings();

  assertThat( slider.getBounds() ).isEqualTo( expected  );
}

private static void verifySliderSettings(
  MouseWheelSupport support, Rectangle bounds, int max, int min, int inc, int pageInc, int thumb, int selection  )
{
  Slider slider = ( Slider )support.getControl();
  assertThat( slider.getMaximum() ).isEqualTo( max );
  assertThat( slider.getMinimum() ).isEqualTo( min );
  assertThat( slider.getIncrement() ).isEqualTo( inc );
  assertThat( slider.getPageIncrement() ).isEqualTo( pageInc );
  assertThat( slider.getThumb() ).isEqualTo( thumb );
  assertThat( slider.getSelection() ).isEqualTo( selection );
  assertThat( slider.getBounds() ).isEqualTo( bounds );
}

private void createPartControl(Composite parent)
{
    GridLayout containerLayout = new GridLayout();
    containerLayout.marginWidth = 0;
    containerLayout.marginHeight = 0;

    GridData containerData = new GridData();
    containerData.horizontalAlignment = GridData.FILL;
    containerData.verticalAlignment = GridData.FILL;
    containerData.grabExcessHorizontalSpace = true;
    containerData.grabExcessVerticalSpace = true;

    Composite container = new Composite(parent, SWT.NONE);
    container.setLayout(containerLayout);
    container.setLayoutData(containerData);

    GridData sliderData = new GridData();
    sliderData.horizontalAlignment = GridData.FILL;
    sliderData.verticalAlignment = GridData.FILL;
    sliderData.grabExcessHorizontalSpace = true;
    sliderData.grabExcessVerticalSpace = true;

    slider = new Slider(container, SWT.HORIZONTAL);
    slider.setLayoutData(sliderData);
    slider.setEnabled(false);

    sliderListener = new TimeSliderListener();
    slider.addListener(SWT.Selection, sliderListener);
}

public Control construct(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    GridDataFactory.swtDefaults().align(SWT.FILL, SWT.FILL)
            .grab(true, true).applyTo(composite);
    GridLayoutFactory.swtDefaults().numColumns(2).applyTo(composite);

    Slider slider = new Slider (composite, SWT.HORIZONTAL);
    Rectangle clientArea = composite.getClientArea ();
    slider.setBounds (clientArea.x + 10, clientArea.y + 10, 200, 32);
    slider.addListener (SWT.Selection, new Listener () {
        public void handleEvent (Event event) {
            String string = "SWT.NONE";
            switch (event.detail) {
                case SWT.DRAG: string = "SWT.DRAG"; break;
                case SWT.HOME: string = "SWT.HOME"; break;
                case SWT.END: string = "SWT.END"; break;
                case SWT.ARROW_DOWN: string = "SWT.ARROW_DOWN"; break;
                case SWT.ARROW_UP: string = "SWT.ARROW_UP"; break;
                case SWT.PAGE_DOWN: string = "SWT.PAGE_DOWN"; break;
                case SWT.PAGE_UP: string = "SWT.PAGE_UP"; break;
            }
            System.out.println ("Scroll detail -> " + string);
        }
    });

    return null;
}

@Override
    public void createComponents(Composite parent)
    {
        parent.setLayout(new GridLayout(2, false));

        ColorVerifier verifier = new ColorVerifier();
        Handler handler = new Handler();

        COLORS[0] = parent.getDisplay().getSystemColor(SWT.COLOR_RED);
        COLORS[1] = parent.getDisplay().getSystemColor(SWT.COLOR_GREEN);
        COLORS[2] = parent.getDisplay().getSystemColor(SWT.COLOR_BLUE);
        COLORS[3] = parent.getDisplay().getSystemColor(SWT.COLOR_GRAY);
        int[] cc = new int[] {color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha()};
        for (int i = 0; i < ELEMENT_COUNT; i++)
        {
//          labels[i] = new Label(parent, SWT.BORDER);
//          labels[i].setLayoutData(new GridData(32, 20));
//          labels[i].setBackground(COLORS[i]);
            sliders[i] = new Slider(parent, SWT.NONE);
            sliders[i].setBackground(COLORS[i]);
            sliders[i].addListener(SWT.Selection, handler);
            sliders[i].setValues(0, 0, 256, 1, 1, 10);
            texts[i] = new Text(parent, SWT.BORDER);
            texts[i].addVerifyListener(verifier);
            texts[i].addListener(SWT.Modify, handler);

            texts[i].setText( Integer.toString(cc[i]));
        }
    }

static SelectionAdapter create(Widget widget) {
    if (widget instanceof Button) {
        return create((Button) widget);
    } else if (widget instanceof CCombo) {
        return create((CCombo) widget);
    } else if (widget instanceof Combo) {
        return create((Combo) widget);
    } else if (widget instanceof CoolItem) {
        return create((CoolItem) widget);
    } else if (widget instanceof CTabFolder) {
        return create((CTabFolder) widget);
    } else if (widget instanceof DateTime) {
        return create((DateTime) widget);
    } else if (widget instanceof Link) {
        return create((Link) widget);
    } else if (widget instanceof List) {
        return create((List) widget);
    } else if (widget instanceof MenuItem) {
        return create((MenuItem) widget);
    } else if (widget instanceof Sash) {
        return create((Sash) widget);
    } else if (widget instanceof Scale) {
        return create((Scale) widget);
    } else if (widget instanceof Slider) {
        return create((Slider) widget);
    } else if (widget instanceof Spinner) {
        return create((Spinner) widget);
    } else if (widget instanceof StyledText) {
        return create((StyledText) widget);
    } else if (widget instanceof TabFolder) {
        return create((TabFolder) widget);
    } else if (widget instanceof Table) {
        return create((Table) widget);
    } else if (widget instanceof TableColumn) {
        return create((TableColumn) widget);
    } else if (widget instanceof TableCursor) {
        return create((TableCursor) widget);
    } else if (widget instanceof Text) {
        return create((Text) widget);
    } else if (widget instanceof ToolItem) {
        return create((ToolItem) widget);
    } else if (widget instanceof ToolTip) {
        return create((ToolTip) widget);
    } else if (widget instanceof TrayItem) {
        return create((TrayItem) widget);
    } else if (widget instanceof Tree) {
        return create((Tree) widget);
    } else if (widget instanceof TreeColumn) {
        return create((TreeColumn) widget);
    } else if (widget instanceof TreeCursor) {
        return create((TreeCursor) widget);
    }

    throw new IllegalArgumentException("The given widget (" + widget.getClass().getName() + ") is not supported.");
}

/**
 * Slider
 */
public static void setValues(Slider s) {
    setValues(s, 0, 0, 1, 0);
}

public static void setValues(Slider s, int min, int max, int thumb) {
    setValues(s, min, max, thumb, s.getSelection());
}

public static void setValues(Slider s, int min, int max, int thumb, int selection) {
    setValues(s, min, thumb + max, thumb, selection, s.getIncrement(), s.getPageIncrement());
}