mmsplit.pas

一套及时通讯的原码

begin
   inherited MouseDown(Button,Shift,X,Y);

   if not FFixed and (FSizeControl <> nil) and (Button = mbLeft) then
   begin
      aRect := Parent.ClientRect;
      case Align of
           alTop,
           alBottom: InflateRect(aRect,0,-FSplitterSize);
           alLeft,
           alRight : InflateRect(aRect,-FSplitterSize,0);
      end;
      MapWindowPoints(Parent.Handle,0,aRect,2);

      if FAutoControl then
      for i := 0 to Parent.ControlCount-1 do
      begin
         Win := TWinControl(Parent.Controls[i]);
         if (Win is TWinControl) and (Win.Align = Align) then
         case Align of
           alTop   : if Win.Top>Top then dec(aRect.Bottom,Win.Height);
           alBottom: if Win.Top+Win.Height<Top+Height then inc(aRect.Top,Win.Height);
           alLeft  : if Win.Left>Left then dec(aRect.Right,Win.Width);
           alRight : if Win.Left+Win.Width<Left+Width then inc(aRect.Left,Win.Width);
         end;
      end;

      ScreenBounds := SizeControl.BoundsRect;
      MapWindowPoints(Parent.Handle,0,ScreenBounds,2);

      with ScreenBounds do
      case Align of
           alTop   : begin
                        aRect.Top := Top+FMinOffset;
                        aRect.Bottom := aRect.Bottom-FMaxOffset;
                     end;
           alBottom: begin
                        aRect.Bottom := Bottom-FMaxOffset;
                        aRect.Top := aRect.Top+FMinOffset;
                     end;
           alLeft  : begin
                        aRect.Left := Left+FMinOffset;
                        aRect.Right := aRect.Right-FMaxOffset;
                     end;
           alRight : begin
                        aRect.Right := Right-FMaxOffset;
                        aRect.Left := aRect.Left+FMinOffset;
                     end;
      end;

      FOrigin := Point(X,Y);
      FOffset := Point(X,Y);

      ClipCursor(@aRect);
      BeginSizing(BoundsRect);

      if assigned(FOnSplitBegin) then FOnSplitBegin(Self);
   end;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.MouseMove(Shift: TShiftState; X, Y: Integer);
var
   aRect : TRect;
   G: integer;

begin
   inherited MouseMove(Shift,X,Y);

   if not FFixed and (FSizeControl <> nil) and (ssLeft in Shift) then
   begin
      G := Max(FGrid,1);
      aRect := BoundsRect;
      case Align of
        alTop,
        alBottom:
        begin
           OffsetRect(aRect,0,FOffset.Y-FOrigin.Y);
           DrawSizeRect(aRect);
           OffsetRect(aRect,0,(Y-FOffset.Y)div G*G);
           FOffset := Point(X,((Y-FOffset.Y)div G*G)+FOffset.Y);
           DrawSizeRect(aRect);
        end;
        alLeft,
        alRight:
        begin
           OffsetRect(aRect,FOffset.X-FOrigin.X,0);
           DrawSizeRect(aRect);
           OffsetRect(aRect,(X-FOffset.X)div G*G,0);
           FOffset := Point(((X-FOffset.X)div G*G)+FOffset.X,Y);
           DrawSizeRect(aRect);
        end;
      end;

      if Assigned(FOnSplit) then FOnSplit(Self,Shift,X,Y);
   end;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
   aRect: TRect;
   G: integer;

begin
   inherited MouseUp(Button,Shift,X,Y);

   if not FFixed and (FSizeControl <> nil) and (Button = mbLeft) then
   begin
      G := Max(FGrid,1);
      aRect := BoundsRect;
      case Align of
        alTop,
        alBottom: OffsetRect(aRect,0,FOffset.Y-FOrigin.Y);
        alLeft,
        alRight: OffsetRect(aRect,FOffset.X-FOrigin.X,0);
      end;

      EndSizing(aRect);

      aRect := FSizeControl.BoundsRect;
      case Align of
        alTop   : inc(aRect.Bottom,(Y-FOrigin.Y)div G*G);
        alBottom: inc(aRect.Top,(Y-FOrigin.Y)div G*G);
        alLeft  : inc(aRect.Right,(X-FOrigin.X)div G*G);
        alRight : inc(aRect.Left,(X-FOrigin.X)div G*G);
      end;

      inc(FUpdate);
      FSizeControl.BoundsRect := aRect;
      dec(FUpdate);

      if assigned(FOnSplitEnd) then FOnSplitEnd(Self);
   end;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.SetGrid(aValue: integer);
begin
   if (aValue <> FGrid) then
   begin
      FGrid := Max(aValue,0);
   end;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.SetSplitterSize(aValue: integer);
begin
   if (aValue <> FSplitterSize) and (aValue > 0) then
   begin
      FSplitterSize := aValue;
      inc(FUpdate);
      SetSizeControl(FSizeControl);
      dec(FUpdate);
   end;
   {$IFDEF WIN32}
   {$IFDEF TRIAL}
   {$DEFINE _HACK1}
   {$I MMHACK.INC}
   {$ENDIF}
   {$ENDIF}
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.UpdateCursor;
begin
   if not FFixed then
      Cursor := FCursor
   else
      Cursor := crDefault;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.SetFixed(aValue: Boolean);
begin
   if (aValue <> FFixed) then
   begin
      FFixed := aValue;
      UpdateCursor;
   end;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.SetSizeControl(aValue: TWinControl);
begin
   if (aValue = nil) then
   begin
      FSizeControl := nil;
      Align := alNone;
      FCursor := crDefault;
      UpdateCursor;
      exit;
   end;

   {$IFDEF WIN32}
   {$IFDEF TRIAL}
   {$DEFINE _HACK2}
   {$I MMHACK.INC}
   {$ENDIF}
   {$ENDIF}

   if (aValue.Align = alNone) or (aValue.Align = alClient) then
   begin
      SetSizeControl(nil);
      raise Exception.Create('Splitter: Control''s align must be left, right, top or bottom');
   end;
   inc(FUpdate);
   Align := aValue.Align;

   case aValue.Align of
         alTop: begin
                   FCursor := crsVSplit;
                   Top := aValue.Top+aValue.Height;
                   Height := FSplitterSize;
                end;
      alBottom: begin
                   FCursor := crsVSplit;
                   Top := aValue.Top-FSplitterSize;
                   Height := FSplitterSize;
                end;
        alLeft: begin
                   FCursor := crsHSplit;
                   Left := aValue.Left+aValue.Width;
                   Width := FSplitterSize;
                end;
       alRight: begin
                   FCursor := crsHSplit;
                   Left := aValue.Left-FSplitterSize;
                   Width := FSplitterSize;
                end;
   end;

   dec(FUpdate);
   FSizeControl := aValue;
   UpdateCursor;
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.Notification(AComponent: TComponent; Operation: TOperation);
begin
   if (Operation = opRemove) and (AComponent = FSizeControl) then
       SetSizeControl(nil);

   inherited Notification(AComponent,Operation);
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.WMSize(var Msg);
begin
   inherited;

   if FUpdate = 0 then SetSizeControl(FSizeControl);
end;

{-- TMMSplitter ---------------------------------------------------------}
procedure TMMSplitter.WMMove(var Msg);
begin
   inherited;

   if FUpdate = 0 then SetSizeControl(FSizeControl);
end;

end.