Switche.xcsm

浏览该文件的文档.

//xlang Source, Name:Switche.xcsm
//Date: Sun Oct 19:29:40 2018
 
package Qt{
    @SuppressWarnings public class Switche : QWidget {
        double _scale = 1.f;
        double switchbegin = 0.f;
        double _present = 0.f;
        bool _bOn = true;
        Timer _animator = nilptr;
        Object _timeObj = new Object();
        QImage _cachedBitmap = nilptr;
        bool _bForceRedraw = false;
        OnSwitchListener _listener = nilptr;
        int switchOnColor = 0xff4BD963;
        int switchOffColor = 0xffcccccc;
 
        public interface OnSwitchListener {
            void onSwitch(Switche view,bool __bOn);
        };
 
        public void setOnSwitchListener(OnSwitchListener listener) {
            _listener = listener;
        }
 
 
        public int dip2px(double dpValue) {
            return (int) (dpValue * _scale + 0.5f);
        }
 
 
        public void onDraw(@NotNilptr QPainter canvas) {
            // TODO Auto-generated method stub
            __nilptr_safe(_cachedBitmap);
            
            if (_present != 0 && switchbegin == 0) {
                switchbegin = (width() - height()) * _present;
            }
            /*canvas.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source);
            canvas.fillRect(0, 0, width(), height(), 0, QPainter.BrushStyle.SolidPattern);*/
 
            canvas.setRenderHint(RenderHint.Antialiasing, true);
 
            bool bReCreateCached = false;
            if (_cachedBitmap == nilptr ) {
                bReCreateCached = true;
                _bForceRedraw = true;
            } else if (_cachedBitmap.width() != width() || _cachedBitmap.height() != height()) {
                bReCreateCached = true;
                _bForceRedraw = true;
            }
            try{
                if (bReCreateCached) {
                    _cachedBitmap = new QImage(width(), height(), QImage.Format_ARGB32);
                }
 
                if (_bForceRedraw) {
                    _bForceRedraw = false;
                    QPainter _canvas = new QPainter(_cachedBitmap);
                    _canvas.setCompositionMode(CompositionMode.CompositionMode_Source);
                    _canvas.fillRect(0, 0, width(), height(), 0, QBrush.Style.SolidPattern);
                    _canvas.setRenderHint(RenderHint.Antialiasing, true);
 
 
                    double padding = dip2px(3.f);
 
                    //_QPainter.drawColor(0x00000000);
                    double r = (height() / 2.f) - padding ;
 
                    QPainter.Paint paint = new QPainter.Paint();
                    //paint.setShadowLayer(3.F, 2.F,2.F, Color.BLACK);
 
                    QRect rect = new QRect();
                    rect.left = rect.top = (padding / 2);
                    rect.right = width() - (padding / 2);
                    rect.bottom = height() - (padding / 2);
                    double rxy = rect.height() / 2.f;
 
                    paint.setStyle(QPainter.Paint.FILL_AND_STROKE);
                    paint.setColor( (this._bOn && (_present == 1)) ? switchOnColor : switchOffColor);
                    paint.setStrokeWidth(1.f);
                    //paint.setShadowLayer(0,0,0, Color.BLACK);
                    _canvas.drawRoundedRect(rect, (int)rxy, (int)rxy,paint);
 
                    QRect disablerect = new QRect(rect);
                    disablerect.left = switchbegin;
                    disablerect.right = rect.right - (switchbegin);
                    disablerect.top = rect.top + (switchbegin);
                    disablerect.bottom = rect.bottom - (switchbegin);
 
                    if (disablerect.right > disablerect.left && disablerect.bottom > disablerect.top) {
                        paint.setStyle(QPainter.Paint.FILL);
 
                        double rate = Math.min(1.f,(1.f -_present));
                        int alpha = (int) (0xff * rate);
                        if (alpha > 0xCE) {
                            alpha = 0xCE;
                        } else if (alpha < 0) {
                            alpha = 0;
                        }
                        alpha <<= 24;
                        paint.setColor(0x00ffffff | alpha);
                        _canvas.drawRoundedRect(disablerect, (int)rxy, (int)rxy,paint);
                    }
 
 
                    if (_present != 0.f) {
                        paint.setStyle(QPainter.Paint.FILL);
                        QRect avarect = new QRect(rect);
                        avarect.right = switchbegin + (r * 2);
 
                        double rate = (1.f -_present);
                        int rgbValue = switchOnColor & 0xffffff;
                        int dist = (0xffffff - rgbValue);
 
                        int _rv = (int) (((dist>>16) & 0xff) * rate);
                        int _gv = (int) (((dist>>8) & 0xff) * rate);
                        int _bv = (int) ((dist & 0xff) * rate);
 
                        int newclr =  (_rv<<16) | (_gv << 8) | _bv;
                        int colordis = (int) (switchOnColor + newclr);
                        paint.setColor(colordis);
                        _canvas.drawRoundedRect(avarect,(int)rxy, (int)rxy,paint);
                    }
 
                    paint.setStyle(QPainter.Paint.FILL);
                    paint.setColor(0xffffffff);
                    //paint.setShadowLayer(2.F, 0.F,2.F, 0xff333333);
                    _canvas.drawCircle((int)(switchbegin + (height() / 2.f)), (int)(height() / 2.f), (int)r, paint);
 
                    //paint.setMaskFilter(blurFilter);
                    //paint.setShadowLayer(10F, 11F,5F, Color.BLACK);
                    //paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
                    paint.setStrokeWidth(0.f);
                    paint.setStyle(QPainter.Paint.STROKE);
                    paint.setColor(0xffdedede);
                    //paint.setShadowLayer(0,0,0, Color.BLACK);
                    _canvas.drawCircle((int)(switchbegin + (height() / 2.f)), (int)(height() / 2.f), (int)r, paint);
                }
                if (this.isEnabled() == false) {
                    /*Paint bitmapPaint = new Paint();
                    bitmapPaint.setAlpha(0x7f);*/
                    canvas.drawImage(_cachedBitmap, 0, 0);
                } else {
                    canvas.drawImage(_cachedBitmap, 0, 0);
                }
            }catch(Exception e){
                
            }
        }
 
        public void onMouseButtonPress(int Button, int x, int y, int flags, int source)override {
            // TODO Auto-generated method stub
            if (this.isEnabled() == false) {
                return ;
            }
 
            _bOn = !_bOn;
            try{
                activeAnimation();
            }catch(IllegalArgumentException e){
                
            }
 
            if (_listener != nilptr) {
                _listener.onSwitch(this, _bOn);
            }
            //break;
        }
 
        public bool create()override  {
            if (super.create()) {
                resize(42, 30);
                setAttribute(Constant.WA_TranslucentBackground, true);
                try{
                    activeAnimation();
                }catch(IllegalArgumentException e){
                    
                }
                return true;
            }
            return false;
        }
 
        public bool create(@NotNilptr QWidget parent) override {
            if (super.create(parent)) {
                resize(42, 30);
                setAttribute(Constant.WA_TranslucentBackground, true);
                try{
                    activeAnimation();
                }catch(IllegalArgumentException e){
                    
                }
                return true;
            }
            return false;
        }
 
        public bool activeAnimation() throws IllegalArgumentException{
            synchronized(_timeObj) {
                if (_animator != nilptr) {
                    return false;
                }
 
                _animator = new Timer();
         
                _animator.schedule(new TimerTask() {
                    void run() override {
                        synchronized(_timeObj) {
                            double step = width() / 46.f;
                            if (_bOn) {
                                double destX = width() - (height());
                                if (switchbegin < destX) {
                                    switchbegin += step;
                                } else {
                                    if (switchbegin > destX) {
                                        switchbegin = switchbegin - 1;
                                        if (switchbegin < destX) {
                                            switchbegin = destX;
                                        }
                                    }
                                    if (switchbegin == destX) {
                                        _animator.cancel();
                                        _animator = nilptr;
                                    }
                                }
                            } else {
                                double destX = 0;
                                if (switchbegin <= destX) {
                                    if (switchbegin < destX) {
                                        switchbegin = switchbegin + 1;
                                        if (switchbegin > destX) {
                                            switchbegin = destX;
                                        }
                                    }
                                    if (switchbegin == destX) {
                                        _animator.cancel();
                                        _animator = nilptr;
                                    }
                                } else {
                                    switchbegin -= step;
                                }
                            }
                        }
                        _present = switchbegin / (width() - (height()));
                        _bForceRedraw = true;
                        Switche.this.postUpdate();
                    }
                }, 10, -1);
            }
            return true;
        }
 
        public bool getChecked() {
            return _bOn;
        }
 
        public void setChecked(bool bOn,bool bAnimation) {
            _bForceRedraw = _bOn != bOn;
            _bOn = bOn;
            if (bAnimation == false) {
 
                if (_bOn) {
                    _present = 1;
                    switchbegin = width() - (height());
                } else {
                    _present = 0.f;
                    switchbegin = 0;
                }
 
                postUpdate();
            } else {
                try{
                     activeAnimation();
                }catch(IllegalArgumentException e){
                    
                }
            }
        }
 
        public void configColor(int _cOn,int _cOff) {
            if (_cOn != 0) {
                switchOnColor = _cOn;
            }
            if (_cOff != 0) {
                switchOffColor = _cOff;
            }
        }
 
        public void onPaint(int , int , int , int , long hpaint) override {
            onDraw(new QPainter(hpaint));
        }
    };
};