就为long类型属性，写了个水平滚动条。

public partial public partial class HScrollbar : UserControl
{
public HScrollbar()
{
InitializeComponent();
SetStyle(ControlStyles.ResizeRedraw, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
MouseLeave += HScrollbar_MouseLeave;
}

#region 属性
public long Maximum = 0;

#endregion

public long BarOffset = 0;

public event System.Windows.Forms.ScrollEventHandler Scroll;

private bool IsShowBar = true;

private void HScrollbar_Paint(object sender, PaintEventArgs e)
{
AutoSize(Width, Height, ref IsShowBar);
Graphics g = e.Graphics;
g.Clear(Color.White);
SmoothingMode sm = g.SmoothingMode;
g.SmoothingMode = SmoothingMode.HighQuality;

g.FillRectangle(new SolidBrush(ColorBackground), rectBackground.Rectangle);

if (IsShowBar)
{
DrawBar(g);
}
g.FillRectangle(new SolidBrush(GetColorButtonBackgrond(rectLeft, IsBegin)), rectLeft.Rectangle);
g.FillRectangle(new SolidBrush(GetColorButtonBackgrond(rectRight, IsEnd)), rectRight.Rectangle);
DrawLeftArrow(g, GetColorArrow(true));
DrawRightArrow(g, GetColorArrow(false));
g.SmoothingMode = sm;
}

private bool IsBegin
{
get
{
long begin = 0;
bool bRet = begin == BarOffset;
return bRet;
}
}

private bool IsEnd
{
get
{
long end = (long)(MaxBarWidth - rectBar.Width);
bool bRet = end == BarOffset;
return bRet;
}
}

private Color GetColorArrow(bool isLeft)
{
if (IsShowBar && !IsBegin && isLeft && enumHitObject == EnumHitObject.HO_Left)
{
return ColorArrowButtonDown;
}

if (IsShowBar && !IsEnd && !isLeft && enumHitObject == EnumHitObject.HO_Right)
{
return ColorArrowButtonDown;
}
return ColorArrow;
}

private Color GetColorButtonBackgrond(Rect2 rect, bool stopFlag)
{
if (IsShowBar && !stopFlag && !IsMouseLevel && rect.Rectangle.Contains(PointMouse))
{
return ColorButtonMoveOn;
}
else
{
return ColorBackground;
}
}
private int SpaceWidth = 3;
private void AutoSize(int barWidth, int barHeight, ref bool showBar)
{
showBar = false;
int rectWidth = 12 + SpaceWidth;
//
rectBackground.Left = 0;
rectBackground.Top = 0;
rectBackground.Width = barWidth;
rectBackground.Height = barHeight;
//
rectLeft.Left = 0;
rectLeft.Top = 0;
rectLeft.Width = rectWidth;
rectLeft.Height = barHeight;
//
rectRight.Left = Right - rectWidth;
rectRight.Width = rectWidth;
rectRight.Top = 0;
rectRight.Height = barHeight;
//
rectCetner.Top = 0;
rectCetner.Height = barHeight;
rectCetner.Left = rectLeft.Right;
rectCetner.Width = rectRight.Left - rectCetner.Left;

double maxBarWidth = MaxBarWidth;
if (BarOffset > Maximum)
BarOffset = Maximum;
if (maxBarWidth > 0 && Maximum > maxBarWidth)
{
showBar = true;
}
double movemax = Maximum - rectBackground.Width;
float width = 20;
if (movemax >= 0 && movemax < maxBarWidth)
{
width = (float)(maxBarWidth - movemax);
}
float left = rectLeft.Right + PaddingBar + BarOffset;//(float)((double)Value / (double)Maximum * (rectBackground.Width));

rectBar.Top = Top + PaddingBar;
rectBar.Left = left;
rectBar.Width = width;
rectBar.Height = barHeight - 2 * PaddingBar - 1;
}

private Rect2 rectLeft = new Rect2();
private Rect2 rectRight = new Rect2();
private Rect2 rectCetner = new Rect2();
private Rect2 rectBackground = new Rect2();
private Rect2 rectBar = new Rect2();

private int PaddingBar = 2;
private int PaddingArrowX = 4;
private int PaddingArrowY = 4;
//配色
private Color ColorArrow = Color.FromArgb(163, 163, 163);
private Color ColorArrowButtonDown = Color.White;
private Color ColorBackground = Color.FromArgb(241, 241, 241);
private Color ColorButtonMoveOn = Color.FromArgb(210, 210, 210);
private Color ColorButtonDown = Color.FromArgb(120, 120, 120);
private Color ColorBar = Color.FromArgb(170, 170, 171);
private Color ColorBarButtonDown = Color.FromArgb(141, 141, 142);
private Color ColorBarBorder = Color.FromArgb(154, 154, 154);
private Brush brDebug = new SolidBrush(Color.Red);

private double MaxBarWidth
{
get
{
double maxBarWidth = rectBackground.Width - 2 * PaddingBar - rectLeft.Width - rectRight.Width;
return maxBarWidth;
}
}
private void DrawLeftArrow(Graphics g, Color color)
{
Rect2 rectArrow = new Rect2();
rectLeft.Copy(ref rectArrow);
rectArrow.InflateRect(-PaddingArrowX, -PaddingArrowY);
rectArrow.Height -= 1;
PointF pt0 = rectArrow.TopRight;
PointF pt1 = rectArrow.BottomRight;
PointF pt2 = rectArrow.LeftCenter;
pt0.X -= SpaceWidth;
pt1.X -= SpaceWidth;
GraphicsPath gPath = new GraphicsPath();
gPath.AddLine(pt0, pt1);
gPath.AddLine(pt1, pt2);
gPath.AddLine(pt2, pt0);

g.FillPath(new SolidBrush(color), gPath);

}

private void DrawRightArrow(Graphics g, Color color)
{
Rect2 rectArrow = new Rect2();
rectRight.Copy(ref rectArrow);
rectArrow.InflateRect(-PaddingArrowX, -PaddingArrowY);
rectArrow.Height -= 1;
//g.FillRectangle(brDebug, rectArrow.Rectangle);
PointF pt0 = rectArrow.TopLeft;
PointF pt1 = rectArrow.BottomLeft;
PointF pt2 = rectArrow.RightCenter;
pt0.X += SpaceWidth;
pt1.X += SpaceWidth;
GraphicsPath gPath = new GraphicsPath();
gPath.AddLine(pt0, pt1);
gPath.AddLine(pt1, pt2);
gPath.AddLine(pt2, pt0);
g.FillPath(new SolidBrush(color), gPath);
}

private void DrawBar(Graphics g)
{
g.FillRectangle(new SolidBrush(GetColorBar()), rectBar.Rectangle);
g.DrawRectangle(new Pen(new SolidBrush(ColorBarBorder)), rectBar.Rectangle);
}
private Color GetColorBar()
{
if (enumHitObject == EnumHitObject.HO_Bar)
{
return ColorBarButtonDown;
}
else
{
return ColorBar;
}
}
private enum EnumHitObject
{
HO_None,
HO_Left,
HO_Right,
HO_Bar,
HO_BarSpace
}

private EnumHitObject enumHitObject = EnumHitObject.HO_None;

private EnumHitObject HitTest(Point pointMouse)
{
EnumHitObject ho = EnumHitObject.HO_None;
if (rectLeft.Rectangle.Contains(pointMouse))
{
ho = EnumHitObject.HO_Left;
}
else if (rectRight.Rectangle.Contains(pointMouse))
{
ho = EnumHitObject.HO_Right;
}
else if (rectBar.Rectangle.Contains(pointMouse))
{
ho = EnumHitObject.HO_Bar;
}
else if (rectBackground.Rectangle.Contains(pointMouse))
{
ho = EnumHitObject.HO_BarSpace;
}
return ho;
}

private DateTime LButtonDownTime = DateTime.Now;
private Point LButtonDownMousePoint = new Point();
private void HScrollbar_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
Point ptMouse = new Point(e.X, e.Y);
enumHitObject = HitTest(ptMouse);
LButtonDownMousePoint.X = e.X;
LButtonDownMousePoint.Y = e.Y;
LButtonDownTime = DateTime.Now;
switch (enumHitObject)
{
case EnumHitObject.HO_BarSpace:
{
SetBarOffset(e.X);
}
break;
}
}
}

