acsbutils.pas

Alpha Controls.v5.46b Source

  GetWindowRect(Handle, R);

  if sw.fLeftScrollbar then begin
    inc(R.Left, sw.cxLeftEdge + integer(sw.sbarVert.fScrollVisible) * GetScrollMetric(sw.sbarVert, SM_CXVERTSB));
    dec(R.Right, sw.cxRightEdge);
  end
  else begin
    inc(R.Left, sw.cxLeftEdge);
    dec(R.Right,sw.cxRightEdge + integer(sw.sbarVert.fScrollVisible) * GetScrollMetric(sw.sbarVert, SM_CXVERTSB));
  end;
  dec(R.Bottom, sw.cyBottomEdge);
  R.Top	:= R.Bottom - integer(sw.sbarHorz.fScrollVisible) * GetScrollMetric(sw.sbarHorz, SM_CYHORZSB);
end;

procedure AC_GetVScrollRect(sw : TacScrollWnd; Handle : hwnd; var R : TRect);
begin
  GetWindowRect(Handle, R);
  inc(R.Top, sw.cyTopEdge);
  dec(R.Bottom, sw.cyBottomEdge + integer(sw.sbarHorz.fScrollVisible) * GetScrollMetric(sw.sbarHorz, SM_CYHORZSB));

  if sw.fLeftScrollbar then begin
    inc(R.Left, sw.cxLeftEdge);
    R.Right := R.Left + integer(sw.sbarVert.fScrollVisible) * GetScrollMetric(sw.sbarVert, SM_CXVERTSB);
  end
  else begin
    dec(R.Right, sw.cxRightEdge);
    R.Left := R.Right - integer(sw.sbarVert.fScrollVisible) * GetScrollMetric(sw.sbarVert, SM_CXVERTSB);
  end;
end;

function Ac_GripVisible(sw : TacScrollWnd; Handle : THandle; R : TRect) : boolean;
var
  parRect : TRect;
  parHandle : hwnd;
begin
  Result := False;
  parHandle := GetParent(Handle);
  if GetParent(parHandle) = 0 then begin
    GetClientRect(parHandle, parRect);
    MapWindowPoints(parHandle, 0, parRect, 2);
    Result := (parHandle = 0) or
      (not sw.fLeftScrollbar and (parRect.right = R.right + sw.cxRightEdge) and (parRect.bottom = R.bottom + sw.cyBottomEdge))
       or (sw.fLeftScrollbar and (parRect.left = R.left - sw.cxLeftEdge) and (parRect.bottom = R.bottom + sw.cyBottomEdge))
  end;
end;

function Ac_NCPaint(sw : TacScrollWnd; Handle : hwnd; wParam : longint; lParam : longint; ThumbPos : integer = -1; aDC : hdc = 0) : longint;
var
  WinRect, R, parRect, R2 : TRect;
  DC : hdc;
  sb : TacScrollBar;
  LeftRight : integer;
  parHandle : hwnd;
  bGrip : TBitmap;
