Hello!
I'm trying to improve GuideGuide's​ handling of Illustrator guides. So far I haven't found a built-in way to add guides, so I draw a path and then set it's guides value to true. While this works, it has the drawback that I have to figure out the boundary locations of the guides in addition to where I want to place them.
For my example, I'm using a horizontal guide.
Looking at how Illustrator handles things, it appears to add guides at the max left and max right bounds of the document. Mind you, it's possible to place objects even farther beyond those bounds, but they're the bounds that Illustrator visually shows. This is the behavior I'm trying to emulate.
So far I haven't found a scripted way to extract those boundaries from Illustrator, but my testing has thus far shown that the document max height and width is 16383pts. One would think that it would be as simple as placing a guide edge at 0 and 16383, however the document origin appears to be in the center. One would then think that (16383/2) * -1 would be the document edge, but this also does not turn out to be true. So far, in my testing the document origin is fluid, sometimes in the center, sometimes offset. I tried incorporating the document pageOrigin, but that has also not proven to be helpful. I'm even taking into account the artboard/document coordinate system differences and have found no obvious solution yet.
Am I missing some obvious details that can be used to pull these values from Illustrator? This seems like something that would be relatively easy to do.
 2016-09-13 09-04-36.png)
1 Correct answer
Only tested with CS6 but it works, no matter artboards been resized or not.
...var d = activeDocument,
rect,
rects = [],
abs = d.artboards,
z = d.views[0].zoom,
cp = d.views[0].centerPoint,
i;
abs.add([0, 1, 1, 0]);
abs.add([0, 1, 1, 0]);
for (i = abs.length - 3; i >= 0; i--) {
rects.push([abs.artboardRect, abs.name]);
abs.remove();
}
d.rearrangeArtboards(DocumentArtboardLayout.Row, 1, 0, false);
rect = abs[0].artboardRect;
d.pathItems.rectangle(rect[1] - 0.5 + 16383 / 2, rect[0] +
Explore related tutorials & articles
38
Replies
UI in illustrator uses local coordinate system (Artboard Rulers). Scriping uses global coordinate system (Global Rulers). Also the cartesian system used in both differs. UI uses a modified one, 90° CW rotated. Scripting uses the actual one. See the difference in the quadrants.
Max document area is 16383 (2^14 - 1), as you pointed out. So, if you were to resize your artboard and make it as large as this, you'd assume (0,0) would be the center of the artboard. Wrong. For some reason, there's an offset. Center of the artboard would be (306.5, -396.5).
If you want to add a horizontal guide using the top left of the artboard as the origin, first you need to get the artboard's global position using "artboard.artboardRect". Try the following code. Create a document. Resize and reposition the artboard however you want, and then run the script. It'll add two guides that intersect at the center of the artboard. Guides' width and length equal to max document size (16383).
function calcRect(rectArray) {
var rect = {
topLeft : {
x : rectArray[0],
y : rectArray[1],
},
bottomRight : {
x : rectArray[2],
y : rectArray[3],
},
};
rect.width = Math.abs(rect.bottomRight.x - rect.topLeft.x);
rect.height = Math.abs(rect.bottomRight.y - rect.topLeft.y);
rect.center = [
rect.topLeft.x + (rect.width / 2),
rect.topLeft.y - (rect.height / 2)
];
return rect;
}
var document = app.activeDocument;
var boardRect = calcRect(document.artboards[0].artboardRect);
var horizontal = document.pathItems.add();
horizontal.setEntirePath([ [-7885, boardRect.center[1]], [8498, boardRect.center[1]] ]);
horizontal.guides = true;
var vertical = document.pathItems.add();
vertical.setEntirePath([ [boardRect.center[0], 7795], [boardRect.center[0], -8588] ]);
vertical.guides = true;
Hi Silly-V​ and cameronmcefee​,
give this snippet a try:
// RectangleMaxPasteboardBounds.jsx
// ArtboardMaxPasteboard2.jsx
// try to create a rectangle with the max. pasteboard bounds
// regards pixxxelschubser Sept. 2016
if (app.activeDocument) {
var aDoc = app.activeDocument;
var ABR = aDoc.artboards[0].artboardRect;
var total = Math.pow (2, 14)-1;
var topLeft = Math.ceil (-total/2);
var maxAB = new Array();
maxAB.centerX = (ABR[2].toFixed(5)-ABR[0].toFixed(5))/2;
maxAB.centerY = (ABR[3].toFixed(5)-ABR[1].toFixed(5))/2;
var xSubstr = (maxAB.centerX < 0) ? Math.floor(maxAB.centerX) : Math.ceil(maxAB.centerX);
var ySubstr = (maxAB.centerY < 0) ? Math.floor(maxAB.centerY) : Math.ceil(maxAB.centerY);
maxAB[0] = topLeft+xSubstr;
maxAB[1] = -topLeft+ySubstr;
var Rect = aDoc.pathItems.rectangle(maxAB[1], maxAB[0], total, total, false);
Rect.stroked = false;
Rect.filled = false;
Rect.selected = true;
alert("Rectangle created");
} else { alert ("no open document"); }
Have fun
All good, but still - if someone does change their global rulers then you're blind with no way out 
I wonder if I can really make a dive and try to mess with the SDK to make a very simple educational .aip plugin whose sole purpose is to report the pasteboard coordinates. All these years and I have not yet made this climb - maybe it's time to start!
Math.pow(2, 14) - 1 yields 16383 which is the max size of the document. I've pointed that out in my answer ((2^14) -1). I've used that instead of 16383, because one might think 16383 is just some random value. It's not. Almost all software uses powers of two for space. Also I think this value is absolute. There is no need to calculate it. However, the origin changes. There's an offset. As Silly-V​ pointed out, this offset depends on the document profile.
When you create a document, the artboard is placed at (0,0) using its top left as the reference point. This would look like this:
The origin is the center of the document area and the artboard is at (0,0). All quadrants are equal in area. But this is not what actually happens. In the above image, the artboard isn't centered in the document area. Illustrator centers the artboard in the document area. To do that, coordinate system needs to be shifted by half the size of the artboard. The artboard is in the quadrant 4, and its opposite quadrant is 2, so the shift happens from quadrant 4 to 2. This would look like this:
See the quadrant sizes have changed, the origin shifted, and the artboard is centered in the document area. To understand this better, imagine the max document size as a viewport. The actual space is infinite, but you can look at this space from a limited viewport (16383 x 16383). When you add a document, the artboard is placed at (0,0) and it is not centered in the viewport, because viewport is focused at (0,0). Illustrator wants to focus on the artboard, not at the origin. So it moves the viewport from (0,0) to the center of the artboard. Thus the offset is always the half size of the artboard.
So, to sum it up, max document size is absolute and always is 16383 x 16383. Offset is not absolute. Do not use fixed values. Calculate it.
AdChoices