private void SetBarOffset(long screenPixcel)
{
screenPixcel = (long)(screenPixcel - rectLeft.Right - PaddingBar);

if (screenPixcel <= 0)
{
screenPixcel = 0;
}
if (screenPixcel >= (MaxBarWidth - rectBar.Width))
{
screenPixcel = (long)(MaxBarWidth - rectBar.Width);
}
BarOffset = screenPixcel;
}

private Point PointMouse = new Point();

private bool IsMouseLevel = true;

private void HScrollbar_MouseLeave(object sender, EventArgs e)
{
IsMouseLevel = true;
}
private void HScrollbar_MouseMove(object sender, MouseEventArgs e)
{
PointMouse.X = e.X;
PointMouse.Y = e.Y;
IsMouseLevel = false;

if (enumHitObject == EnumHitObject.HO_Bar
|| enumHitObject == EnumHitObject.HO_BarSpace && e.Button == System.Windows.Forms.MouseButtons.Left)
{
SetBarOffset(e.X);
Debug();
}
}

pri
bd85
vate void HScrollbar_MouseUp(object sender, MouseEventArgs e)
{
enumHitObject = EnumHitObject.HO_None;
}

private void timer1_Tick(object sender, EventArgs e)
{
long step = Maximum / 20;
double ms = (DateTime.Now - LButtonDownTime).TotalMilliseconds;
if (ms > 200)
{
step = Maximum / 10;
}
long newValue = Value;
if (enumHitObject == EnumHitObject.HO_Left)
{
newValue -= step;
Value = newValue;
}
else if (enumHitObject == EnumHitObject.HO_Right)
{
newValue += step;
Value = newValue;
}
Invalidate();
}