begin
  Result := 0;
  if sw = nil then Exit;
  if sw.SkinData <> nil then begin
    sw.SkinData.Updating := sw.SkinData.Updating;
    if sw.SkinData.Updating then Exit;
    if Assigned(sw.SkinData.FOwnerControl) and ((csCreating in sw.SkinData.FOwnerControl.ControlState) or not TWinControl(sw.SkinData.FOwnerControl).Showing) then Exit;
    if sw.SkinData.BGChanged
      then SendMessage(sw.CtrlHandle, SM_ALPHACMD, MakeWParam(0, AC_PREPARECACHE), 0);
  end;
  GetWindowRect(Handle, WinRect);
  if aDC = 0 then DC := GetWindowDC(Handle) else DC := aDC;
  sb := sw.sBarHorz;
  if sb = nil then Exit;
  if sb.fScrollVisible then begin
    AC_GetHScrollRect(sw, Handle, R);
    OffsetRect(R, -WinRect.Left, -WinRect.Top);
    if uCurrentScrollbar = SB_HORZ
      then Ac_NCDrawHScrollbar(sb, Handle, dc, R, uScrollTimerPortion, ThumbPos)
      else Ac_NCDrawHScrollbar(sb, Handle, dc, R, HTSCROLL_NONE, ThumbPos);
  end;
  sb := sw.sBarVert;
  if sb = nil then Exit;
  if sb.fScrollVisible then begin
    AC_GetVScrollRect(sw, Handle, R);
    OffsetRect(R, -WinRect.Left, -WinRect.Top);
    if uCurrentScrollbar = SB_VERT
      then Ac_NCDrawVScrollbar(sb, Handle, dc, R, uScrollTimerPortion, ThumbPos)
      else Ac_NCDrawVScrollbar(sb, Handle, dc, R, HTSCROLL_NONE, ThumbPos);
  end;      
  if sw.sbarHorz.fScrollVisible and sw.sbarVert.fScrollVisible then begin
    GetWindowRect(Handle, R);
    OffsetRect(R, -winrect.left, -winrect.top);
    dec(R.bottom, sw.cyBottomEdge);
    R.top := R.bottom - GetScrollMetric(sw.sbarHorz, SM_CYHORZSB);

    if sw.fLeftScrollbar then begin
      inc(R.left, sw.cxLeftEdge);
      R.right := R.left + GetScrollMetric(sw.sbarVert, SM_CXVERTSB);
    end
    else begin
      dec(R.right, sw.cxRightEdge);
      R.left := R.right  - GetScrollMetric(sw.sbarVert, SM_CXVERTSB);
    end;
    // Paint dead zone
    parHandle := GetParent(Handle);
    GetClientRect(parHandle, parRect);
    MapWindowPoints(parHandle, 0, parRect, 2);
    Windows.CopyRect(R2, R);
    OffsetRect(R2, winrect.left, winrect.top);
    // Paint BG
    GlobalCacheInfo.Ready := False;
    SendMessage(Handle, SM_ALPHACMD, MakeWParam(0, AC_GETCACHE), 0);
    GlobalCacheInfo.X := 0; GlobalCacheInfo.Y := 0;
    bGrip := CreateBmp24(WidthOf(R), HeightOf(R));
    if GlobalCacheInfo.Ready then begin // If AlphaSkins are fully supported
      BitBlt(bGrip.Canvas.Handle, 0, 0, bGrip.Width, bGrip.Height, GlobalCacheInfo.Bmp.Canvas.Handle, R.Left, R.Top, SRCCOPY);
    end
    else begin
      FillDC(bGrip.Canvas.Handle, Rect(0, 0, bGrip.Width, bGrip.Height), sw.SkinManager.GetActiveEditColor);
    end;
    // Grip if exists
    if Ac_GripVisible(sw, Handle, R2) then begin
      LeftRight := sw.SkinManager.GetMaskIndex(sw.SkinManager.ConstData.IndexGLobalInfo, s_GlobalInfo, s_GripImage);
      if sw.SkinManager.IsValidImgIndex(LeftRight)
        then DrawSkinGlyph(bGrip,
          Point(bGrip.Width - (WidthOf(sw.SkinManager.ma[LeftRight].R) div sw.SkinManager.ma[LeftRight].ImageCount),
                bGrip.Height - (HeightOf(sw.SkinManager.ma[LeftRight].R) div (1 + sw.SkinManager.ma[LeftRight].MaskType))),
                0, 1, sw.SkinManager.ma[LeftRight]);
    end;

    BitBlt(dc, R.Left, R.Top, bGrip.Width, bGrip.Height, bGrip.Canvas.Handle, 0, 0, SRCCOPY);
    FreeAndNil(bGrip);
  end;
  if aDC = 0 then ReleaseDC(Handle, DC);
end;

procedure DrawCenterGlyph(b : TBitmap; m : integer; State : integer; sm : TsSkinManager; R : TRect);
var
  p : TPoint;
  w, h : integer;
begin
  with sm do if IsValidImgIndex(m) then begin
    w := WidthOf(ma[m].R) div ma[m].ImageCount;
    h := HeightOf(ma[m].R) div (1 + ma[m].MaskType);
    p.x := R.Left + (WidthOf(R) - w) div 2;
    p.y := R.Top + (HeightOf(R) - h) div 2;
    DrawSkinGlyph(b, p, State, 1, ma[m]);
  end;
end;

procedure DrawSlider(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp, bRect.Left, bRect.Top);
    PaintItemFast(IndexSliderHorz, MaskSliderHorz, ScrollSliderBGHorz, ScrollSliderBGHotHorz, s_ScrollSliderH, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskSliderGlyphHorz, State, sm, Rect(0, 0, b.Width, b.Height));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

