The main difference is that the resizeObject of some of my nodes doesn’t take all the area.
There are some other parts which are not resizable. Such as the label, and some other things. It’s basically a rectangle inside another rectangle.
I am trying to figure out a way to prevent the overflow of the container. Not only the resizableObject.
I end up with complex calculations that initially store the difference between the resizeObject and the outer container.
const aoab = this.adornedObject.part.actualBounds.copy();
const roab = this.adornedObject.part.resizeObject.part.actualBounds.copy();
// Store this somewhere
const topLeftSize = new go.Size(Math.abs(aoab.x - roab.x), Math.abs(aoab.y - roab.y));
// Same for the other 3 points: topRight, bottomLeft, bottomRight
Then in computeResize, I use these values to calculate the outer rectangle dimension.
That works well, until I rotate the nodes. I end up spending few days for nothing so far. Basically nothing work as expected whatever I try.
Note: In my use case, the problem occurs only when resizing the nodes inside a group. For group resize it works as expected since I don’t support rotation and it was pretty much like the code snippet in the example.
I believe that the code I wrote is not working when rotating because I am using the actualBounds. That won’t help much when rotating the Node.
Instead, I need to get the local points of the resizeObject inside the container.
The thing is, in most cases, the container is not the direct parent of the resizeObject. Usualy there are different Panels in between. So I am not sure how can I get the local points regardless of the angle value.
If I get these values, I could probably use them later to get the accurate points that I am looking for. Something like:
Yes, you need to use GraphObject.getDocumentPoint. But I’m curious when you are calling it. You might need to call Part.ensureBounds so that the bounds of every visible element in the node is up-to-date if you are depending on the bounds of objects during a tool operation while you are modifying them. If that doesn’t help, don’t call it.
Just to be clear, you have rotated the member nodes of the group, not the group itself, correct? It should then be the case that the actualBounds will be the orthogonal rectangle that encompasses the rotated GraphObject. See for example: GoJS Shapes -- Northwoods Software
I believe that the design of the custom ResizingTool was that the user would be resizing the whole Node. So I think you want to try using the node’s future bounds rather just the size and position (in document coordinates!) of newRect.
One problem is that in general one cannot know what size the node will be when an element of it changes size. The easiest solution is to change the size and then call Node.ensureBounds so that you can look at the value of Node.actualBounds. However, that is not done by the computeResize method – it is only done by the resize method using the result of the computeResize method.
However you might be able to make some assumptions about the node template(s) that the user will be resizing. In the example of your codesandbox, it appears that the Node height will always be larger than the panel height of resized element by the height of the blue square. So your code could just add that before calling _checkNodeIntersections or whatever.
If the element is not at angle == zero, you’ll need to compute the rotated width and height of the element and use that in your calculations for the future size of the whole Node.