public int SliderWidth//滑块宽度
{
get
{
return (int)rectBar.Width;
}
}

private double MaxValue
{
get
{
double maxValue = (double)(Maximum - rectBackground.Width);
if (maxValue < 0)
maxValue = 0;
return maxValue;
}
}

public long Value
{
get
{
double maxPixcel = (double)(MaxBarWidth - rectBar.Width);
double maxValue = MaxValue;
//像素转值
long value = (long)((double)BarOffset * maxValue / maxPixcel + 0.5d);
return value;
}
set
{
double maxPixcel = (double)(MaxBarWidth - rectBar.Width);
double maxValue = MaxValue;
double v = value;
if (v < 0)
{
v = 0;
}
if (v > maxValue && maxValue >= 0)
v = maxValue;
//值转像素
BarOffset = (long)(v * maxPixcel / maxValue + 0.5d);
if (BarOffset < 0)
BarOffset = 0;
Debug();
}
}

private void Debug()
{
System.Console.WriteLine(string.Format("Begin:{0},End:{1}", Value, Value + rectBackground.Width));
}

private int PrevWidth = 0;
private int PrevHeight = 0;

private void HScrollbar_Resize(object sender, EventArgs e)
{

bool isShowbar = false;
AutoSize(PrevWidth, PrevHeight, ref isShowbar);
double prevMaxBarWidth = MaxBarWidth - rectBar.Width;
AutoSize(Width, Height, ref isShowbar);
double maxBarWidth = MaxBarWidth - rectBar.Width;

double xscale = BarOffset / (double)prevMaxBarWidth;

double screenPixcel = xscale * maxBarWidth + rectLeft.Right + PaddingBar;
if (double.IsNaN(screenPixcel))
{
SetBarOffset(0);
}
else
{
SetBarOffset((long)screenPixcel);
}

PrevWidth = Width;
PrevHeight = Height;
Debug();
}

}