procedure DrawSliderV(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp, bRect.Left, bRect.Top);
    PaintItemFast(IndexSliderVert, MaskSliderVert, ScrollSliderBGVert, ScrollSliderBGHotVert, s_ScrollSliderV, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskSliderGlyphVert, State, sm, Rect(0, 0, b.Width, b.Height));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

procedure DrawBtnTop(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp);
    PaintItemFast(IndexScrollTop, MaskScrollTop, IndexBGScrollTop, IndexBGHotScrollTop, s_ScrollBtnTop, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskArrowTop, State, sm, Rect(0, 0, b.Width, acScrollBtnLength));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

procedure DrawBtnBtm(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp, bRect.Left, bRect.Top);
    PaintItemFast(IndexScrollBottom, MaskScrollBottom, IndexBGScrollBottom, IndexBGHotScrollBottom, s_ScrollBtnBottom, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskArrowBottom, State, sm, Rect(0, b.Height - acScrollBtnLength, b.Width, b.Height));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

procedure DrawBtnLeft(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp);
    PaintItemFast(IndexScrollLeft, MaskScrollLeft, IndexBGScrollLeft, IndexBGHotScrollLeft, s_ScrollBtnLeft, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskArrowLeft, State, sm, Rect(0, 0, acScrollBtnLength, b.Height));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

procedure DrawBtnRight(bRect : TRect; State : integer; Bmp : TBitmap; sm : TsSkinManager);
var
  ci : TCacheInfo;
  b : TBitmap;
begin
  b := CreateBmp24(WidthOf(bRect), HeightOf(bRect));
  with sm.ConstData do begin
    Ci := MakeCacheInfo(Bmp, bRect.Left, bRect.Top);
    PaintItemFast(IndexScrollRight, MaskScrollRight, IndexBGScrollRight, IndexBGHotScrollRight, s_ScrollBtnRight, Ci, True,
      State, Rect(0, 0, b.Width, b.Height), Point(0, 0), b, sm);
    DrawCenterGlyph(b, MaskArrowRight, State, sm, Rect(b.Width - acScrollBtnLength, 0, b.Width, b.Height));
  end;
  BitBlt(Bmp.Canvas.Handle, bRect.Left, bRect.Top, b.Width, b.Height, b.Canvas.Handle, 0, 0, SRCCOPY);
  FreeAndNil(b);
end;

function Ac_NCDrawHScrollbar(sb : TacScrollBar; Handle : hwnd; DC : hdc; R : TRect; uDrawFlags : integer; SliderPos : integer = -1) : integer;
var
  ctrl, thumb : TRect;
  butwidth, scrollwidth, workingwidth, thumbwidth, realthumbsize, thumbpos : integer;
  fMouseOverL, fBarHot, fMouseOverR : boolean;
  Bmp : TBitmap;
  sm : TsSkinManager;
  lbState, rbState, tdiv2 : integer;
  c : TsColor;
  IsEnabled : boolean;
