号码线压缩和对接控件

Question

Hi Mathmeticians out there.

I am a little stumped and I was wondering if there was any sort of algorithm that could help me.

First the conceptual problem, Lets say I have a bunch of boxes that lie along an X axis. I want to be able to choose an arbitrary point A on the axis and have everything on the left scaled to 95% of its original width and position and to compensate, everything on the right will have to be scaled to 105%. The width of the resulting boxes is easy to calculate since it is the original width times the scale. The problem I am having is how to calculate the gap which has now been created at point A so that I can shift the second part left to close that gap.

Furthermore, I would like to not only select a point A, but also a B and C, etc.. as well and be able to close their gaps likewise.

--The real reason I am asking--

Now for the actual problem (in case anyone else out there has gone through this.) I have a control in a C# Winforms app that was made by some programmer before I got here. The control can contain any number of child controls that each have their own relative coordinates as a percentage of the Width or Height (ie A control with a relative X coordinate of 0.5 will be placed halfway across the parent container.

We desperately need to support multiple monitors and the problem that I am having is that if you dock a control or toolbar next to our proprietary control then the ClientRectangle is smaller so it shifts around the child borders like so

My boss doesn't like that the lines shift over monitor boundaries and wants me to only mess with the lines on the same monitor where the window was docked. I have been able to get 90% of the way using the concept above, but I can't seem to get the re-spacing calculation right.

Answer 1

Here is a Mathematical model of what I think for calculating the gap.

Let's say that you have a starting point A, and lets define it as xA.

Now, let's define the boxes

//Box{x0,x1}
Boxes = {[B1]{0,100},[B2]{100,200},[B3]{200,400},[B4]{400,450},[B5]{450,700}}

Now we have 5 boxes on the X axis.

Let's define;

A = xA = 370;
TotalLength = 700;

If you divide 700 by 2, that makes 350 which makes the mid point, and 370 is bigger than the mid point value. So that is being said, in this case you would need to shift the elements on the left to right. The calculation of the gap is as the following;

IF(Midpoint < A)
    Gap = ((A- Midpoint) * 100 ) / TotalLength //This is the gap in percent
ELSE
    Gap = ((Midpoint - A) * 100) / TotalLength 

This way, you can find the gap. The Axis you need to shift towards will need to be decided based on the point you are selecting, if the selected point less than the Mid point then shift to right, if higher shift to left (to the positive axis route).

I hope this helps.

Answer 2

Thank you for your help Surgeon. Unfortunately I wasn't able to find a solution using your method. On the bright side, I was able to find a solution. The trick was to treat the X coordinate as the width between the Client Rectangle's left edge and the X coordinate's position and calculate it similarly to the child width.

For more specifics, here's the algorithm I have come up with for dealing with the docking problem:

var clientOriginalWidth = what the width of the Client rectangle would be without docks
var clientCompressedWidth = the width of the client now

//Calculate the Compression Ratio for each screen as follows
foreach(var screen in Screens){
  var widthOfClientRectOnScreenNow = how much of the client rectangle is on this screen
  var widthOfClientRectOnScreenWithoutDocks = how much of the client rectangle was on the screen before the docks were there
  var compressionRatio = (widthOfClientRectOnScreenNow / clientCompressedWidth) / 
                     (widthOfClientRectOnScreenWithoutDocks / clientOriginalWidth);

  //Assuming control.xScale and control.widthScale are initially 0
  foreach(var control in ParentControl){
     var controlBounds = where the control was when the client was full width
     if(controlBounds.X > screen.right){
        var percentOfXPositionOnScreen = screen.right - screen.left / control.x;
        controlBounds.xScale += percentOfPositionOnScreen * compressionRatio;
     }
     else if(control.X > screen.left){
       var percentOfXPositionOnScreen = control.x - screen.left / control.x;
       controlBounds.xScale += percentOfPositionOnScreen * compressionRatio;
     }

     if(screen.intersects(controlBounds){
       var percentControlIsOnScreen = what percent of the control's width was on this screen
       control.widthScale += percentControlIsOnScreen * compressionRatio;
     }
  }
}

The position is then found by multiplying the original X coordinate by the scale (same for the width). Once the docks are removed, recalculate the scale. When all docks are removed, the scale should be 1.

I have left out some specifics to make it more of a generalized algorithm, but one should be able to work through this on their own system.