How to get bounds of largest possible document area?

So far all of the examples are susceptible to the artboard resize issue with the exception of o-marat's version. That one works well, but unfortunately I'm not thrilled about the flash of UI that comes with it. The search continues…

I use this:

/**
 * Adobe ExtendScript for Illustrator CS4+
 * (c)Marat Shagiev
 * m_js@bk.ru
 * 04.12.2016
 * */
//@target illustrator
try {
  getWorkAreaBnds();
} catch (e) {}
/**
 * get the Illustrator's Document work area maximal bounds
 * work in document with multiple artboards, shifted center and selected objects
 *
 * this method using:
 * * copy-past max-size-rectangle (16383*16383 pt)
 * * the Document.view properties (zoom, centerPoint, screenMode)
 *
 * @return{Array} workAreaBnds - Illustrator's Document work area maximal bounds
 * */
function getWorkAreaBnds() {
  var sel = _deselAll();
  var WORK_AREA_SIZE  = 16383,
      d               = activeDocument,
      rect            = d.pathItems.rectangle(0, 0, WORK_AREA_SIZE, WORK_AREA_SIZE),
      workAreaBnds,
      screenModeStore = d.views[0].screenMode,
      zoomStore       = d.views[0].zoom,
      centerPntStore  = d.views[0].centerPoint;
  rect.stroked  = false;
  rect.selected = true;
  cut();
  d.views[0].screenMode = ScreenMode.FULLSCREEN;
  d.views[0].zoom       = 64;
  d.views[0].zoom       = 0.0313;
  paste();
  rect         = selection[0];
  workAreaBnds = rect.geometricBounds;
  rect.remove();
  d.views[0].zoom        = zoomStore;
  d.views[0].screenMode  = screenModeStore;
  d.views[0].centerPoint = centerPntStore;
  for (var i = 0; i < sel.length; i++) {
    var item      = sel;
    item.selected = true;
  }
  function _deselAll() {
    var sel = selection;
    for (var i = 0; i < activeDocument.layers.length; i++) {
      activeDocument.layers.hasSelectedArtwork = false;
    }
    return sel;
  }
  return workAreaBnds;
}

Hello all!

You know, when rearrange artboards, it always center them in the Canvas. So I get this.(the sample code only deal with document with one artboard)

var doc = activeDocument,
    rect = doc.artboards[0].artboardRect,
    rect2;
doc.artboards.add([0, 0, 100, -100]);
doc.artboards.add([0, 0, 1, -1]);
doc.artboards[0].remove();
doc.rearrangeArtboards(DocumentArtboardLayout.Row, 1, 0, false);
rect2 = doc.artboards[0].artboardRect;
doc.pathItems.rectangle(rect2[1] - 50 + 16383 / 2 + 24.5, rect2[0] + 50 - 16383 / 2 - 24.5, 16383, 16383).guides = true;
doc.artboards.add(rect);
doc.artboards[0].remove();
doc.artboards[0].remove();

tl;dr: Illustrator bases the measurement on some sort of "original document size" value, not the current artboard size. Does anyone know how to find this value?

Following up here, this code has been running in production for a few months now and hasn't had any origin related issues as feared, however I've discovered a pretty strange quirk. Before I get into the next phase of this discussion, here's the coffeescript that is powering it:

DOC_MEASURE = 16383

pasteboardRect = ->

  artboards = activeDocument.artboards

  i = artboards.getActiveArtboardIndex()

  abRect = artboards.artboardRect

  abWidth = abRect[2] - abRect[0]

  abHeight = abRect[3] - abRect[1]

  topLeft = Math.ceil(-DOC_MEASURE / 2)

  centerX = (abRect[2].toFixed(5) - abRect[0].toFixed(5)) / 2

  centerY = (abRect[3].toFixed(5) - abRect[1].toFixed(5)) / 2

  xSubstr = if centerX < 0 then Math.floor(centerX) else Math.ceil(centerX)

  ySubstr = if centerY < 0 then Math.floor(centerY) else Math.ceil(centerY)

  [

    topLeft + xSubstr   # left

    -topLeft + ySubstr  # top

    -((topLeft + xSubstr) - abWidth)  # right

    -((-topLeft + ySubstr) - abHeight) # bottom

  ]

The idea here is essentially:

1. Get the rect of the artboard

2. Determine the center of the artboard

3. Subtract half of the document width/height from half of the max pasteboard width/height.

This works perfectly… if you don't change the artboard size from the original value. However, if you resize the artboard, it throws the math off. This is not because the math is wrong, it's because the position appears to be tied to *the original artboard size*, not the current artboard size. I've tested this by swapping out the calculations for hard coded measurements based on the original size of the document and the guides go back to lining up.

Does anyone know if there's some store of data in Illustrator documents that record the original size of the document when it was created? One would think that since this is part of the calculation, it would also be part of the APIs, but I've come to always assume the worst.

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.

> (306.5, -396.5) corresponds to half of the default document size (Letter) that is (612,792).

Oh that's interesting. Seems like an odd thing to tie into the positioning, but worth looking into.

> Well this is good, for people who leave their origins alone and don't drag around the document origin (using the square at the intersection of the rulers) - which would be most people, but there are some wanderers of course.

Agreed. Not shown in my personal calculation is a helper that adjusts for ruler offsets. Anyone following this thread would likely want to include their own adjustment.

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;

maybe so:

• previously make a template ai-file with a group of 2 guides (horizontal + vertical)
• [you can even include it into a script as a binary string]
• copy this group to target document
• take geometricBounds of this guides-group...

You know, good question- since an artboard can be moved all around the pasteboard.