begin
  Result := 0;
  if sb.sw.fThumbTracking then Exit;
  sm := sb.sw.SkinManager;
  if not sb.fScrollVisible or (sm = nil) or not sm.IsValidSkinIndex(sm.ConstData.IndexScrollBar1H) or (WidthOf(R) < 2) then Exit;
  GetScrollInfo(sb.sw.CtrlHandle, sb.nBarType, sb.scrollinfo);

  butwidth := GetScrollMetric(sb, SM_SCROLL_LENGTH, True);
  scrollwidth := R.right - R.left;
  if scrollwidth <= 0 then Exit;
  Result := 1;
  workingwidth := scrollwidth - butwidth * 2;
  GetScrollMetric(sb, SM_SCROLL_LENGTH);
  thumbwidth := 0;
  thumbpos := 0;

  if sb.sw.SkinData.FOwnerControl <> nil
    then IsEnabled := Ac_IsScrollbarActive(sb) and sb.sw.SkinData.FOwnerControl.Enabled
    else IsEnabled := Ac_IsScrollbarActive(sb);
  fBarHot := (sb.nBarType = uMouseOverScrollbar);

  fMouseOverL := (uHitTestPortion = HTSCROLL_LEFT) and fBarHot and IsEnabled and (Handle = hwndCurSB);
  fMouseOverR := (uHitTestPortion = HTSCROLL_RIGHT) and fBarHot and IsEnabled and (Handle = hwndCurSB);

  if Handle <> hwndCurSB then uDrawFlags := HTSCROLL_NONE;
  Ac_CalcThumbSize(sb, R, thumbwidth, thumbpos);
  if SliderPos <> -1 then thumbpos := SliderPos;

  if Handle = hwndCurSB then begin
    if (uDrawFlags = HTSCROLL_LEFT) then lbState := 2 else if fMouseOverL then lbState := 1 else lbState := 0;
    if (uDrawFlags = HTSCROLL_RIGHT) then rbState := 2 else if fMouseOverR then rbState := 1 else rbState := 0
  end
  else begin
    lbState := 0;
    rbState := 0
  end;
  ////////////////////////////
  // Draw the scrollbar now //
  ////////////////////////////
  Bmp := CreateBmp24(WidthOf(R), HeightOf(R));
  SendMessage(Handle, SM_ALPHACMD, MakeWParam(0, AC_GETCACHE), 0);
  if sb.sw is TacMdiWnd then begin
    GetWindowRect(TacMdiWnd(sb.sw).FForm.ClientHandle, thumb);
    GetWindowRect(TacMdiWnd(sb.sw).FForm.Handle, ctrl);
    GlobalCacheInfo.X := thumb.Left - ctrl.Left;
    GlobalCacheInfo.Y := thumb.Top - ctrl.top;
  end
  else begin
    GlobalCacheInfo.X := 0; GlobalCacheInfo.Y := 0;
  end;
  if (scrollwidth > butwidth * 2) then begin
    tdiv2 := thumbpos + thumbwidth div 2 - R.Left;
    PaintItemFast(sm.ConstData.IndexScrollBar1H, sm.ConstData.MaskScrollBar1H, sm.ConstData.BGScrollBar1H, sm.ConstData.BGHotScrollBar1H,
      s_ScrollBar1H, GlobalCacheInfo, True, integer(uDrawFlags = HTSCROLL_PAGELEFT) * 2, Rect(0, 0, tdiv2, Bmp.Height), Point(R.Left, R.Top), Bmp, sm);
    PaintItemFast(sm.ConstData.IndexScrollBar2H, sm.ConstData.MaskScrollBar2H, sm.ConstData.BGScrollBar2H, sm.ConstData.BGHotScrollBar2H,
      s_ScrollBar2H, GlobalCacheInfo, True, integer(uDrawFlags = HTSCROLL_PAGERIGHT) * 2, Rect(tdiv2, 0, Bmp.Width, Bmp.Height), Point(R.Left + tdiv2, R.Top), Bmp, sm);
    // LEFT ARROW
    SetRect(ctrl, R.left, R.top, R.left + butwidth, R.bottom);
    DrawBtnLeft(Rect(0, 0, WidthOf(Ctrl), HeightOf(Ctrl)), lbState, Bmp, sm);
    // RIGHT ARROW
    SetRect(ctrl, R.right - butwidth, R.top, R.right, R.bottom);
    OffsetRect(ctrl, -R.Left, -R.Top);
    DrawBtnRight(ctrl, rbState, Bmp, sm);
    // MIDDLE PORTION
    // Getting real values
    realthumbsize := MulDiv(sb.scrollInfo.nPage, scrollwidth - 2 * butwidth, sb.scrollInfo.nMax - sb.scrollInfo.nMin);
    if realthumbsize < sb.nMinThumbSize then realthumbsize := sb.nMinThumbSize;

    if IsEnabled and (realthumbsize > 0) and (realthumbsize <= workingWidth) then begin
      // Draw the THUMB finally
      SetRect(thumb, thumbpos, R.top, thumbpos + thumbwidth{realthumbsize}, R.bottom);
      OffsetRect(thumb, -R.Left, -R.Top);
      DrawSlider(thumb, integer((uHitTestPortion = HTSCROLL_THUMB) and fBarHot and IsEnabled and (Handle = hwndCurSB)), Bmp, sm);
    end;
  end
  //not enough room for the scrollbar, so just draw the buttons (scaled in size to fit)
  else begin
    butWidth := Bmp.width div 2;
    PaintItemFast(sm.ConstData.IndexScrollBar1H, sm.ConstData.MaskScrollBar1H, sm.ConstData.BGScrollBar1H, sm.ConstData.BGHotScrollBar1H,
      s_S