public class Rect2
{
public float Left = 0;
public float Width = 0;
public float Top = 0;
public float Height = 0;

public Rect2()
{

}

public static void TestDraw(Graphics g, RectangleF rect)
{
g.FillRectangle(new SolidBrush(Color.Gray), rect);
}

public Rect2(float Left, float Top, float Width, float Height)
{
this.Left = Left;
this.Width = Width;
this.Top = Top;
this.Height = Height;
}

#region 点
public float Right
{
get
{
return Left + Width;
}
}

public float Bottom
{
get
{
return Top + Height;
}
}

public PointF TopLeft
{
get
{
PointF pt = new PointF(Left, Top);
return pt;
}
}

public PointF TopRight
{
get
{
PointF pt = new PointF(Right, Top);
return pt;
}
}

public PointF BottomLeft
{
get
{
PointF pt = new PointF(Left, Bottom);
return pt;
}
}

public PointF BottomRight
{
get
{
PointF pt = new PointF(Right, Bottom);
return pt;
}
}

public PointF Center
{
get
{
PointF pt = new PointF(Left + Width / 2.0f, Top + Height / 2.0f);
return pt;
}
}

public PointF LeftCenter
{
get
{
PointF pt = new PointF(Left, Top + Height / 2.0f);
return pt;
}
}

public PointF RightCenter
{
get
{
PointF pt = new PointF(Right, Top + Height / 2.0f);
return pt;
}
}

public PointF TopCenter
{
get
{
PointF pt = new PointF(Left + Width / 2.0f, Top);
return pt;
}
}

public PointF BottomCenter
{
get
{
PointF pt = new PointF(Left + Width / 2.0f, Bottom);
return pt;
}
}

public RectangleF RectangleF
{
get
{
RectangleF rect = new RectangleF(Left, Top, Width, Height);
return rect;
}
}

public Rectangle Rectangle
{
get
{
Rectangle rect = new Rectangle((int)Left, (int)Top, (int)Width, (int)Height);
return rect;
}
}

public void Set(RectangleF rect)
{
this.Left = rect.X;
this.Width = rect.Width;
this.Top = rect.Y;
this.Height = rect.Height;
}

public void InflateRect(float x, float y)
{
Left -= x;
Width += 2 * x;
Top -= y;
Height += 2 * y;
}

public void Copy(ref Rect2 rect)
{
rect.Left = Left;
rect.Top = Top;
rect.Width = Width;
rect.Height = Height;
}

#endregion

#region 计算矩形位置
public enum EnumPosition
{
EnumPosition_Center,
EnumPosition_LeftCenter,
EnumPosition_RightCenter,
EnumPosition_TopCenter,
EnumPosition_BottomCenter
}

public static Rect2 Postion(PointF point, SizeF sz, EnumPosition enumPostion)
{
Rect2 rect = new Rect2();
switch (enumPostion)
{
case EnumPosition.EnumPosition_LeftCenter:
rect = new Rect2(point.X - sz.Width, point.Y - sz.Height / 2.0f, sz.Width, sz.Height);
break;
case EnumPosition.EnumPosition_RightCenter:
rect = new Rect2(point.X, point.Y - sz.Height / 2.0f, sz.Width, sz.Height);
break;
case EnumPosition.EnumPosition_TopCenter:
rect = new Rect2(point.X - sz.Width / 2.0f, point.Y - sz.Height, sz.Width, sz.Height);
break;
case EnumPosition.EnumPosition_BottomCenter:
rect = new Rect2(point.X - sz.Width / 2.0f, point.Y, sz.Width, sz.Height);
break;
case EnumPosition.EnumPosition_Center:
rect = new Rect2(point.X - sz.Width / 2.0f, point.Y - sz.Height / 2.0f, sz.Width, sz.Height);
break;

}
return rect;
}

#endregion
}