Forums

i Thiyagu,

you are quite inspired by doing manual work.... (this is quite good to learn, but too complicated in production)

You don't have to "select" the items you want to group.

Selection is (and should be) rarely used in scipting!

First of all IMHO the error (which you could have written in your message as well, so we can identifiy problems better) when grouping is that a group has to be bound to a page instead of a document.

So you will have to iterate through the pages and then group pageItems on each page! (otherwise you also cannot make a different move on different pages!)

//------------------------------------

var doc=app.activeDocument;

for (i=0; i<doc.pages.count; i++) {

  thisPage = doc.pages[i];

  items1 = thisPage.PageItems;

  if ( thisPage.PageItems.length> 1 )    
  { 

    myMovingItem = thisPage.groups.add(thisPage.PageItems);

  } else {

    myMovingItem = thisPage.PageItems.firstItem();

  }

     [... move your "myMovingItem" here !!! and ungroup the group if you want...]

}

//------------------------------------

(Code is written by memory and NOT TESTED !)

Greetings,

Marc

From the OMV:

void move ([to: {Array of 2 Units | Spread | Page | Layer} ][, by: Array of Measurement Unit
(Number or String)=any])

As you can see, Marc sets the first argument (to) to undefined, and the 2nd to the distance, in an array of 2 units.

The sign stuff is needed in case the zero point of your document is inbetween spreads (and what a dirty trick this is, I'm tempted to copy it as my own! ). On left pages it will be -1, on right pages +1.

The variable dx is a global value (Marc: would it be possible to put this in the declaration, as "function( dx, dy)"?). The second value in the array is set to 0, and that's where you would put the y distance. The y distance does not need any special sign handling as it always will move down with a positive value.

thiyagus5 wrote:

 

Can you please explain the below syntax just i want to understand the things.

 

Object.prototype.offsetX = function()
    {
    /* 1 */ if (this.parent.constructor != Page) return;
    /* 2 */ var sgn = 1 - 2*(this.parent.documentOffset%2);
    /* 3 */ this.move(undefined,['' + sgn*dx + u,0]);
    }

 

First, I prototype an offsetX method at the Object level, so everything is supposed to be offset-able. That makes things easier, because we don't know a priori what kind of items we will have to move: the Object method will ‘catch’ anything from the syntax <anyPageItem>.offsetX()

In the body of the function, line 1, I ignore the object (this) if it is not a page child item, because your goal is to move only page items. Ideally, we should also test if the object can move :

/* 1bis */ if (! (move in this) ) return;

Line 2, I need to get the sign of the x-move according to the even/odd parity of the page index in the document (this.parent.documentOffset). Here I supposed that the document was structured by facing pages (2-pages spreads). The point is that N%2 returns 0 if N is an even number, 1 if it is an odd number (% is the modulo operator). Then, I use the transformation  X -> 1 - 2X  returning +1 if X=0 and -1 if X = 1. That's the sign of the translation.

var sgn = 1 - 2 * (this.parent.documentOffset % 2 );

Finally, line 3, we apply the sign to dx and we make the move! (Note that you may use a negative dx if you need to reverse the process.)

Regards,

Marc

Harbs. wrote:

 

Yes, the sign stuff is a nice trick, but it'll fail miserably on a 

right bound document, so I'd avoid standardizing this trick (unless of 

course you'd put in a pageBinding condition)...

 

I totally agree with you. This script is not to be standardized, it's just a proposal. There are many other circumstances where it will fail miserably.

I was just trying to answer a specific question.

@+

Marc

Hi Marc,

I understood that. My response was to Jong; not to your solution per se.

FWIW, if you want to make that work with right-bound docs, this should 

do the trick:

Object.prototype.offsetXY = function(/*int*/dx, /*int*/dy)
      {
      *if* (this.parent.constructor != Page) return;
      var sgn = this.parent.side == PageSideOptions.LEFT_HAND ? -1 : 1;
      this.move(undefined,['' + sgn*dx + u, '' + dy + unit]);
      }

Harbs

No, that wouldn't work [a]. I misplaced a parenthesis, which may well be critical, as it should change the precendence of the operators! I meant to say

sign = (obj.parent.index & 1) ? 1 : -1;

so the (obj.parent.index & 1) gets evaluated first. I'm not sure at all it even works without the parentheses ...

In your example, it still would do something, but only the first page would be correct :-) The ?..: operator is shorthand for a full if .. then .. else expression; the value "0", for the first page, evaluates to 'false', and any other value (for all other pages) evaluate to 'true'.

[a] Your expression, I meant. Harbs' snidely side shows I didn't really memorize the OMV from first page to last -- first time I've ever heard of that!

Did I miss something?

Eh. From the OMV:

"The index of the Page within its containing object." Actually, I was assuming this would be the index of the page in the document? I never thought a Page parent could be a Spread (and yes, the OMV tells me it is a Spread).

(1 min later) Okay, you are so right about this. This script

alert (app.activeDocument.layoutWindows[0].activePage.index);

shows nothing but 0 and 1. And that's for a regular document -- I imagine I'd get higher values for those combined to side-by-sides by dragging in the pages panel.

I'm pretty sure I used it at least once my way, but then again -- hey, it works (for a normal book).

Let's not confuse poor Thiyagu any further

It's pretty. What is it?

(I'm joking -- of course I know, it's the schematics of my Intel(R) Core(TM)2 Duo CPU!)

Jokes aside, you made that by hand? (Sweet.) Perhaps you could use the parent/child hierarchies in my version of the OMV Help to update it?