private void OnMouseUpSB (object sender, MouseEventArgs e)
    		{
			ClearDirty ();

			if (Enabled == false)
				return;

    			timer.Enabled = false;
    			if (thumb_moving != ThumbMoving.None) {
				DirtyThumbArea ();
    				thumb_moving = ThumbMoving.None;
    			}

			if (firstbutton_pressed) {
				firstbutton_state = ButtonState.Normal;
				if (first_arrow_area.Contains (e.X, e.Y)) {
					SmallDecrement ();
				}
				SendWMScroll(ScrollBarCommands.SB_LINEUP);
				firstbutton_pressed = false;
				Dirty (first_arrow_area);
			} else if (secondbutton_pressed) {
				secondbutton_state = ButtonState.Normal;
				if (second_arrow_area.Contains (e.X, e.Y)) {
					SmallIncrement ();
				}
				SendWMScroll(ScrollBarCommands.SB_LINEDOWN);
				Dirty (second_arrow_area);
				secondbutton_pressed = false;
			} else if (thumb_pressed == true) {
				OnScroll (new ScrollEventArgs (ScrollEventType.ThumbPosition, position));
				OnScroll (new ScrollEventArgs (ScrollEventType.EndScroll, position));
				SendWMScroll(ScrollBarCommands.SB_THUMBPOSITION);
				ThumbPressed = false;
				return;
			}

			InvalidateDirty ();
    		}
		private void OnTimer (Object source, EventArgs e)
		{
			ClearDirty ();

			switch (timer_type) {

			case TimerType.HoldButton:
				SetRepeatButtonTimer ();
				break;

			case TimerType.RepeatButton:
			{
				if ((firstbutton_state & ButtonState.Pushed) == ButtonState.Pushed && position != Minimum) {
					SmallDecrement();
					SendWMScroll(ScrollBarCommands.SB_LINEUP);
				}

				if ((secondbutton_state & ButtonState.Pushed) == ButtonState.Pushed && position != Maximum) {
					SmallIncrement();
					SendWMScroll(ScrollBarCommands.SB_LINEDOWN);
				}

				break;
			}

			case TimerType.HoldThumbArea:
				SetRepeatThumbAreaTimer ();
				break;

			case TimerType.RepeatThumbArea:
			{
				Point pnt, pnt_screen;
				Rectangle thumb_area_screen = thumb_area;

				pnt_screen = PointToScreen (new Point (thumb_area.X, thumb_area.Y));
				thumb_area_screen.X = pnt_screen.X;
				thumb_area_screen.Y = pnt_screen.Y;

				if (thumb_area_screen.Contains (MousePosition) == false) {
					timer.Enabled = false;
					thumb_moving = ThumbMoving.None;
					DirtyThumbArea ();
					InvalidateDirty ();
				}

				pnt = PointToClient (MousePosition);

				if (vert)
					lastclick_pos = pnt.Y;
				else
					lastclick_pos = pnt.X;

				if (thumb_moving == ThumbMoving.Forward) {
					if ((vert && (thumb_pos.Y + thumb_size > lastclick_pos)) ||
					   (!vert && (thumb_pos.X + thumb_size > lastclick_pos)) ||
					   (thumb_area.Contains (pnt) == false)) {
						timer.Enabled = false;
    						thumb_moving = ThumbMoving.None;
    						Refresh ();
						return;
					} else {
						LargeIncrement ();
						SendWMScroll(ScrollBarCommands.SB_PAGEDOWN);
					}
				} else {
					if ((vert && (thumb_pos.Y < lastclick_pos)) ||
					   (!vert && (thumb_pos.X  < lastclick_pos))){
						timer.Enabled = false;
						thumb_moving = ThumbMoving.None;
						SendWMScroll(ScrollBarCommands.SB_PAGEUP);
						Refresh ();
					} else {
						LargeDecrement ();
						SendWMScroll(ScrollBarCommands.SB_PAGEUP);
					}
				}

				break;
			}
			default:
				break;
			}

			InvalidateDirty ();
		}
    		private void OnMouseDownSB (object sender, MouseEventArgs e)
    		{
			ClearDirty ();

			if (Enabled == false || (e.Button & MouseButtons.Left) == 0)
				return;

    			if (firstbutton_state != ButtonState.Inactive && first_arrow_area.Contains (e.X, e.Y)) {
				SendWMScroll(ScrollBarCommands.SB_LINEUP);
				firstbutton_state = ButtonState.Pushed;
				firstbutton_pressed = true;
				Invalidate (first_arrow_area);
				Update();
				if (!timer.Enabled) {
					SetHoldButtonClickTimer ();
					timer.Enabled = true;
				}
			}

			if (secondbutton_state != ButtonState.Inactive && second_arrow_area.Contains (e.X, e.Y)) {
				SendWMScroll(ScrollBarCommands.SB_LINEDOWN);
				secondbutton_state = ButtonState.Pushed;
				secondbutton_pressed = true;
				Invalidate (second_arrow_area);
				Update();
				if (!timer.Enabled) {
					SetHoldButtonClickTimer ();
					timer.Enabled = true;
				}
			}

			if (thumb_size > 0 && thumb_pos.Contains (e.X, e.Y)) {
				ThumbPressed = true;
				SendWMScroll(ScrollBarCommands.SB_THUMBTRACK);
				if (vert) {
					thumbclick_offset = e.Y - thumb_pos.Y;
					lastclick_pos = e.Y;
				}
				else {
					thumbclick_offset = e.X - thumb_pos.X;
					lastclick_pos = e.X;
				}
			} else {
				if (thumb_size > 0 && thumb_area.Contains (e.X, e.Y)) {

					if (vert) {
						lastclick_pos = e.Y;

						if (e.Y > thumb_pos.Y + thumb_pos.Height) {
							SendWMScroll(ScrollBarCommands.SB_PAGEDOWN);
							LargeIncrement ();
							thumb_moving = ThumbMoving.Forward;
							Dirty (new Rectangle (0, thumb_pos.Y + thumb_pos.Height,
										      ClientRectangle.Width,
										      ClientRectangle.Height -	(thumb_pos.Y + thumb_pos.Height) -
										      scrollbutton_height));
						} else {
							SendWMScroll(ScrollBarCommands.SB_PAGEUP);
							LargeDecrement ();
							thumb_moving = ThumbMoving.Backwards;
							Dirty (new Rectangle (0,  scrollbutton_height,
										      ClientRectangle.Width,
										      thumb_pos.Y - scrollbutton_height));
						}
					} else {

						lastclick_pos = e.X;

						if (e.X > thumb_pos.X + thumb_pos.Width) {
							SendWMScroll(ScrollBarCommands.SB_PAGEDOWN);
							thumb_moving = ThumbMoving.Forward;
							LargeIncrement ();
							Dirty (new Rectangle (thumb_pos.X + thumb_pos.Width, 0,
										      ClientRectangle.Width -  (thumb_pos.X + thumb_pos.Width) -
										      scrollbutton_width,
										      ClientRectangle.Height));
						} else {
							SendWMScroll(ScrollBarCommands.SB_PAGEUP);
							thumb_moving = ThumbMoving.Backwards;
							LargeDecrement ();
							Dirty (new Rectangle (scrollbutton_width,  0,
										      thumb_pos.X - scrollbutton_width,
										      ClientRectangle.Height));
						}
					}

					SetHoldThumbAreaTimer ();
					timer.Enabled = true;
					InvalidateDirty ();
				}
			}
    		}