黑莓滑条

Question

我有兴趣在我的BlackBerry应用程序中使用可拖动滑条。

我想知道在BlackBerry API中是否有这样的东西，或者如果有人做过类似的事情！

Answer 1

有一个GaugeField -

这里是它an example与bimaps -

Answer 2

下面是滑块字段中的代码，您需要使用您自己的“.png”图像，因为我无法将它们附加在这里，现在您需要做的就是创建一个名为SliderField的类并将该代码粘贴到该类中并传递参数：

package mypackage; 

import java.lang.Math; 

import net.rim.device.api.system.*; 
import net.rim.device.api.ui.*; 

public class SliderField extends Field 
{ 
Bitmap _imageThumb; 

Bitmap _imageSlider; 
Bitmap _imageSliderLeft; 
Bitmap _imageSliderCenter; 
Bitmap _imageSliderRight; 

Bitmap _imageSliderFocus; 
Bitmap _imageSliderFocusLeft; 
Bitmap _imageSliderFocusCenter; 
Bitmap _imageSliderFocusRight; 

private int _numStates; 
private int _currentState; 
private boolean _selected; 

private int _xLeftBackMargin; 
private int _xRightBackMargin; 

private int _thumbWidth; 
private int _thumbHeight; 

private int _totalHeight; 
private int _totalWidth; 

private int _rop; 

private int _backgroundColours[]; 
private int _backgroundSelectedColours[]; 

private int _defaultSelectColour = 0x977DED; 
private int _defaultBackgroundColour = 0x000000; 
private int _defaultHoverColour = 0x999999; 


public SliderField(Bitmap thumb 
      , Bitmap sliderBackground 
      , int numStates 
      , int initialState 
      , int xLeftBackMargin 
      , int xRightBackMargin) 
{ 
    this(thumb, sliderBackground, sliderBackground, numStates, initialState, xLeftBackMargin, xRightBackMargin, FOCUSABLE); 
} 

public SliderField(Bitmap thumb 
      , Bitmap sliderBackground 
      , int numStates 
      , int initialState 
      , int xLeftBackMargin 
      , int xRightBackMargin 
      , long style) 
{ 
    this(thumb, sliderBackground, sliderBackground, numStates, initialState, xLeftBackMargin, xRightBackMargin, style); 
} 

public SliderField(Bitmap thumb 
      , Bitmap sliderBackground 
      , Bitmap sliderBackgroundFocus 
      , int numStates 
      , int initialState 
      , int xLeftBackMargin 
      , int xRightBackMargin) 
{ 
    this(thumb, sliderBackground, sliderBackgroundFocus, numStates, initialState, xLeftBackMargin, xRightBackMargin, FOCUSABLE); 
} 

public SliderField(Bitmap thumb 
      , Bitmap sliderBackground 
      , Bitmap sliderBackgroundFocus 
      , int numStates 
      , int initialState 
      , int xLeftBackMargin 
      , int xRightBackMargin 
      , long style) 
{ 
    super(style); 

    if(initialState > numStates || numStates < 2){ 
    } 
    _imageThumb = thumb; 
    _imageSlider = sliderBackground; 
    _imageSliderFocus = sliderBackgroundFocus; 
    _numStates = numStates; 
    setState(initialState); 

    _xLeftBackMargin = xLeftBackMargin; 
    _xRightBackMargin = xRightBackMargin; 

    _rop = _imageSlider.hasAlpha() ? Graphics.ROP_SRC_ALPHA : Graphics.ROP_SRC_COPY; 

    _thumbWidth = thumb.getWidth(); 
    _thumbHeight = thumb.getHeight(); 
    initBitmaps(); 
}    
public SliderField(Bitmap thumb 
      , Bitmap sliderBackground 
      , int numStates 
      , int initialState 
      , int xLeftBackMargin 
      , int xRightBackMargin 
      , int[] colours 
      , int[] selectColours) 
{ 
    this(thumb, sliderBackground, sliderBackground, numStates, initialState, xLeftBackMargin, xRightBackMargin, FOCUSABLE); 

    if(colours.length != numStates+1){ 
     throw new IllegalArgumentException(); 
    } 
    _backgroundColours = colours; 
    _backgroundSelectedColours = selectColours; 
} 
public void initBitmaps() 
{ 
    int height = _imageSlider.getHeight(); 

    _imageSliderLeft = new Bitmap(_xLeftBackMargin, height); 
    _imageSliderCenter = new Bitmap(_imageSlider.getWidth() - _xRightBackMargin - _xLeftBackMargin, height); 
    _imageSliderRight = new Bitmap(_xRightBackMargin, height); 

    copy(_imageSlider, 0, 0, _xLeftBackMargin, height, _imageSliderLeft); 
    copy(_imageSlider, _xLeftBackMargin, 0, _imageSlider.getWidth() - _xRightBackMargin - _xLeftBackMargin, height, _imageSliderCenter); 
    copy(_imageSlider, _imageSlider.getWidth() - _xRightBackMargin, 0, _xRightBackMargin, height, _imageSliderRight); 

    _imageSliderFocusLeft = new Bitmap(_xLeftBackMargin, height); 
    _imageSliderFocusCenter = new Bitmap(_imageSlider.getWidth() - _xRightBackMargin - _xLeftBackMargin, height); 
    _imageSliderFocusRight = new Bitmap(_xRightBackMargin, height); 

    copy(_imageSliderFocus, 0, 0, _xLeftBackMargin, height, _imageSliderFocusLeft); 
    copy(_imageSliderFocus, _xLeftBackMargin, 0, _imageSlider.getWidth() - _xRightBackMargin - _xLeftBackMargin, height, _imageSliderFocusCenter); 
    copy(_imageSliderFocus, _imageSlider.getWidth() - _xRightBackMargin, 0, _xRightBackMargin, height, _imageSliderFocusRight); 
} 
private void copy(Bitmap src, int x, int y, int width, int height, Bitmap dest) { 
    int[] argbData = new int[width * height]; 
    src.getARGB(argbData, 0, width, x, y, width, height); 
    for(int tx = 0; tx < dest.getWidth(); tx += width) { 
     for(int ty = 0; ty < dest.getHeight(); ty += height) { 
      dest.setARGB(argbData, 0, width, tx, ty, width, height); 
     } 
    } 
} 
public void setState(int newState) { 
    if(newState > _numStates){ 
     throw new IllegalArgumentException(); 
    } else { 
     _currentState = newState; 
     invalidate(); 
    } 
} 
public int getState() { 
    return _currentState; 
} 
public int getNumStates() { 
    return _numStates; 
} 
public int getColour() { 
    if(_backgroundSelectedColours != null) { 
     return _backgroundSelectedColours[getState()]; 
    } 
    return 0x000000; 
} 

public int getPreferredWidth() { 
    return _totalWidth; 
} 

public int getPreferredHeight() { 
    return _totalHeight; 
} 
protected void layout(int width, int height) { 
    if (width < 0 || height < 0) 
     throw new IllegalArgumentException(); 
    _totalWidth = width; 
    _totalHeight = Math.max(_imageSlider.getHeight(), _imageThumb.getHeight()); 

    setExtent(_totalWidth, _totalHeight); 
} 

public void paint(Graphics g) 
{ 
    int sliderHeight = _imageSlider.getHeight(); 
    int sliderBackYOffset = (_totalHeight - sliderHeight) >> 1; 
    int backgroundColor = _defaultBackgroundColour; 
    if(_backgroundSelectedColours != null || _backgroundColours != null) { 

     if(_selected) { 
      backgroundColor = _backgroundSelectedColours != null ? _backgroundSelectedColours[getState()] : _defaultSelectColour; 
     } else if(g.isDrawingStyleSet(Graphics.DRAWSTYLE_FOCUS)) { 
      backgroundColor = _backgroundColours != null ? _backgroundColours[getState()] : _defaultHoverColour; 
     } else { 
      backgroundColor = _defaultBackgroundColour; 
     } 
    } 
    g.setColor(backgroundColor); 
    g.fillRect(1, sliderBackYOffset + 1, _totalWidth - 2, sliderHeight - 2); 

    if(g.isDrawingStyleSet(Graphics.DRAWSTYLE_FOCUS)) {  
     paintSliderBackground(g, _imageSliderFocusLeft, _imageSliderFocusCenter, _imageSliderFocusRight); 
    } else { 
     paintSliderBackground(g, _imageSliderLeft, _imageSliderCenter, _imageSliderRight); 
    } 
    int thumbXOffset = ((_totalWidth - _thumbWidth) * _currentState)/_numStates; 
    g.drawBitmap(thumbXOffset, (_totalHeight - _thumbHeight) >> 1, _thumbWidth, _thumbHeight, _imageThumb, 0, 0); 
} 

private void paintSliderBackground(Graphics g, Bitmap left, Bitmap middle, Bitmap right) 
{ 
    int sliderHeight = _imageSlider.getHeight(); 
    int sliderBackYOffset = (_totalHeight - sliderHeight) >> 1; 
    g.drawBitmap(0, sliderBackYOffset, _xLeftBackMargin, sliderHeight, left, 0, 0); 
    g.tileRop(_rop, _xRightBackMargin, sliderBackYOffset, _totalWidth - _xLeftBackMargin - _xRightBackMargin, sliderHeight, middle, 0, 0); 
    g.drawBitmap(_totalWidth - _xRightBackMargin, sliderBackYOffset, _xRightBackMargin, sliderHeight, right, 0, 0); 
} 

public void paintBackground(Graphics g) 
{ 
} 

protected void drawFocus(Graphics g, boolean on) 
{ 
    boolean oldDrawStyleFocus = g.isDrawingStyleSet(Graphics.DRAWSTYLE_FOCUS); 
    try { 
     if(on) { 
      g.setDrawingStyle(Graphics.DRAWSTYLE_FOCUS, true); 
     } 
     paint(g); 
    } finally { 
     g.setDrawingStyle(Graphics.DRAWSTYLE_FOCUS, oldDrawStyleFocus); 
    } 
} 
protected boolean touchEvent(TouchEvent message) 
{ 
    boolean isConsumed = false; 
    boolean isOutOfBounds = false; 
    int x = message.getX(1); 
    int y = message.getY(1); 
    if(x < 0 || y < 0 || x > getExtent().width || y > getExtent().height) { 
     isOutOfBounds = true; 
    } 
    switch(message.getEvent()) { 
     case TouchEvent.CLICK: 
     case TouchEvent.MOVE: 
      if(isOutOfBounds) return true; 
      _selected = true; 

      int stateWidth = getExtent().width/_numStates; 
      int numerator = x/stateWidth; 
      int denominator = x % stateWidth; 
      if(denominator > stateWidth/2) { 
       numerator++; 
      } 
      _currentState = numerator; 
      invalidate(); 

      isConsumed = true; 
      break; 
     case TouchEvent.UNCLICK: 
      if(isOutOfBounds) { 
       _selected = false; 
       return true; 
      } 
      _selected = false; 
      stateWidth = getExtent().width/_numStates; 
      numerator = x/stateWidth; 
      denominator = x % stateWidth; 
      if(denominator > stateWidth/2) { 
       numerator++; 
      } 
      _currentState = numerator; 
      invalidate(); 
      fieldChangeNotify(0); 
      isConsumed = true; 
      break; 
    } 
    return isConsumed; 
} 
protected boolean navigationMovement(int dx, int dy, int status, int time) 
{ 
    if(_selected) 
    { 
     if(dx > 0 || dy > 0) { 
      incrementState(); 
      fieldChangeNotify(0); 
      return true; 
     } else if(dx < 0 || dy < 0) { 
      decrementState(); 
      fieldChangeNotify(0); 
      return true; 
     } 
    } 
    return super.navigationMovement(dx, dy, status, time); 
} 
public void decrementState() { 
    if(_currentState > 0) { 
     _currentState--; 
     invalidate(); 
    } 
} 
public void incrementState() { 
    if(_currentState < _numStates) { 
     _currentState++; 
     invalidate(); 
    } 
} 
protected boolean invokeAction(int action) { 
    switch(action) { 
     case ACTION_INVOKE: { 
      toggleSelected(); 
      return true; 
     } 
    } 
    return false; 
} 
protected boolean keyChar(char key, int status, int time) { 
    if(key == Characters.SPACE || key == Characters.ENTER) { 
     toggleSelected(); 
     return true; 
    } 

    return false; 
} 
protected boolean trackwheelClick(int status, int time) { 
    if(isEditable()) { 
     toggleSelected(); 
     return true; 
    } 
    return super.trackwheelClick(status, time); 
} 
private void toggleSelected() { 
    _selected = !_selected; 
    invalidate(); 
} 
public void setDirty(boolean dirty) 
{ 
} 
public void setMuddy(boolean muddy) 
{ 
} 

}