精华内容
下载资源
问答
  • 时间轴控件

    2017-11-06 11:04:55
    时间轴控件控件,里面有样式和js从上到下排列按时间顺序
  • wpf 时间轴控件

    2017-06-29 12:18:56
    wpf 时间轴控件
  • TimelineDataSource时间线控件 TimelineDataSource时间线控件 TimelineDataSource时间线控件 TimelineDataSource时间线控件 TimelineDataSource时间线控件 TimelineDataSource时间线控件
  • MFC时间轴控件

    热门讨论 2011-12-23 10:00:40
    通过MFC的静态类派生的时间轴控件,提供时间轴的显示、设置及查询,并且可在时间轴上显示两层不同颜色的背景,供有类似需求的MFC程序员参考。
  • jquery时间轴控件

    2015-03-26 17:13:06
    jquery时间轴控件,内含时间轴JS类库,开发实例,轻巧好用
  • DYLIKE时间轴控件

    2008-12-26 01:47:20
    DYLIKE时间轴控件
  • 时间轴控件控件,里面有样式和js从上到下排列按时间顺序
  • 一个自定义时间轴控件,有问题可以留言
  • 精美的时间轴控件

    2015-09-25 15:39:50
    精美的时间轴控件,需自行优化,通过实体类、数组
  • Andorid自定义布局时间轴控件
  • VC 自定义时间轴控件

    热门讨论 2010-10-15 11:49:29
    基于MFC写的时间轴控件,可添加背景图片等,有兴趣的可以看看
  • Android 具有左右滑动功能的时间轴控件代码源码
  • 精美的时间轴控件 如果需要 可自行优化,修改.zip,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • android 仿淘宝物流时间轴控件

    千次阅读 2016-10-19 10:29:28
    Android 仿淘宝物流时间轴控件 在这里感谢一片作者的demo,我在他的基础上做了写修改 ,改成我们项目所用的样式!还是那句话没有实现不了的需求,只有想不到的。首先看我们项目的设计图。  首先看一下别人的...

    Android 仿淘宝物流时间轴控件

    在这里感谢一片作者的demo,我在他的基础上做了写修改 ,改成我们项目所用的样式!还是那句话没有实现不了的需求,只有想不到的。首先看我们项目的设计图。 
    这里写图片描述

    首先看一下别人的自定义时间轴控件,是通过画布的方法自己写的一个view.

    `public class TimeLineView extends View {

    private Paint mPaint;
    /**
     * 第一个节点的外半径
     */
    private float timelineHeadRadius;
    /**
     * 第一个节点的颜色值
     */
    // private int timelineHeadColor;
    /**
     * 第二个节点的颜色值
     */
    private int timelineOtherColor;
    /**
     * 时间线的节点数
     */
    private int timelineCount;
    /**
     * 时间轴的位置
     */
    private int viewWidth;
    /**
     * 时间轴到距离顶部的距离
     */
    private int marginTop;
    /**
     * 时间轴的节点的半径
     */
    private int timelineRadius;
    /**
     * 时间轴节点之间的距离
     */
    private int timelineRadiusDistance;
    /**
     * 时间轴的宽度
     */
    private int timelineWidth;
    /**
     * 时间轴的高度
     */
    private float timeLineViewHeight;
    
    /**
     * 自己需求第一个显示的颜色图片
     * */
    
    private Bitmap bitmapHead;
    
    public TimeLineView(Context context) {
        this(context, null);
    }
    
    public TimeLineView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
    
    public TimeLineView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context, attrs, defStyle);
    }
    
    /**
     * 初始化
     *
     * @param context
     * @param attrs
     * @param defStyle
     */
    private void init(Context context, AttributeSet attrs, int defStyle) {
    
        final TypedArray a = getContext().obtainStyledAttributes(attrs,
                R.styleable.TimeLineView, defStyle, 0);
        timelineRadiusDistance = (int) a.getDimension(
                R.styleable.TimeLineView_timelineRadiusDistance,
                convertDIP2PX(context, 20));
        // timelineHeadRadius =
        // a.getDimension(R.styleable.TimeLineView_timelineHeadRadius,
        // convertDIP2PX(context, 10));
        timelineRadius = (int) a.getDimension(
                R.styleable.TimeLineView_timelineRadius,
                convertDIP2PX(context, 5));
        // timelineHeadColor =
        // a.getColor(R.styleable.TimeLineView_timelineHeadColor,
        // Color.parseColor("#F15719"));
        timelineOtherColor = a.getColor(
                R.styleable.TimeLineView_timelineOtherColor,
                Color.parseColor("#A8A8A8"));
        timelineCount = a.getInteger(R.styleable.TimeLineView_timelineCount, 0);
        timelineWidth = (int) a.getDimension(
                R.styleable.TimeLineView_timelineWidth,
                convertDIP2PX(context, 1));
        marginTop = (int) a.getDimension(
                R.styleable.TimeLineView_timelineMarginTop,
                convertDIP2PX(context, 50));
        a.recycle();
    
        mPaint = new Paint();
        mPaint.setAntiAlias(true);
    
        Resources res = getResources();
        bitmapHead = BitmapFactory.decodeResource(res,
                R.drawable.icon_logistics);
    
    }
    
    /**
     * 画出Bitmap
     * 
     * @param canvas
     * @param src
     * @param dst
     * @param bitmap
     */
    private void drawBitmap(Canvas canvas, Rect src, Rect dst, Bitmap bitmap) {
        dst = (dst == null ? new Rect(0, 0, bitmap.getWidth(),
                bitmap.getHeight()) : dst);
        Paint paint = new Paint();
        // canvas.drawBitmap(bitmap, src, dst, paint);
        canvas.drawBitmap(bitmap, viewWidth - (bitmap.getWidth() / 2),
                timelineHeadRadius + marginTop - (bitmap.getHeight() / 2) - 10,
                paint);
    }
    
    @Override
    protected void onDraw(Canvas canvas) {
        // 默认设置时间轴的位置位于view的中间
        viewWidth = getMeasuredWidth() / 2;
        // 设置第一个节点的颜色
        // mPaint.setColor(timelineHeadColor);
        /**
         * 根据时间轴的节点数目,画对应的节点和轴
         */
        for (int j = 1; j <= timelineCount; j++) {
    
            /**
             * 当j==1,画第一个节点的时候,有点特殊,我们需要在节点的外面再换一个圆环
             */
            if (j == 1) {
                Rect dstRect = new Rect();
                drawBitmap(canvas, null, null, bitmapHead);
    
                // 画笔设置为空心
                // canvas.drawCircle(viewWidth, timelineHeadRadius + marginTop,
                // timelineRadius, mPaint);
                // mPaint.setStyle(Paint.Style.STROKE);
                // mPaint.setStrokeWidth(5.0f);
                // //画第一个节点外围的圆环
                // canvas.drawCircle(viewWidth, timelineHeadRadius + marginTop,
                // timelineHeadRadius, mPaint);
                // 设置画笔颜色,画其他时间节点的颜色
                mPaint.setColor(timelineOtherColor);
                // 画笔设置为实心
                mPaint.setStyle(Paint.Style.FILL);
                /**
                 * 画第一个节点下面的轴
                 */
                canvas.drawRect(new Rect(viewWidth - timelineWidth / 2,
                        (int) (2 * timelineHeadRadius + marginTop) + 5,
                        viewWidth + timelineWidth / 2, (int) (2
                                * timelineHeadRadius + timelineRadiusDistance
                                + marginTop + 5)), mPaint);
                continue;
            }
            /**
             * 画时间轴的节点,即画圆形 圆心的x都是一样的,view的中间
             * 圆心的y的计算是根据节点的位置来计算的,例如:第一个节点的y是根据第一个节点距离上面的距离加上第一个节点的半径
             * :timelineHeadRadius + marginTop
             * 其余的节点就是在一个节点的y的基础上,加上两倍半径和节点之间的轴的长度*节点数:(2 * timelineRadius +
             * timelineRadiusDistance) * (j - 1) + timelineHeadRadius -
             * timelineRadius + marginTop
             *
             */
            canvas.drawCircle(viewWidth,
                    (2 * timelineRadius + timelineRadiusDistance) * (j - 1) + 2
                            * timelineHeadRadius - timelineRadius + marginTop,
                    timelineRadius, mPaint);
            /**
             *   画其余的轴 left:每个轴距离左边距离都是一样的   时间轴的中心位置-1/2的时间轴的宽度 viewWidth -
             * timelineWidth / 2 top: (int) (j * (2 * timelineRadius +
             * timelineRadiusDistance) - timelineRadiusDistance + 2 *
             * (timelineHeadRadius-timelineRadius)+ marginTop) 
             * right:每个轴距离右边距离都是一样的   时间轴的中心位置+1/2的时间轴的宽度 viewWidth +
             * timelineWidth / 2 bottom: (int) (j * (2 * timelineRadius +
             * timelineRadiusDistance) + 2 *
             * (timelineHeadRadius-timelineRadius)+ marginTop)
             */
    
            if (j < timelineCount) {
                canvas.drawRect(
                        new Rect(
                                viewWidth - timelineWidth / 2,
                                (int) (j
                                        * (2 * timelineRadius + timelineRadiusDistance)
                                        - timelineRadiusDistance + 2
                                        * (timelineHeadRadius - timelineRadius) + marginTop),
                                viewWidth + timelineWidth / 2,
                                (int) (j
                                        * (2 * timelineRadius + timelineRadiusDistance)
                                        + 2
                                        * (timelineHeadRadius - timelineRadius) + marginTop)),
                        mPaint);
            }
    
        }
    }
    
    public float getTimelineHeadRadius() {
        return timelineHeadRadius;
    }
    
    public void setTimelineHeadRadius(float timelineHeadRadius) {
    
        this.timelineHeadRadius = timelineHeadRadius;
        invalidate();
    }
    
    // public int getTimelineHeadColor() {
    // return timelineHeadColor;
    // }
    //
    // public void setTimelineHeadColor(int timelineHeadColor) {
    //
    // this.timelineHeadColor = timelineHeadColor;
    // invalidate();
    // }
    
    public int getTimelineOtherColor() {
        return timelineOtherColor;
    }
    
    public void setTimelineOtherColor(int timelineOtherColor) {
        this.timelineOtherColor = timelineOtherColor;
        invalidate();
    }
    
    public int getTimelineCount() {
        return timelineCount;
    }
    
    public void setTimelineCount(int timelineCount) {
        this.timelineCount = timelineCount;
        invalidate();
    }
    
    public int getMarginTop() {
        return marginTop;
    }
    
    public void setMarginTop(int marginTop) {
    
        this.marginTop = marginTop;
        invalidate();
    }
    
    public int getTimelineRadius() {
        return timelineRadius;
    }
    
    public void setTimelineRadius(int timelineRadius) {
    
        this.timelineRadius = timelineRadius;
        invalidate();
    }
    
    public int getTimelineRadiusDistance() {
        return timelineRadiusDistance;
    }
    
    public void setTimelineRadiusDistance(int timelineRadiusDistance) {
    
        this.timelineRadiusDistance = timelineRadiusDistance;
        invalidate();
    }
    
    public int getTimelineWidth() {
        return timelineWidth;
    }
    
    public void setTimelineWidth(int timelineWidth) {
        this.timelineWidth = timelineWidth;
    }
    
    public float getTimeLineViewHeight() {
        this.timeLineViewHeight = getMarginTop() + getTimelineCount()
                * (2 * getTimelineRadius() + getTimelineRadiusDistance());
        return timeLineViewHeight;
    }
    
    public void setTimeLineViewHeight(float timeLineViewHeight) {
        this.timeLineViewHeight = timeLineViewHeight;
        invalidate();
    
    }
    
    public int getViewWidth() {
        return viewWidth;
    }
    
    public void setViewWidth(int viewWidth) {
        this.viewWidth = viewWidth;
        invalidate();
    }
    
    /**
     * 转换dip为px
     */
    public static int convertDIP2PX(Context context, int dip) {
        float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dip * scale + 0.5f * (dip >= 0 ? 1 : -1));
    }
    

    }`

    里面写了一些详细的方法等很好用的,其中的bitmapHead是我们项目需求需要的一个头结点,这些是我在原来的基础上自己添加的,通过 
    private void drawBitmap(Canvas canvas, Rect src, Rect dst, Bitmap bitmap) { 
    dst = (dst == null ? new Rect(0, 0, bitmap.getWidth(), 
    bitmap.getHeight()) : dst); 
    Paint paint = new Paint(); 
    // canvas.drawBitmap(bitmap, src, dst, paint); 
    canvas.drawBitmap(bitmap, viewWidth - (bitmap.getWidth() / 2), 
    timelineHeadRadius + marginTop - (bitmap.getHeight() / 2) - 10, 
    paint); 
    }
     
    画自己的头结点,也就是第一个点。

    实现我们的需求需要左边布局是自定义的View,右边用一个listview。

    http://download.csdn.net/detail/u014007519/9454830这是我的demo地址可以下载下看一看,如果有什么问题可以联系

    展开全文
  • 仿Path的界面,里面有path的弧形菜单和时间轴控件.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • leaflet时间轴控件数据过多显示不全 timelineItems属性数组是时间轴节点 如果超出屏幕大小数据就会显示不全, 如何才能实现可以左右拖动整条时间轴, 或者选中点在中间,可以左右进行拖动。请大佬指教。。 还有一个...

    leaflet时间轴控件数据过多显示不全

    timelineItems属性数组是时间轴节点在这片描述
    如果超出屏幕大小数据就会显示不全,
    在这里插入图片描述
    如何才能实现可以左右拖动整条时间轴, 或者选中点在中间,可以左右进行拖动。请大佬指教。。

    还有一个问题,现在初始化时间轴后是在数组第一个节点的位置处,如何可以定位到数组最后一个节点的位置。

    展开全文
  • 都昌时间轴控件完全用C#开发,性能卓越,能显示百万数据点。具有足够的能力显示从出生到死亡的所有的医疗及健康档案数据。 这里展示了使用都昌时间轴控件(DCTimeLine)的显示效果。 这个展示了各个阶段的数据集成。...

     

    都昌时间轴控件完全用C#开发,性能卓越,能显示百万数据点。具有足够的能力显示从出生到死亡的所有的医疗及健康档案数据。

    这里展示了使用都昌时间轴控件(DCTimeLine)的显示效果。

    这个展示了各个阶段的数据集成。包含门诊、血透、社区、住院、手麻的数据。其中数据区域是可以展开和收缩的。比如第二个血透区域的内容和第一个血透是类似的,但它是收缩的,这样能节约展示空间。

    这张图片用于展示围术期中的相关数据,红色区域表示手术。可以看到都昌时间轴可以临时调整时间刻度的单位。并能将护理数据和手麻数据无缝集成起来。

    展示手术排程结果,淡绿色部分是已经开始或者完成的手术,红色为病人死亡的手术,灰色为正在排队中的手术。
    用户点击手术色块,控件能触发一个事件,应用程序编程响应事件显示对应手术的详细信息。
    本控件仅仅用于展示已有的手术排程结果,不管手术排程过程。具体如何排程请咨询其他人士。

     

     

    其他应用


    诚邀各位专家点评,提出建议,以帮助我们持续改进,不断进步。
    我们产品网站 www.dcwriter.cn,联系邮箱 28348092@qq.com

    转载于:https://www.cnblogs.com/xdesigner/p/dctimeline.html

    展开全文
  • 时间线.Wpf WPF 时间轴控件完全由 WPF 构建。 我接受了下面的控制,并为它添加了我自己的耀斑和功能。 我将大部分控制和代码归功于下面的项目。
  • Android时间轴控件-WheelView

    千次阅读 2018-11-16 11:26:03
    因此,我们就需要重新自定义scrollview,,也就是移动端常用的时间轴控件:WheelView 实现方式直接上代码: public class WheelView extends ScrollView { public static final String TAG = WheelView.class.getSi....

    在做时间轴或者某些类型的选择时,有时候设计师会给我们出类似下面的效果:
    在这里插入图片描述
    因此,我们就需要重新自定义scrollview,,也就是移动端常用的时间轴控件:WheelView

    实现方式直接上代码:

    public class WheelView extends ScrollView {
        public static final String TAG = WheelView.class.getSimpleName();
    
        public static class OnWheelViewListener {
            public void onSelected(int selectedIndex, String item) {
            }
        }
    
    
        private Context context;
    //    private ScrollView scrollView;
    
        private LinearLayout views;
    
        public WheelView(Context context) {
            super(context);
            init(context);
        }
    
        public WheelView(Context context, AttributeSet attrs) {
            super(context, attrs);
            init(context);
        }
    
        public WheelView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            init(context);
        }
    
        //    String[] items;
        List<String> items;
    
        private List<String> getItems() {
            return items;
        }
    
        public void setItems(List<String> list) {
            if (null == items) {
                items = new ArrayList<String>();
            }
            items.clear();
            items.addAll(list);
    
            // 前面和后面补全
            for (int i = 0; i < offset; i++) {
                items.add(0, "");
                items.add("");
            }
            initData();
        }
    
    
        // 每页显示的数量
        public static final int OFF_SET_DEFAULT = 1;
        int offset = OFF_SET_DEFAULT; // 偏移量(需要在最前面和最后面补全)
    
        int displayItemCount;
        int selectedIndex = 1; //
        int itemHeight = 0;//每个条目的高度
        int textSize = 20;//每个条目的字体大小
    
        public int getOffset() {
            return offset;
        }
    
        public void setOffset(int offset) {
            this.offset = offset;
        }
    
        public void setTextSize(int textSize) {
            this.textSize = textSize;
        }
    
        private void init(Context context) {
            this.context = context;
    
    //        scrollView = ((ScrollView)this.getParent());
    //        Log.d(TAG, "scrollview: " + scrollView);
            Log.d(TAG, "parent: " + this.getParent());
    //        this.setOrientation(VERTICAL);
            this.setVerticalScrollBarEnabled(false);
    
            views = new LinearLayout(context);
            views.setOrientation(LinearLayout.VERTICAL);
            this.addView(views);
    
            scrollerTask = new Runnable() {
    
                public void run() {
    
                    int newY = getScrollY();
                    if (initialY - newY == 0) { // stopped
                        final int remainder = initialY % itemHeight;
                        final int divided = initialY / itemHeight;
    //                    Log.d(TAG, "initialY: " + initialY);
    //                    Log.d(TAG, "remainder: " + remainder + ", divided: " + divided);
                        if (remainder == 0) {
                            selectedIndex = divided + offset;
    
                            onSeletedCallBack();
                        } else {
                            if (remainder > itemHeight / 2) {
                                WheelView.this.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        WheelView.this.smoothScrollTo(0, initialY - remainder + itemHeight);
                                        selectedIndex = divided + offset + 1;
                                        onSeletedCallBack();
                                    }
                                });
                            } else {
                                WheelView.this.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        WheelView.this.smoothScrollTo(0, initialY - remainder);
                                        selectedIndex = divided + offset;
                                        onSeletedCallBack();
                                    }
                                });
                            }
    
    
                        }
    
    
                    } else {
                        initialY = getScrollY();
                        WheelView.this.postDelayed(scrollerTask, newCheck);
                    }
                }
            };
    
    
        }
    
        int initialY;
    
        Runnable scrollerTask;
        int newCheck = 50;
    
        public void startScrollerTask() {
    
            initialY = getScrollY();
            this.postDelayed(scrollerTask, newCheck);
        }
    
        private void initData() {
            displayItemCount = offset * 2 + 1;
    
            for (String item : items) {
                views.addView(createView(item));
            }
    
            refreshItemView(0);
        }
    
        private TextView createView(String item) {
            TextView tv = new TextView(context);
            tv.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
            tv.setSingleLine(true);
            tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, textSize);
            tv.setText(item);
            tv.setGravity(Gravity.CENTER);
            int padding = dip2px(15);
            tv.setPadding(padding, padding, padding, padding);
            if (0 == itemHeight) {
                itemHeight = getViewMeasuredHeight(tv);
                Log.d(TAG, "itemHeight: " + itemHeight);
                views.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, itemHeight * displayItemCount));
                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) this.getLayoutParams();
                this.setLayoutParams(new LinearLayout.LayoutParams(lp.width, itemHeight * displayItemCount));
            }
            return tv;
        }
    
    
        @Override
        protected void onScrollChanged(int l, int t, int oldl, int oldt) {
            super.onScrollChanged(l, t, oldl, oldt);
    
    //        Log.d(TAG, "l: " + l + ", t: " + t + ", oldl: " + oldl + ", oldt: " + oldt);
    
    //        try {
    //            Field field = ScrollView.class.getDeclaredField("mScroller");
    //            field.setAccessible(true);
    //            OverScroller mScroller = (OverScroller) field.get(this);
    //
    //
    //            if(mScroller.isFinished()){
    //                Log.d(TAG, "isFinished...");
    //            }
    //
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    
    
            refreshItemView(t);
    
            if (t > oldt) {
    //            Log.d(TAG, "向下滚动");
                scrollDirection = SCROLL_DIRECTION_DOWN;
            } else {
    //            Log.d(TAG, "向上滚动");
                scrollDirection = SCROLL_DIRECTION_UP;
    
            }
        }
    
        private void refreshItemView(int y) {
            int position = y / itemHeight + offset;
            int remainder = y % itemHeight;
            int divided = y / itemHeight;
    
            if (remainder == 0) {
                position = divided + offset;
            } else {
                if (remainder > itemHeight / 2) {
                    position = divided + offset + 1;
                }
    
    //            if(remainder > itemHeight / 2){
    //                if(scrollDirection == SCROLL_DIRECTION_DOWN){
    //                    position = divided + offset;
    //                    Log.d(TAG, ">down...position: " + position);
    //                }else if(scrollDirection == SCROLL_DIRECTION_UP){
    //                    position = divided + offset + 1;
    //                    Log.d(TAG, ">up...position: " + position);
    //                }
    //            }else{
                    position = y / itemHeight + offset;
    //                if(scrollDirection == SCROLL_DIRECTION_DOWN){
    //                    position = divided + offset;
    //                    Log.d(TAG, "<down...position: " + position);
    //                }else if(scrollDirection == SCROLL_DIRECTION_UP){
    //                    position = divided + offset + 1;
    //                    Log.d(TAG, "<up...position: " + position);
    //                }
    //            }
    //        }
    
    //        if(scrollDirection == SCROLL_DIRECTION_DOWN){
    //            position = divided + offset;
    //        }else if(scrollDirection == SCROLL_DIRECTION_UP){
    //            position = divided + offset + 1;
            }
    
            int childSize = views.getChildCount();
            for (int i = 0; i < childSize; i++) {
                TextView itemView = (TextView) views.getChildAt(i);
                if (null == itemView) {
                    return;
                }
                if (position == i) {
                    itemView.setTextColor(checkTextColor);
                } else {
                    itemView.setTextColor(nocheckTextColor);
                }
            }
        }
    
        int checkTextColor = Color.parseColor("#0288ce");
        int nocheckTextColor = Color.parseColor("#bbbbbb");
    
        //设置选中的字体颜色
        public void setCheckTextColor(String checkTextColor) {
            this.checkTextColor = Color.parseColor(checkTextColor);
        }
    
        public void setCheckTextColor(int checkTextColor) {
            this.checkTextColor = checkTextColor;
        }
    
        //设置未选中的字体颜色
        public void setNocheckTextColor(String nocheckTextColor) {
            this.nocheckTextColor = Color.parseColor(nocheckTextColor);
        }
    
        public void setNocheckTextColor(int nocheckTextColor) {
            this.nocheckTextColor = nocheckTextColor;
        }
    
        /**
         * 获取选中区域的边界
         */
        int[] selectedAreaBorder;
    
        private int[] obtainSelectedAreaBorder() {
            if (null == selectedAreaBorder) {
                selectedAreaBorder = new int[2];
                selectedAreaBorder[0] = itemHeight * offset;
                selectedAreaBorder[1] = itemHeight * (offset + 1);
            }
            return selectedAreaBorder;
        }
    
    
        private int scrollDirection = -1;
        private static final int SCROLL_DIRECTION_UP = 0;
        private static final int SCROLL_DIRECTION_DOWN = 1;
    
        Paint paint;
        int viewWidth;
    
        @Override
        public void setBackgroundDrawable(Drawable background) {
    
            if (viewWidth == 0) {
                viewWidth = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();
                Log.d(TAG, "viewWidth: " + viewWidth);
            }
    
            if (null == paint) {
                paint = new Paint();
                paint.setColor(Color.parseColor("#83cde6"));
                paint.setStrokeWidth(dip2px(1f));
            }
    
            background = new Drawable() {
                @Override
                public void draw(Canvas canvas) {
                    canvas.drawLine(viewWidth * 1 / 6, obtainSelectedAreaBorder()[0], viewWidth * 5 / 6, obtainSelectedAreaBorder()[0], paint);
                    canvas.drawLine(viewWidth * 1 / 6, obtainSelectedAreaBorder()[1], viewWidth * 5 / 6, obtainSelectedAreaBorder()[1], paint);
                }
    
                @Override
                public void setAlpha(int alpha) {
    
                }
    
                @Override
                public void setColorFilter(ColorFilter cf) {
    
                }
    
                @SuppressLint("WrongConstant")
                @Override
                public int getOpacity() {
                    return 0;
                }
            };
    
            super.setBackgroundDrawable(background);
        }
    
        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            super.onSizeChanged(w, h, oldw, oldh);
            Log.d(TAG, "w: " + w + ", h: " + h + ", oldw: " + oldw + ", oldh: " + oldh);
            viewWidth = w;
            setBackgroundDrawable(null);
        }
    
        /**
         * 选中回调
         */
        private void onSeletedCallBack() {
            if (null != onWheelViewListener) {
                onWheelViewListener.onSelected(selectedIndex, items.get(selectedIndex));
            }
    
        }
    
        public void setSeletion(int position) {
            final int p = position;
            selectedIndex = p + offset;
            this.post(new Runnable() {
                @Override
                public void run() {
                    WheelView.this.smoothScrollTo(0, p * itemHeight);
                }
            });
    
        }
    
        public String getSeletedItem() {
            return items.get(selectedIndex);
        }
    
        public int getSeletedIndex() {
            return selectedIndex - offset;
        }
    
    
        @Override
        public void fling(int velocityY) {
            super.fling(velocityY / 3);
        }
    
        @Override
        public boolean onTouchEvent(MotionEvent ev) {
            if (ev.getAction() == MotionEvent.ACTION_UP) {
    
                startScrollerTask();
            }
            return super.onTouchEvent(ev);
        }
    
        private OnWheelViewListener onWheelViewListener;
    
        public OnWheelViewListener getOnWheelViewListener() {
            return onWheelViewListener;
        }
    
        public void setOnWheelViewListener(OnWheelViewListener onWheelViewListener) {
            this.onWheelViewListener = onWheelViewListener;
        }
    
        private int dip2px(float dpValue) {
            final float scale = context.getResources().getDisplayMetrics().density;
            return (int) (dpValue * scale + 0.5f);
        }
    
        private int getViewMeasuredHeight(View view) {
            int width = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
            int expandSpec = View.MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, View.MeasureSpec.AT_MOST);
            view.measure(width, expandSpec);
            return view.getMeasuredHeight();
        }
    
    }
    

    外面设置属性和传数据的使用方式如下:

    val layout_wheelview = findViewById<WheelView>(R.id.layout_wheelview).apply {
               //设置选中的字体颜色
                setCheckTextColor(Color.BLACK)
                //设置条目字体大小
                setTextSize(18)
                //设置列表数据
                setItems(listContent)
                //添加滑动监听
                onWheelViewListener = object : WheelView.OnWheelViewListener() {
                    override fun onSelected(selectedIndex: Int, item: String) {
                    }
                }
            }
    

    外面获取当前选中的条目:

    layout_wheelview.seletedIndex
    
    展开全文
  • 从CStatic类派生的一个CTimebar类,具体功能查看CTimebar.h文件
  • 自定义控件开发,时间范围选择控制,用于视频播放的时间段选择,开发者可进行二次开发,开发语言C#,框架.net framework
  • Android UI组合控件------自定义时间轴控件

    千次阅读 热门讨论 2013-04-17 11:49:40
    最近由于项目需要,需要自定义时间轴控件,废话不多说,直接上图: 控件特点: 1. 宽度高度可自行设定,各个时间点间的间距会自动拉长或缩短。(控件自身有最小长度和最小宽度,小于这个范围就无法拉长或...
  • 时间轴控件TimeLineView的实现

    千次阅读 2016-12-08 21:43:07
    android中经常会用到时间轴,那么如何实现时间轴呢?首先我们了解时间轴的构成 (1)时间球 (2)直线 (3)位置 下面介绍一个时间轴实现的开源代码:https://github.com/newhope1106/TimeLineView 把这几个问题解决再掌握...
  • 求助:winform中的时间轴控件

    千次阅读 2013-10-30 11:07:19
    求助:winform中的时间轴控件 我现在做的项目遇到一个需求,就是有没有类似的控件: 我要实现的功能是:播放录像。 某个时间段内假如有2个录像,这个坐标表示的是时间,假如我现在拖动时间轴,拖到第一个录像...
  • 用于视频的时间轴控件 安装 npm install --save react-timeline-bar 用法 import React from ' react ' import Timeline from ' react-timeline-bar ' import ' react-timeline-bar/dist/index.css ' const Example ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,826
精华内容 32,730
关键字:

时间线控件