Illustrator CC compared to CS

When I draw a rectangle  to represent a wall in a house in CC it has four anchor points where as in CS it has it has eight anchor points. To change the length of the wall in CC I have to select two anchor points using the "Direct Selection Tool" and then drag compaired to in CS I just click on the center anchor point on one end of the wall and drag. Am I missing something or is this the way it is in CC. CS way is much simplier.

E1,
What you drag at in CS is actually the middle of that side of the Bounding Box.
If that is missing in CC you may drag horizontalle/vertically at one of the corner points.

Similar Messages

  • Illustrator CS4 compare type size to actual

    When I set the type size from the drop down box it measures on the screen and prints out smaller than the size I want. ie 50mm type is 34mm actual, the bounding box however is the type size 50mm. As a sign writer this causes a problem as customers order type of a particular size and when printed it is much smaller. I appreciate that I can create outlines and enlarge the size accordingly however I would have expected the type size to be the same as in the drop down type box.
    thanks Andrew

    You might want to take a look at my AI Javascript script named JET_SetCapHeight.jsx, which can be downloaded
    here
    JET

  • Interface Illustrator / Oracle (or comparable database)

    We handle a big amount of huge Illustrator-Files. Some of our drawings have a size of 3.5 x 4.5 meters and contain several hundredthousand objects. We are looking for an interface to store this data on a server and to allow workgroups to load just a part of the drawing, to modify it and to save it back to the server.
    We are cartographers. But to make it a bit more clear just imagine an architect drawing a skyscraper with Illustrator in one big file. Imagine this architect would like to allow one workgroup to make changes in the drawing of the the basement and at the same time one workgroup makes changes to the drawing of the penthouse.
    There are interfaces available to connect AutoCAD or ArchiCAD-Files to Oracle. We are looking for an interface to connect Illustrator to Oracle (or something comparable).
    Kind regards,
    Tim Kober
    P.S.: Sorry for crossposting to "Illustrator Feature Requests" and "Illustrator Developers SDK" forum, but it seems to me, this forum here is the better place for my topic.

    I am working on a project to transfer data from Illustrator to MySQL Database. Give me at [email protected] more detailed info about your Illustrator-Files, then I'll let you know if any breakthrough.

  • Comparing Indesign/Illustrator/Photoshop to other programmes

    Hi all,
    My place of work has asked me to look into the possibility of moving away from Adobe to other lower cost or free design options.
    We are still languishing behind on Creative Suite 5.5 so can either go to CC (yes please), or go the other way using alternatives that are cheaper or free.
    I've have been asked to look at Functionality (obvious feature comparison), Compatibility (I believe this means opening old files, working with external organisations such as printers etc), Inter-operability I imagine they mean between indesign, illustrator, photoshop and then the other packages).
    So, my question is, are there any resources online you chaps can recommend that compares features and/or has covered similar topics?
    Thank you!

    Here are two non-Adobe CC comparison, you can gave a look at it.
    When to Use Adobe Illustrator vs. Photoshop vs. InDesign | Printwand™
    Illustrator vs. Photoshop vs. Indesign: What’s the Difference? | BEC Digital
    It will be best to contact support regarding this.https://helpx.adobe.com/contact.html
    Regards
    Rajshree

  • Hello,  Can you please advise me as to the recommended system requirements for Adobe CC for Photoshop, Illustrator, InDesign, and Dreamweaver (all 4 programs). I'm hoping this is summarized somewhere rather than making me look up and compare all four. I'l

    Hello,
    Can you please advise me as to the recommended system requirements for Adobe CC for Photoshop, Illustrator, InDesign, and Dreamweaver (all 4 programs). I'm hoping this is summarized somewhere rather than making me look up and compare all four. I'll be using a windows based PC, and will need a graphics card that can support at least two monitors.

    Hi julir
    check this System requirements | Photoshop
    why photoshop demand?cause photoshop having 3D feature, it mean need high spec,,so if you can run photoshop cc to run ai,indd and dw is posibilty
    regards
    Deto

  • Why is FrameMaker using different CYMK/RGB values for Pantone library colours compared with Illustrator?

    Evening all -
    this is by no means the first time I'm banged my head against the colour management brick wall, and I doubt it will be the last
    I am running Frame 12 and Illustrator CC on Windows 7.
    Both these Adobe products ship bundled with Pantone libraries. (Correct me with I'm wrong, but these "libraries" are basically a bunch of look-up tables, mapping named Pantone colours to various CYMK, RGB, etc equivalents?)
    Can anyone tell me why these two different Adobe applications appear to give different definitions for the same Pantone colours?
    For example, if I choose the Pantone Coated library > 'Warm Red'
    In Illustrator CC (left screenshot), it offers this as C0% M87.4% Y79.9% K0%
    in FrameMaker 12 (right screenshot), I get C0% M79%  Y91%  K0%
    Why are they different?
    Are the library definitions shipped with the products simply different?
    Frame's dialog ominously mentions "© Pantone, Inc., 1986, 1988"
    And if I go to C:\Program Files (x86)\Adobe\AdobeFrameMaker12\fminit\color and open the corresponding .bcf file in an editor, the header says:
    "BCF 2.0PANTONE¨ Coated 1.1 ©Pantone, Inc., 1986, 1988.PANTONE¨* Computer Video simulations displayed may not match PANTONE-identified solid color standards.  Use current PANTONE Color Reference Manuals for accurate color.  To order publications from Pantone, Inc., in the U.S. please call the toll-free number (800) 222-1149 [within NJ, call (201) 935-5500].  In other countries contact your local Pantone representative.  *Pantone, Inc.'s check-standard trademark for color.[1]"
    whereas if I go to C:\Program Files (x86)\Adobe\Adobe Illustrator CC\Presets\en_US\Swatches\Color Books and open the corresponding .acb swatch file in there, in amoungst the hex gibberish I note it says:
    "�=$$$/colorbook/PantonePlusCoated/title=PANTONE+^R Solid Coated/$$$/colorbook/PantonePlusCoated/prefix=PANTONE *$$$/colorbook/PantonePlusCoated/postfix= CK"$$$/colorbook/PantonePlusCoated/description=Copyright^C Pantone LLC, 2010"
    Have Pantone perhaps changed their colour definitions between 1988 and 2010?
    (I'm thinking it would be sensible to establish this one way or the other before we get into any convoluted discussions about the Windows GDI etc etc)

    David,
    What options did you use for defining the colours internally and what options for output in AI? I suspect that if you examine the EPS file you created from AI for the Panotne 355C, the only values in there are the CMYK ones - no LAB nor RGB. So FM has to use the algorithm mentioned in the other thread and creates the lime green based upon the algorithm. If you have set the AI drawing to an RGB color mode and set the EPS export option for "Include CMYK Postscript in RGB files" to OFF, then you would get the desired RGB values in the EPS file.
    If you're so intent on using Pantone Spot colours to get RGB, then you can create your own ACF library file with the exact RGB definitions that you want (you can then use whatever values you get in Photoshop, Illustrator or whatever source that you're trying to match). The structure of the file is as follows:
    ACF 1.0
    My Color Library             <----  name of library
    LibraryVersion: 1.0
    Copyright: © 2014 <your name here>. All rights reserved.
    AboutMessage: User defined Spot colours for RGB
    Names: Partial
    Rows: 4
    Columns: 4
    Entries: 1           <---- number of colours in file
    Prefix:         <---- used for display in FM, e.g. "Panotne"
    Suffix:           <----- used together with prefix, e.g. "CVC, CVU, etc."
    Type: Process <---- Spot, Process, Tint, Mixed (need to add specifier to Data lines)
    Models: CMYK RGB
    PreferredModel: RGB     <---- whatever you want
    Data:
    0.98 0.11 1.00 0.02              <---- CMYK values (0-1)
    0 38143 19967     <---- RGB values as 16-bit, i.e. 16-bit = ( [RGB value (1-255)]*256) + 255; zero is still zero
    Spruce Green                   <---- name of colour
    The acf file needs to be installed in the fminit\color folder.
    Also, a note of caution, If you screw something up in the acf file (like the incorrect number of entries in the file or you're missing a component value, this will hang FM if you use the View > Color > Definitions... option. You'll need to kill FM, fix or remove the ACF file and re-start. Also, FM only reads the libraries at the start, so if you need to make any changes to the ACF definitions, you have to r-start FM for those changes to take place.
    [I know, FM doesn't make it easy, but it can be done...]

  • Pixels and document size differences in Illustrator compared to Photoshop

    Why is the pixel ratio of a project in illustrator different than that of the same pixel ratio of a project in Photoshop?  Example:  A project can in Illustrator can have an artboard of 950px X 950px and be 12in and in Photoshop that same pixel ratio will be 4 3/4in.

    The rulers in Illustrator are always with fixed ratio of 1 inch = 72 pixels (72 ppi), you can check this by right clicking on the ruler and choosing inches or pixels and you will see that 950 px will be 13.9 inches and not 12 inches as you stated.
    The ratio of the rulers in Photoshop depends on the ppi resolution of the image set by the user in the Image Size dialog box. If choose Image > Image size, and set the Resolution to 72 pixels/inch (ppi) then the ratio of the rulers in Photoshop will match Illustrator. If you set it to something else they will not, in your case with an image with sides of 4.75 inches in Photoshop the Resolution will be 200 ppi in order to contain 950 pixels per side.
    When you save an image from Photoshop that contains metadata it has information about the size of the document in inches and pixels. Illustrator will place such images with the size of the inches not the pixels as indicated on the Illustrator rulers, internally however the image will contain all the pixels as indicated next to the PPI on the Control bar under the main menu when image is selected. These internal (actual) image pixels will be used when printing and when zooming on screen to render the image. Also if you copy from Photoshop and paste in Illustrator, it also will paste with the size of the inches and not the pixels (at least this is how it works with CS5 on Windows)
    If the placed image is without metadata Illustrator will always place it assuming 72 px = 1 inch (72 ppi). You can check that if in Photoshop save an image using Save for Web and Devices and choose None for Metadata.

  • Why Illustrator UI is so different compared to Photoshop?

    Features that do the same thing like skewing an object is even named differently (its shear in Illustrator, under object/transform/). There are also many other differences that only confuses user like me who often works with both apps. Why can't Photoshop, Illustrator and even other Adobe apps for that matter share similar user interface?
    Thanks for any explanation!

    aleno,
    Two important things in this connexion:
    The two applications have had quite different histories, even starting in different companies. There has been a certain convergence, but each has been developed from its own starting point.
    There is a fundamental difference between raster and vector artwork, the other side being incorporated as an addition at a lower level in each application.

  • Can you remove XMP data from .eps files in Illustrator-CS5.5?

    Background:
    I'm using font software called Typetool 3 and Illustrator CS5.5.
    I am using these on Windows 7, 64 bit.
    This is entry level font software released by Fontlab.
    This software accepts artwork through the .eps file format in both theory and practice.
    However: it refuses illustrator CS5.5 .eps files.
    When I looked at this I came up with two highly interesting things: First- CS5.5 illustrator files are roughly 13 times the size of CS5 files, of this type (a simple font glyph-comparing a 29-30 kbfile to a 420-450 kb file in cs5 and cs5.5 respectively).
    Thing two came from looking at what that data was (by opening it in a text editor). It appears that some of the data XMP data, illustrators data for tracking things like who created the file, copyright, and other. In document info many of these fields were blank. I'm sure this isn't the only issue because my exported xmp data is 64 kb large, but it does account for a chunk of the file.
    The main question being: Can this xmp data; which for my purposes is redundant, because I have to put copyright and other data in the font, be removed or not included at the point of document creation?
    The technical question being:Can the file be saved in a manner which will allow it to be exported from adobe CS5.5 and imported into Typetool 3?
    Things I've tried:
    In saving .eps file: removing document headers, previews, color data, saving as different versions of the language. Basically saving it without all settings.
    In saving .ai file: saving without any settings checked (without compression, pdf editting, ect.) and saving it to a different level of illustrator.
    I do not know enough about postscript programming to navigate the file or remove the offending data. Nor do I have time to do this over multiple glyphs.
    As a matter of opinion I do not like that my software is including potentially identifying information (which is one of the intents of XMP data, to provide identification) without notifying the creator, let alone allowing me to keep it from doing that. I would not mind or bother-except for the fact its messed up an established workflow. If someone editted this data without my knowledge, say with a virus or heaven forbid manually, it would be also be bothersome. Having a check that identifies that I am sending this data out would give me something to know if this situation was in fact happening. Additionally for a situation like mine-communication between programs in a closed environment where no other users are involved, its unnecessary and wasteful... like putting gold rims on what is intended to be an oxcart.
    I'm planning on going to Fontlab for later this week, as it is as much thier issue as it is Adobe's. From what I know XMP is both a useful and popular technology- having a workaround for this situation seems like it would be a good idea. If necessary I can attach some working files for comparision.

    I would save it as EPS (version Illustrator 3). This should be compatible to almost any  software that takes EPS.

  • Convert old cs4 script to illustrator cc

    This is a big ask, but I found this script to remove redundant points at github.com/mekkablue/Glyphs-Scripts
    Each time I run, it seems to work, it shows how many points it has removed, but then illustrator crashes, with no kind of error notice.
    If I run it via extendscript toolkit it jumps to the following bit of code
    var docRef=app.activeDocument;
    I would really love to get this to work, if anyone is willing to help me.
      RemovetRedundantPoints.jsx
      A Javascript for Adobe Illustrator
      Author:
      Jim Heck
      [email protected]
      Purpose:
      Remove anchorpoints on selected path that are coincident in location.
      Finds and optionally removes redundant points from each selected PathItem.
      Useful for cleaning up after Offset Path and Outline Stroke commands in CS3.
      To Use:
      Select the paths, including compound paths to be affected. If no path is
      selected, the script will run for all paths in the document that are not
      locked. Run the script.
      Rights:
      This work is licensed under the Creative Commons Attribution 3.0 United States
      License. To view a copy of this license, visit
      http://creativecommons.org/licenses/by/3.0/us/
      or send a letter to Creative Commons, 171 Second Street, Suite 300,
      San Francisco, California, 94105, USA.
      Version History:
      1.8 120108 More fixes to the logic for keeping only a single point.
      The direction handles for the remaining point are now correctly calculated
      based on relative angle and distance to the original anchor to which a
      handle related. Also if a SMOOTH point is remaining, the angle of the
      two direction handles has been tweaked to be exactly 180 degrees for
      consistency with the definition of a SMOOTH point.
      1.7 120106 Change the way direction handles and PointType are handled
      when keeping only one point. Retract handles less than 0.5 points to keep
      consistent angles for SMOOTH point types. If keepLeadingPoint or
      keepTrailingPoint is specified, try to keep the PointType of that point.
      In the absence of other indicators, base PointType on the point (leading
      or trailing) that has an extended handle.
      1.6.1 090914 Tweak defaults to make sense for my work style
      1.6 090411 Fix a bug in creating a temporary path. Fix a bug in
      findRedundantPoints(), when searching backwards, the tolerance was always
      applied against the first point on the path instead of the adjacent point
      along the path. Change selection options so that there is more control over
      which points are processed on a given path. The new options allow for ignoring
      selection of points, restricting processing to only selected points, or
      processing redundant points if at least one of them is selected. Correct count
      of redundant points removed when both leading and trailing points retained.
      1.5 090404 Change default action to remove. Fix a major performance issue
      in the docGetSelectedPaths() routine. Searching through all the paths in very
      complex files takes a LONG time. Instead, search the document groups array.
      BETA: Lots of hacking on the removeRedundantPoints() routine to improve the
      look of the resulting curve when applied to the oxbow problem.
      1.4.1 090331 Fix a bug in removeRedundantPoints(), needed to compare absolute
      error to a tolerance. Also, loosen up the error criteria so less smooth
      points are mischaracterized as corners. Tolerance is now 0.02 radians,
      which is about 1.15 degrees. For some reason, the redundant points on
      arbitrary (non-geometric) outlined paths have lots of slop in the
      direction handles.
      1.4 090331 Add options to control which points are left on removal, leading,
      trailing or both. If neither is retained, the redundant point positions
      are averaged. If both are retained, intermediate points are removed, and
      inward facing control handles are synthesized (see comments below).
      Switched to using the atan2 function instead of atan for calculating theta.
      Fixed bugs in docGetSelectedPaths(). CompoundPathItem objects don't seem
      to have properly formed pathItems arrays when they contain what appear to
      be groups of paths. Also, layer objects can contain layers.
      1.3.1 090327 Limit user entered tolerance value to something sane.
      1.3 090327 Add user controls to specify a tolerance in points for identifying
      redundant points.
      1.2.3 090327 Improve results dialog verbiage.
      1.2.2 090326 Bug fix. Observe proper unlocking and locking order for
      handling of locked objects.
      1.2.1 090326 Minor bug fixes including, restricting selection only option
      to not be allowed with selection function.
      1.2 090326 Add option to remove only redundant points sets with at least one
      selected point. Fix broken option to remove locked redundant points.
      Add results dialog OK button.
      1.1 090325 Improve select action to work across selection or entire document.
      Handle nested layers in docGetSelectedPaths(). Clean whitespace.
      1.0.1 090325 Minor bug fix.
      1.0 090311 Initial release.
    * Function: getPairTheta
    * Description:
    * Return the angle relative to the X axis from the line formed between
    * two points, which are passed in as arguments. The angle is measured
    * relative to point A (as if A were relocated to the origin, and the angle
    * is measured to the X axis itself). The arguments are expected to be
    * arrays of two numbers (X, Y) defining the point. The return value is in
    * radians (PI to -PI)
    function getPairTheta(pairA,pairB){
      var deltaX=pairB[0]-pairA[0];
      var deltaY=pairB[1]-pairA[1];
      /*alert("deltaX="+deltaX+" deltaY="+deltaY);*/
      return(Math.atan2(deltaY, deltaX));
    * Function: getPairDistance
    * Description:
    * Return the distance between two points. The arguments are expected to be
    * arrays of two numbers (X, Y) defining the point. The return value is the
    * distance in units relative to the inputs.
    function getPairDistance(pairA,pairB){
      var deltaX=pairB[0]-pairA[0];
      var deltaY=pairB[1]-pairA[1];
      return(Math.sqrt((deltaX*deltaX)+(deltaY*deltaY)));
    * Function: findRedundantPoints
    * Description:
    * Find all sets of redundant points for the input path. A redundant point
    * is defined as one that has the same anchor location as a neighboring point.
    * The arguments are a path to work on, the tolerance in points to apply to
    * determine a point is redundant, and a boolean to indicate that only
    * groups of redundant points where at least one point is selected should
    * be considered. The return value is an Array of Arrays containing the
    * indicies of the redundant pathPoint objects found in the path.
    function findRedundantPoints(path, tolerance, anySelected, allSelected){
      var anchorDistance = 0;
      var redundantPointSets = new Array();
      var redundantPoint = new Array();
      var selectedRedundantPointSets = new Array();
      var selectedRedundantPoint = new Array();
      var i = 0;
      var j = 0;
      var k = 0;
      var index;
      var selected = false;
      if(path.pathPoints.length > 1) {
      * The first path point may be coincident with some at the end of the path
      * so we check going backwards first. Redundant points pushed on the
      * front of the array so they stay in order leftmost to rightmost.
      redundantPoint.push(0);
      index = 0;
      for (i=path.pathPoints.length-1; i>0; i--) {
      * Get distance and round to nearest hundredth of a point.
      * If points are closer than the tolerance, consider them
      * coincident.
      anchorDistance = getPairDistance(path.pathPoints[index].anchor, path.pathPoints[i].anchor);
      anchorDistance = roundToPrecision(anchorDistance, 0.01);
      if (anchorDistance < tolerance) {
      redundantPoint.unshift(i);
      else {
      break;
      index = i;
      * If we haven't used up all the points, start searching forwards
      * up to the point we stopped searching backwards. Test the
      * current point against the next point. If the next point matches push
      * its index onto the redundantPoint array. When the first one doesn't match,
      * check if the redundantPoint array has more than one index. If so add it
      * to the redundantPointSets array. Then clean the redundantPoint array
      * and push on the next point index.
      if(i > 0) {
      for (j=0; j<i; j++) {
      anchorDistance = getPairDistance(path.pathPoints[j].anchor, path.pathPoints[j+1].anchor);
      anchorDistance = roundToPrecision(anchorDistance, 0.01);
      if (anchorDistance < tolerance) {
      redundantPoint.push(j+1);
      else {
      if (redundantPoint.length > 1) {
      redundantPointSets.push(redundantPoint);
      redundantPoint = [];
      redundantPoint.push(j+1);
      * Push the last redundantPoint array onto the redundantPointSets array if
      * its length is greater than one.
      if (redundantPoint.length > 1) {
      redundantPointSets.push(redundantPoint);
      if (anySelected) {
      for (i=0; i<redundantPointSets.length; i++) {
      var currentPointSet = redundantPointSets[i];
      selected = false;
      for (j=0; j<currentPointSet.length; j++) {
      if (path.pathPoints[currentPointSet[j]].selected ==
      PathPointSelection.ANCHORPOINT) {
      selected = true;
      if (selected) {
      selectedRedundantPointSets.push(currentPointSet);
      else if (allSelected) {
      for (i=0; i<redundantPointSets.length; i++) {
      var currentPointSet = redundantPointSets[i];
      for (j=currentPointSet.length-1; j>=0; j--) {
      var currentPoint = path.pathPoints[currentPointSet[j]];
      if (currentPoint.selected == PathPointSelection.ANCHORPOINT) {
      selectedRedundantPoint.unshift(currentPointSet[j]);
      else {
      break;
      if (j > 0) {
      for (k=0; k<j; k++) {
      var currentPoint = path.pathPoints[currentPointSet[k]];
      if (currentPoint.selected == PathPointSelection.ANCHORPOINT) {
      selectedRedundantPoint.push(currentPointSet[k]);
      else {
      if (selectedRedundantPoint.length > 1) {
      selectedRedundantPointSets.push(selectedRedundantPoint);
      selectedRedundantPoint = [];
      if (selectedRedundantPoint.length > 1) {
      selectedRedundantPointSets.push(selectedRedundantPoint);
      selectedRedundantPoint = [];
      else {
      selectedRedundantPointSets = redundantPointSets;
      return(selectedRedundantPointSets);
    * Function: countRedundantPoints
    * Description:
    * Count the number of redundant points given a redundantPointSets array as
    * the first parameter.
    function countRedundantPoints(redundantPointSets, doKeepLeadingPoint, doKeepTrailingPoint) {
      var i = 0;
      var redundantPoints = 0;
      var pointsKept = 1;
      if (doKeepLeadingPoint && doKeepTrailingPoint) {
      pointsKept = 2;
      for (i=0; i<redundantPointSets.length; i++) {
      redundantPoints += redundantPointSets[i].length - pointsKept;
      return (redundantPoints);
    * Function: countSelectedPoints
    * Description:
    * Count the number of selected anchor points given a path as the first parameter.
    function countSelectedPoints(path) {
      var i = 0;
      var selectedPoints = 0;
      for (i=0; i<path.pathPoints.length; i++) {
      if (path.pathPoints[i].selected == PathPointSelection.ANCHORPOINT) {
      selectedPoints++;
      return (selectedPoints);
    * Function: removeRedundantPoints
    * Description:
    * Remove redundant points from a path input as the first parameter. The
    * second input parameter should be an array of arrays containing the
    * indicies of redundant points, as returned from function
    * findRedundantPoints(). From each set of indicies, the first point is
    * retained, and the subsequent points are removed from the path. Care is
    * taken to preserve the proper leftDirection and rightDirection handles,
    * as well as the proper PointType for the remaining point. Returns
    * the number of points removed.
    function removeRedundantPoints(path, redundantPointSets, keepLeadingPoint, keepTrailingPoint, keepAveragedPoint){
      var i = 0;
      var j = 0;
      var pointsToRemove = new Array();
      var tempLayer;
      var tempPath;
      * For each array of redundant point indicies in array redundantPointSets,
      * modify the leadingPoint to have all the properties needed to properly
      * describe the set of coincident points.
      for (i=0; i<redundantPointSets.length; i++) {
      var x = 0;
      var y = 0;
      var currentPointSet = redundantPointSets[i];
      var leadingPoint = path.pathPoints[currentPointSet[0]];
      var trailingPoint = path.pathPoints[currentPointSet[currentPointSet.length-1]];
      if (keepLeadingPoint && keepTrailingPoint) {
      * JAH 090401 REVISIT COMMENT WHEN DONE
      * If we are keeping two points, the leftDirection of the leading point
      * and rightDirection of the trailing point are already fixed. We have to
      * synthesize the inward facing handles, and choose pointType of the two points.
      * To allow easy manipultion of the inner handles without disturbing the fixed
      * handles, make the points PointType.CORNER. For the direction handles, make
      * them parallel to their respective paired handle, and extend them half the
      * distance between the two remaining points.
      var averagedPoint;
      var theta;
      var deltaX;
      var deltaY;
      var pairDistance;
      var leftDistance;
      var rightDistance;
      var firstRemovedIndex = 1;
      if (currentPointSet.length > 2) {
      averagedPoint = path.pathPoints[currentPointSet[1]];
      else {
      tempLayer = app.activeDocument.layers.add();
      tempLayer.name = "Temp";
      tempPath = tempLayer.pathItems.add();
      averagedPoint = tempPath.pathPoints.add();
      if( currentPointSet.length <= 2 || !keepAveragedPoint ) {
      * Use just the leading and trailing points. Create inward facing
      * direction handles for the two endpoints based on the relationship
      * of the angles between each endpoint and the average point.
      * For each endpoint, calcualte the angle of the endpoint to the
      * average point, and the endpoint to the other endpoint. Combine
      * the angles. The base angle for the inward facing direction handle
      * is the angle that points it towards the average point. Add to this
      * angle, a multiple of the difference between the angle just mentioned,
      * and the angle to the other endpoint. Adding this difference angle
      * will bias the curve towards the average point. Finally, set the
      * length of the direction handle as the distance from the endpoint
      * to the average point multiplied by a factor.
      var thetaAverage;
      var thetaPair;
      var tweakThetaToOppositeEndpoint = 1.0;
      var tweakPairDistance = 0.5;
      * Since the leading and trailing points will have direction handles pointing
      * in different directions, these points must be corner points by necessity.
      leadingPoint.pointType = PointType.CORNER;
      trailingPoint.pointType = PointType.CORNER;
      * Create new average point.
      for (j=0; j<currentPointSet.length; j++) {
      x += path.pathPoints[currentPointSet[j]].anchor[0];
      y += path.pathPoints[currentPointSet[j]].anchor[1];
      x /= currentPointSet.length;
      y /= currentPointSet.length;
      averagedPoint.anchor = Array(x, y);
      averagedPoint.leftDirection = Array( averagedPoint.anchor[0], averagedPoint.anchor[1]);
      averagedPoint.rightDirection = Array( averagedPoint.anchor[0], averagedPoint.anchor[1]);
      averagedPoint.pointType = PointType.CORNER;
      /* Calcualte new leading point rightDirection */
      pairDistance = getPairDistance(leadingPoint.anchor, averagedPoint.anchor);
      thetaAverage = getPairTheta(leadingPoint.anchor, averagedPoint.anchor);
      thetaPair = getPairTheta(leadingPoint.anchor, trailingPoint.anchor);
      theta = thetaAverage + tweakThetaToOppositeEndpoint * (thetaAverage - thetaPair);
      /*alert("thetaAverage="+thetaAverage+" thetaPair="+thetaPair" theta="+theta);*/
      deltaX = Math.cos(theta) * tweakPairDistance * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistance * pairDistance;
      leadingPoint.rightDirection = Array(leadingPoint.anchor[0]+deltaX, leadingPoint.anchor[1]+deltaY);
      /* Calcualte new trailing point leftDirection */
      pairDistance = getPairDistance(trailingPoint.anchor, averagedPoint.anchor);
      thetaAverage = getPairTheta(trailingPoint.anchor, averagedPoint.anchor);
      thetaPair = getPairTheta(trailingPoint.anchor, leadingPoint.anchor);
      theta = thetaAverage + tweakThetaToOppositeEndpoint * (thetaAverage - thetaPair);
      /*alert("thetaAverage="+thetaAverage+" thetaPair="+thetaPair" theta="+theta);*/
      deltaX = Math.cos(theta) * tweakPairDistance * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistance * pairDistance;
      trailingPoint.leftDirection = Array(trailingPoint.anchor[0]+deltaX, trailingPoint.anchor[1]+deltaY);
      else {
      * Use just the leading and trailing points, along with a third point added
      * at the average of all the removed points. This point will act to anchor
      * the curve at the average point. It will also allow the leading and
      * trailing points to be smooth points, allowing for a continuous
      * curve through them.
      * The inward facing direction handles for the two endpoints will be
      * shortened extensions of the outward facing direction handles for these
      * points. The length of the handles will be a multiple of the
      * distance from the direction handle to the average point.
      * For the average point, the direction handles will be parallel to the
      * angle formed by the angle between the two endpoints. The length
      * of the direction handles for this point will be a different multiple
      * of the length from each endpoint to the average point.
      var thetaAverage;
      var thetaPair;
      var tweakPairDistanceForAveraged = 0.5;
      var tweakPairDistanceForEndpoint = 0.25;
      * Since the leading and trailing points will have direction handles that
      * are parallel, make them smooth points.
      leadingPoint.pointType = PointType.SMOOTH;
      trailingPoint.pointType = PointType.SMOOTH;
      /* We will be keeping one more point, the averaged point. */
      firstRemovedIndex = 2;
      * Create new average point.
      for (j=0; j<currentPointSet.length; j++) {
      x += path.pathPoints[currentPointSet[j]].anchor[0];
      y += path.pathPoints[currentPointSet[j]].anchor[1];
      x /= currentPointSet.length;
      y /= currentPointSet.length;
      averagedPoint.anchor = Array(x, y);
      averagedPoint.leftDirection = Array( averagedPoint.anchor[0], averagedPoint.anchor[1]);
      averagedPoint.rightDirection = Array( averagedPoint.anchor[0], averagedPoint.anchor[1]);
      averagedPoint.pointType = PointType.SMOOTH;
      /* Calcualte new averaged point leftDirection */
      pairDistance = getPairDistance(leadingPoint.anchor, averagedPoint.anchor);
      theta = getPairTheta(leadingPoint.anchor, trailingPoint.anchor);
      /*alert("theta="+theta);*/
      if (theta > 0) {
      theta += Math.PI;
      else {
      theta += -Math.PI;
      deltaX = Math.cos(theta) * tweakPairDistanceForAveraged * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistanceForAveraged * pairDistance;
      averagedPoint.leftDirection = Array(averagedPoint.anchor[0]+deltaX, averagedPoint.anchor[1]+deltaY);
      /* Calcualte new averaged point rightDirection */
      pairDistance = getPairDistance(trailingPoint.anchor, averagedPoint.anchor);
      theta = getPairTheta(trailingPoint.anchor, averagedPoint.anchor);
      /*alert("theta="+theta);*/
      if (theta > 0) {
      theta += Math.PI;
      else {
      theta += -Math.PI;
      deltaX = Math.cos(theta) * tweakPairDistanceForAveraged * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistanceForAveraged * pairDistance;
      averagedPoint.rightDirection = Array(averagedPoint.anchor[0]+deltaX, averagedPoint.anchor[1]+deltaY);
      /* Calculate direction handles for leading and trailing points */
      pairDistance = getPairDistance(leadingPoint.anchor, trailingPoint.anchor);
      leftDistance = getPairDistance(leadingPoint.anchor, leadingPoint.leftDirection);
      if (leftDistance > 0) {
      theta = getPairTheta(leadingPoint.anchor, leadingPoint.leftDirection);
      /*alert("theta="+theta);*/
      if (theta > 0) {
      theta += Math.PI;
      else {
      theta += -Math.PI;
      pairDistance = getPairDistance(leadingPoint.anchor, averagedPoint.anchor);
      deltaX = Math.cos(theta) * tweakPairDistanceForEndpoint * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistanceForEndpoint * pairDistance;
      leadingPoint.rightDirection = Array(leadingPoint.anchor[0]+deltaX, leadingPoint.anchor[1]+deltaY);
      else {
      leadingPoint.rightDirection = leadingPoint.anchor;
      rightDistance = getPairDistance(trailingPoint.anchor, trailingPoint.rightDirection);
      if (rightDistance > 0) {
      theta = getPairTheta(trailingPoint.anchor, trailingPoint.rightDirection);
      if (theta > 0) {
      theta += Math.PI;
      else {
      theta += -Math.PI;
      pairDistance = getPairDistance(trailingPoint.anchor, averagedPoint.anchor);
      deltaX = Math.cos(theta) * tweakPairDistanceForEndpoint * pairDistance;
      deltaY = Math.sin(theta) * tweakPairDistanceForEndpoint * pairDistance;
      trailingPoint.leftDirection = Array(trailingPoint.anchor[0]+deltaX, trailingPoint.anchor[1]+deltaY);
      else {
      trailingPoint.leftDirection = trailingPoint.anchor;
      * Push all points other than the leading and trailing onto the pointsToRemove array
      * for later removal. We can't remove them while we are working with later sets.
      for (j=firstRemovedIndex; j<currentPointSet.length-1; j++) {
      pointsToRemove.push(currentPointSet[j]);
      else {
      * If we are only keeping one point, we will work with the leading point.
      * First, calculate the relative distances and angles of the direction handle for
      * the leadingPoint leftDirection handle and the trailingPoint rightDirection
      * handle. These values will be used to help properly construct the remaining
      * point.
      var leftDistance = getPairDistance(leadingPoint.anchor, leadingPoint.leftDirection);
      var rightDistance = getPairDistance(trailingPoint.anchor, trailingPoint.rightDirection);
      var leftTheta = getPairTheta(leadingPoint.anchor, leadingPoint.leftDirection);
      var rightTheta = getPairTheta(trailingPoint.anchor, trailingPoint.rightDirection);
      * If we are keeping the leadingPoint, calculate a relative rightDirection handle
      * based on the trailingPoint rightDistance and rightTheta. If we are keeping the
      * trailingPoint, copy its anchor and rightDirection handle to the leadingPoint,
      * and calculate a relative leftDirection handle based on the leadingPoint
      * leftDistance and leftTheta. If we are to keep neither leading or trailing point,
      * average the position of all the redundant points and calcuate direction handles
      * based on the appropriate values.
      if (keepLeadingPoint) {
      x = leadingPoint.anchor[0] + (Math.cos(rightTheta) * rightDistance);
      y = leadingPoint.anchor[1] + (Math.sin(rightTheta) * rightDistance);
      leadingPoint.rightDirection = Array(x, y);
      else if (keepTrailingPoint) {
      leadingPoint.anchor = trailingPoint.anchor;
      leadingPoint.rightDirection = trailingPoint.rightDirection;
      x = leadingPoint.anchor[0] + (Math.cos(leftTheta) * leftDistance);
      y = leadingPoint.anchor[1] + (Math.sin(leftTheta) * leftDistance);
      leadingPoint.leftDirection = Array(x, y);
      else {
      for (j=0; j<currentPointSet.length; j++) {
      x += path.pathPoints[currentPointSet[j]].anchor[0];
      y += path.pathPoints[currentPointSet[j]].anchor[1];
      x /= currentPointSet.length;
      y /= currentPointSet.length;
      leadingPoint.anchor = Array(x, y);
      x = leadingPoint.anchor[0] + (Math.cos(leftTheta) * leftDistance);
      y = leadingPoint.anchor[1] + (Math.sin(leftTheta) * leftDistance);
      leadingPoint.leftDirection = Array(x, y);
      x = leadingPoint.anchor[0] + (Math.cos(rightTheta) * rightDistance);
      y = leadingPoint.anchor[1] + (Math.sin(rightTheta) * rightDistance);
      leadingPoint.rightDirection = Array(x, y);
      * If the distance for a handle is less than half a point and rounds to zero,
      * retract that handle fully by setting that direction handle equal to the anchor
      * point. This will keep angles consistent for smooth points.
      if (Math.round(leftDistance) == 0) {
      leadingPoint.leftDirection = leadingPoint.anchor;
      if (Math.round(rightDistance) == 0) {
      leadingPoint.rightDirection = leadingPoint.anchor;
      * Handle the PointType in a minimal manner. If keeping the leadingPoint or keeping
      * the trailingPoint, keep the PointType of that point if possible. If both handles
      * are extended, measure the angles of the two direction handles. If both handles
      * have the same angle relative to the X axis within a tolerance, the PointType
      * can be SMOOTH, otherwise it must be CORNER. If the point type is SMOOTH, ensure
      * the direction handles are corrected to be exactly 180 degrees apart.
      * If not specifically keeping the leading or trailing point and only one handle is
      * extended, base the pointType on the the leadingPoint if only the left handle is
      * extended and the trailingPoint if only the right handle is extended. 
      if (Math.round(leftDistance) > 0 && Math.round(rightDistance) > 0) {
      var absdiff = Math.abs(leftTheta-rightTheta);
      var error = Math.PI - absdiff;
      /*alert("leftTheta="+leftTheta+" rightTheta="+rightTheta+" absdiff="+absdiff+" error="+error);*/
      if (Math.abs(error) < 0.02) {
      if (keepTrailingPoint) {
      leadingPoint.pointType = trailingPoint.pointType;
      else if (!keepLeadingPoint) {
      leadingPoint.pointType = PointType.SMOOTH;
      if (leadingPoint.pointType == PointType.SMOOTH) {
      if (keepTrailingPoint) {
      x = leadingPoint.anchor[0] + (Math.cos(Math.PI + rightTheta) * leftDistance);
      y = leadingPoint.anchor[1] + (Math.sin(Math.PI + rightTheta) * leftDistance);
      leadingPoint.leftDirection = Array(x, y);
      else {
      x = leadingPoint.anchor[0] + (Math.cos(Math.PI + leftTheta) * rightDistance);
      y = leadingPoint.anchor[1] + (Math.sin(Math.PI + leftTheta) * rightDistance);
      leadingPoint.rightDirection = Array(x, y);
      else {
      leadingPoint.pointType = PointType.CORNER;
      else if (keepTrailingPoint) {
      leadingPoint.pointType = trailingPoint.pointType;
      else if (!keepLeadingPoint && rightDistance > 0) {
      leadingPoint.pointType = trailingPoint.pointType;
      * Push all other points onto the pointsToRemove array for later removal. We can't
      * remove them while we are working with later sets.
      for (j=1; j<currentPointSet.length; j++) {
      pointsToRemove.push(currentPointSet[j]);
      * Sort the pointsToRemove array and then remove the points in reverse order, so the indicies
      * remain coherent during the removal.
      pointsToRemove.sort(function (a,b) { return a-b });
      for (i=pointsToRemove.length-1; i>=0; i--) {
      var pointToRemove = path.pathPoints[pointsToRemove[i]];
      pointToRemove.remove();
      if (tempPath) {
      tempPath.remove();
      if (tempLayer) {
      tempLayer.remove();
      return (pointsToRemove.length);
    * Function: selectRedundantPoints
    * Description:
    * Select redundant points on a path input as the first parameter. The
    * second input parameter should be an array of arrays containing the
    * indicies of redundant points, as returned from function
    * findRedundantPoints(). If there are redundant points, deselect all points
    * on the path and select the ANCHORPOINT of each redundant point. If there
    * are no redundant points on the path, do nothing.
    function selectRedundantPoints(path, redundantPointSets){
      var i = 0;
      var j = 0;
      if (redundantPointSets.length > 0) {
      for (i=0; i<path.pathPoints.length; i++) {
      path.pathPoints[i].selected = PathPointSelection.NOSELECTION;
      for (i=0; i<redundantPointSets.length; i++) {
      var currentPointSet = redundantPointSets[i];
      for (j=0; j<currentPointSet.length; j++) {
      path.pathPoints[currentPointSet[j]].selected = PathPointSelection.ANCHORPOINT;
    * Function: unlockPath
    * Description:
    * For a path input as the first parameter, unlock the path and any locked
    * parent object. Return an array of objects that have been unlocked.
    function unlockPath(path){
      var unlockedObjects = new Array();
      var parentObjects = new Array();
      var currentObject = path;
      var i = 0;
      while (currentObject.typename != "Document") {
      parentObjects.unshift(currentObject);
      currentObject = currentObject.parent;
      for (i=0; i<parentObjects.length; i++) {
      if (parentObjects[i].locked) {
      parentObjects[i].locked = false;
      unlockedObjects.unshift(parentObjects[i]);
      return unlockedObjects;
    * Function: lockObjects
    * Description:
    * For a set of objects as the first parameter, lock each object.
    function lockObjects(objects){
      var i = 0;
      for (i=0; i<objects.length; i++) {
      objects[i].locked = true;
    * Function: docGetSelectedPaths
    * Description:
    * Get all the selected paths for the docRef argument passed in as
    * a parameter. The second parameter is a boolean that controls if compound
    * path items are included (default true), and the third parameter is a
    * boolean that controls if locked objects are included (default false).
    * Returns an array of paths.
    function docGetSelectedPaths(docRef, includeCompound, includeLocked){
      var qualifiedPaths = new Array();
      var i = 0;
      var j = 0;
      var nextPath = null;
      var currentSelection = new Array();
      var nextSelection = docRef.selection;
      if (includeCompound == null) {
      includeCompound = true;
      if (includeLocked == null) {
      includeLocked = false;
      do {
      currentSelection = nextSelection;
      nextSelection = [];
      for(i=0; i<currentSelection.length; i++){
      var currentObject=currentSelection[i];
      if (currentObject.typename == "PathItem") {
      if (includeLocked || !(currentObject.locked ||
      currentObject.layer.locked)) {
      qualifiedPaths.push(currentObject);
      else if (currentObject.typename == "CompoundPathItem") {
      if (includeCompound &&
      (includeLocked || !(currentObject.locked ||
      currentObject.layer.locked))) {
      * For more complex compound paths (e.g. concentric circular bands),
      * in CS3 the CompoundPathItem object's pathItems array is empty.
      * Inspection of the paths in a document shows the paths contained
      * in the CompoundPathItem have groups as parents. To get around
      * this seeming bug, in addition to using the pathItems array,
      * which still contains individual paths, we also search through
      * all the groups in the document adding paths whose parent
      * is the CompoundPathItem object.
      * WARNING this takes non-negligible time in large documents.
      for (j=0; j<currentObject.pathItems.length; j++) {
      qualifiedPaths.push(currentObject.pathItems[j]);
      for (j=0; j<docRef.groupItems.length; j++) {
      if (docRef.groupItems[j].parent == currentObject) {
      nextSelection.push(docRef.groupItems[j]);
      else if (currentObject.typename == "GroupItem") {
      for (j=0; j<currentObject.pathItems.length; j++){
      nextSelection.push(currentObject.pathItems[j]);
      for (j=0; j<currentObject.compoundPathItems.length; j++){
      nextSelection.push(currentObject.compoundPathItems[j]);
      for (j=0; j<currentObject.groupItems.length; j++){
      nextSelection.push(currentObject.groupItems[j]);
      else if (currentObject.typename == "Layer") {
      for (j=0; j<currentObject.pathItems.length; j++){
      nextSelection.push(currentObject.pathItems[j]);
      for (j=0; j<currentObject.compoundPathItems.length; j++){
      nextSelection.push(currentObject.compoundPathItems[j]);
      for (j=0; j<currentObject.groupItems.length; j++){
      nextSelection.push(currentObject.groupItems[j]);
      for (j=0; j<currentObject.layers.length; j++){
      nextSelection.push(currentObject.layers[j]);
      } while (nextSelection.length > 0);
      return qualifiedPaths;
    * Function: docGetAllPaths
    * Description:
    * Get all the paths for the docRef argument passed in as a parameter.
    * The second parameter is a boolean that controls if compound path items are
    * included (default true), and the third parameter is a boolean that controls
    * if locked objects are included (default false). Returns an array of paths.
    function docGetAllPaths(docRef, includeCompound, includeLocked) {
      var qualifiedPaths = new Array();
      var i = 0;
      var nextPath = null;
      if (includeCompound == null) {
      includeCompound = true;
      if (includeLocked == null) {
      includeLocked = false;
      for (i=0; i<docRef.pathItems.length; i++) {
      nextPath = docRef.pathItems[i];
      if (!includeCompound && nextPath.parent.typename == "CompoundPathItem") {
      continue;
      if (!includeLocked && (nextPath.layer.locked == true || nextPath.locked == true)) {
      continue;
      qualifiedPaths.push(nextPath);
      return qualifiedPaths;
    * Function: roundToPrecision
    * Description:
    * Round a number input as the first parameter to a given precision. The
    * second input parameter is the precision to round to (typically a power of
    * 10, like 0.1). Returns the rounded value.
    function roundToPrecision(value, precision) {
      var result;
      result = value / precision;
      result = Math.round(result);
      result = result * precision;
      return (result);
    * Main code
    var dlgInit = new Window('dialog', 'Redundant Path Points');
    doInitDialog(dlgInit);
    var exitError;
    var tolerance = 1 * (dlgInit.tolerancePnl.editText.text);
    var doAnalyze = dlgInit.functionPnl.doAnalyze.value;
    var doRemove = dlgInit.functionPnl.doRemove.value;
    var doSelect = dlgInit.functionPnl.doSelect.value;
    var doKeepLeadingPoint = dlgInit.removalPnl.doKeepLeadingPoint.value;
    var doKeepTrailingPoint = dlgInit.removalPnl.doKeepTrailingPoint.value;
    var doKeepAveragedPoint = dlgInit.removalPnl.doKeepAveragedPoint.value;
    var includeCompound = dlgInit.optionPnl.includeCompound.value;
    var includeLocked = dlgInit.optionPnl.includeLocked.value;
    var ignoreSelected = dlgInit.selectionPnl.ignoreSelected.value;
    var anySelected = dlgInit.selectionPnl.anySelected.value;
    var allSelected = dlgInit.selectionPnl.allSelected.value;
    var docRef=app.activeDocument;
    var pathsToProcess = new Array();
    var i = 0;
    var j = 0;
    var totalPaths = 0;
    var totalPointsWithRedundancy = 0;
    var totalPointsToRemove = 0;
    var totalPointsRemoved = 0;
    var totalPointsStarting = 0;
    var totalPointsRemaining = 0;
    var totalPointsSelected = 0;
    var redundantPointSets = new Array();
    var unlockedObjects = new Array();
    try {
      if (exitError != 0) {
      throw("exit");
      exitError = 99;
      if (docRef.selection.length > 0) {
      pathsToProcess = docGetSelectedPaths(docRef, includeCompound, includeLocked);
      else {
      var doAll = confirm("Run script for all paths in document?");
      if (doAll) {
      pathsToProcess = docGetAllPaths(docRef, includeCompound, includeLocked);
      if (doSelect) {
      if (includeLocked) {
      exitError = 2;
      throw("exit");
      if (!ignoreSelected) {
      exitError = 3;
      throw("exit");
      docRef.selection = null;
      for (i=0; i<pathsToProcess.length; i++) {
      redundantPointSets = findRedundantPoints(pathsToProcess[i], tolerance, anySelected, allSelected);
      totalPaths++;
      totalPointsWithRedundancy += redundantPointSets.length;
      totalPointsToRemove += countRedundantPoints(redundantPointSets, doKeepLeadingPoint, doKeepTrailingPoint);
      totalPointsStarting += pathsToProcess[i].pathPoints.length;
      totalPointsSelected += countSelectedPoints(pathsToProcess[i]);
      if (doRemove) {
      if (includeLocked) {
      unlockedObjects = unlockPath(pathsToProcess[i]);
      else {
      unlockedObjects = [];
      totalPointsRemoved += removeRedundantPoints(pathsToProcess[i], redundantPointSets, doKeepLeadingPoint, doKeepTrailingPoint, doKeepAveragedPoint);
      if (unlockedObjects.length > 0) {
      lockObjects(unlockedObjects);
      if (doSelect) {
      selectRedundantPoints(pathsToProcess[i], redundantPointSets);
      totalPointsRemaining += pathsToProcess[i].pathPoints.length;
      var dlgResults = new Window('dialog', 'Redundant Path Points');
      doResultsDialog(dlgResults,
      totalPaths,
      totalPointsWithRedundancy,
      totalPointsToRemove,
      totalPointsRemoved,
      totalPointsStarting,
      totalPointsRemaining,
      totalPointsSelected,
      tolerance);
    catch(er)
      if (exitError == 2) {
      alert("Select function not supported in conjunction with 'Include Locked Items' option.");
      if (exitError == 3) {
      alert("Select function supported only with 'Ignore' selection restriction.");
      if (exitError == 99) {
      alert("ACK! Unexplained error\n");
    * Dialog Code
    * Function: doInitDialog
    function doInitDialog(dlgInit) {
      var defaultTolerance = 5.0;
      var maxSliderTolerance = 5;
      /* Add radio buttons to control functionality */
      dlgInit.functionPnl = dlgInit.add('panel', undefined, 'Function:');
      (dlgInit.functionPnl.doAnalyze = dlgInit.functionPnl.add('radiobutton', undefined, 'Analyze' )).helpTip = "Find and count redundant points.";
      (dlgInit.functionPnl.doRemove = dlgInit.functionPnl.add('radiobutton', undefined, 'Remove' )).helpTip = "Find and remove redundant points.";
      (dlgInit.functionPnl.doSelect = dlgInit.functionPnl.add('radiobutton', undefined, 'Select' )).helpTip = "Find and select redundant points.\nWARNING:Manual removal of selected redundant points can change the shape of your curves.\nTips:Hiding bounding box helps to see which points are selected. Modify selection as desired and rerun script to remove specific redundant points.";
      dlgInit.functionPnl.doRemove.value = true;
      dlgInit.functionPnl.orientation='row';
      /* Add radio buttons to control point selection */
      dlgInit.selectionPnl = dlgInit.add('panel', undefined, 'Point Selection State:');
      (dlgInit.selectionPnl.ignoreSelected = dlgInit.selectionPnl.add('radiobutton', undefined, 'Ignore')).helpTip="Process redundant points on a path regardless of their selection state.";
      (dlgInit.selectionPnl.allSelected = dlgInit.selectionPnl.add('radiobutton', undefined, 'All')).helpTip="Process redundant points on a path only if each of them is selected.";
      (dlgInit.selectionPnl.anySelected = dlgInit.selectionPnl.add('radiobutton', undefined, 'Any')).helpTip="Process redundant points on a path if any one of them is selected.";
      dlgInit.selectionPnl.allSelected.value = true;
      dlgInit.selectionPnl.orientation='row';
      /* Add a checkbox to control options */
      dlgInit.optionPnl = dlgInit.add('panel', undefined, 'Other Options:');
      (dlgInit.optionPnl.includeCompound = dlgInit.optionPnl.add('checkbox', undefined, 'Include Compound Path Items?')).helpTip="Work on compound path items.";
      (dlgInit.optionPnl.includeLocked = dlgInit.optionPnl.add('checkbox', undefined, 'Include Locked Items?')).helpTip="Work on locked items or items in locked layers.";
      dlgInit.optionPnl.includeCompound.value = true;
      dlgInit.optionPnl.includeLocked.value = false;
      dlgInit.optionPnl.alignChildren='left';
      dlgInit.optionPnl.orientation='column';
      /* Add a slider and edit box for user entered tolerance */
      dlgInit.tolerancePnl = dlgInit.add('panel', undefined, 'Tolerance (in PostScript points):');
      (dlgInit.tolerancePnl.slide = dlgInit.tolerancePnl.add('slider', undefined, defaultTolerance, 0.01, maxSliderTolerance)).helpTip="Use slider to set a tolerance value in hundredths of a point.";
      (dlgInit.tolerancePnl.editText = dlgInit.tolerancePnl.add('edittext', undefined, defaultTolerance)).helpTip="Enter a tolerance value. Values greater then 5.0 or more precise than 1/100 point can be manually entered here.";
      dlgInit.tolerancePnl.editText.characters = 5;
      dlgInit.tolerancePnl.orientation='row';
      dlgInit.tolerancePnl.slide.onChange = toleranceSliderChanged;
      dlgInit.tolerancePnl.editText.onChange = toleranceEditTextChanged;
      /* Add a panel control removal options */
      dlgInit.removalPnl = dlgInit.add('panel', undefined, 'Removal Options:');
      (dlgInit.removalPnl.doKeepLeadingPoint = dlgInit.removalPnl.add('checkbox', undefined, 'Keep Leading Point' )).helpTip = "Keep the leading point (lowest path index, lowest prior to origin cross for closed path).";
      (dlgInit.removalPnl.doKeepTrailingPoint = dlgInit.removalPnl.add('checkbox', undefined, 'Keep Trailing Point' )).helpTip = "Keep the trailing point (highest path index, highest following origin cross for closed path).";
      (dlgInit.removalPnl.doKeepAveragedPoint = dlgInit.removalPnl.add('checkbox', undefined, 'Keep Averaged Point' )).helpTip = "Keep an averaged point to help smooth transitions.";
      dlgInit.removalPnl.keepTips = dlgInit.removalPnl.add('statictext', undefined, 'Keeping neither will cause position of remaining point to be averaged. Keeping both will anchor two ends of a segment while removing intermediate redundant points. An averaged point helps smooth transitions.', {multiline:'true'} );
      dlgInit.removalPnl.doKeepLeadingPoint.value = false;
      dlgInit.removalPnl.doKeepTrailingPoint.value = false;
      dlgInit.removalPnl.doKeepAveragedPoint.value = false;
      dlgInit.removalPnl.alignChildren='left';
      dlgInit.removalPnl.orientation='column';
      /* Add execution buttons */
      dlgInit.executeGrp = dlgInit.add('group', undefined, 'Execute:');
      dlgInit.executeGrp.orientation='row';
      dlgInit.executeGrp.buildBtn1= dlgInit.executeGrp.add('button',undefined, 'Cancel', {name:'cancel'});
      dlgInit.executeGrp.buildBtn2 = dlgInit.executeGrp.add('button', undefined, 'OK', {name:'ok'});
      dlgInit.executeGrp.buildBtn1.onClick= initActionCanceled;
      dlgInit.executeGrp.buildBtn2.onClick= initActionOk;
      dlgInit.frameLocation = [100, 100];
      dlgInit.alignChildren='fill';
      dlgInit.show();
      return dlgInit;
    function initActionCanceled() {
      exitError = 1;
      dlgInit.hide();
    function initActionOk() {
      var proceed = true;
      exitError = 0;
      if (dlgInit.tolerancePnl.editText.text > 5.0) {
      proceed = confirm("Tolerance entered greater than 5.0 PostScript points. Proceed?");
      if (proceed) {
      dlgInit.hide();
    function toleranceSliderChanged() {
      dlgInit.tolerancePnl.editText.text = roundToPrecision(dlgInit.tolerancePnl.slide.value, 0.01);
    function toleranceEditTextChanged() {
      if (dlgInit.tolerancePnl.editText.text > 5000) {
      dlgInit.tolerancePnl.editText.text = 5000;
      dlgInit.tolerancePnl.slide.value = roundToPrecision(dlgInit.tolerancePnl.editText.text, 0.01);
    * Function: doResultsDialog
    function doResultsDialog(dlgResults,
      totalPaths,
      totalPointsWithRedundancy,
      totalPointsToRemove,
      totalPointsRemoved,
      totalPointsStarting,
      totalPointsRemaining,
      totalPointsSelected,
      tolerance) {
      /* Add static text to display results */
      dlgResults.resultsPnl = dlgResults.add('panel', undefined, 'Results:');
      dlgResults.resultsPnl.totalPaths = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPaths.txt = dlgResults.resultsPnl.totalPaths.add('statictext', undefined, 'Paths processed: ');
      dlgResults.resultsPnl.totalPaths.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPaths.val = dlgResults.resultsPnl.totalPaths.add('statictext', undefined, totalPaths);
      dlgResults.resultsPnl.totalPaths.val.characters = 10;
      dlgResults.resultsPnl.totalPaths.val.helpTip = "The number of paths processed.";
      dlgResults.resultsPnl.totalPointsSelected = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsSelected.txt = dlgResults.resultsPnl.totalPointsSelected.add('statictext', undefined, 'Total points selected: ');
      dlgResults.resultsPnl.totalPointsSelected.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsSelected.val = dlgResults.resultsPnl.totalPointsSelected.add('statictext', undefined, totalPointsSelected);
      dlgResults.resultsPnl.totalPointsSelected.val.characters = 10;
      dlgResults.resultsPnl.totalPointsSelected.val.helpTip = "The total number of points initially selected.";
      dlgResults.resultsPnl.separator0 = dlgResults.resultsPnl.add('panel');
      dlgResults.resultsPnl.totalPointsWithRedundancy = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsWithRedundancy.txt = dlgResults.resultsPnl.totalPointsWithRedundancy.add('statictext', undefined, 'Points with redundancy: ');
      dlgResults.resultsPnl.totalPointsWithRedundancy.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsWithRedundancy.val = dlgResults.resultsPnl.totalPointsWithRedundancy.add('statictext', undefined, totalPointsWithRedundancy);
      dlgResults.resultsPnl.totalPointsWithRedundancy.val.characters = 10;
      dlgResults.resultsPnl.totalPointsWithRedundancy.val.helpTip = "The number of points with redundancy.";
      dlgResults.resultsPnl.totalPointsToRemove = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsToRemove.txt = dlgResults.resultsPnl.totalPointsToRemove.add('statictext', undefined, 'Redundant points to remove: ');
      dlgResults.resultsPnl.totalPointsToRemove.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsToRemove.val = dlgResults.resultsPnl.totalPointsToRemove.add('statictext', undefined, totalPointsToRemove);
      dlgResults.resultsPnl.totalPointsToRemove.val.characters = 10;
      dlgResults.resultsPnl.totalPointsToRemove.val.helpTip = "The number of redundant points that would be removed.";
      dlgResults.resultsPnl.totalPointsRemoved = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsRemoved.txt = dlgResults.resultsPnl.totalPointsRemoved.add('statictext', undefined, 'Redundant points removed: ');
      dlgResults.resultsPnl.totalPointsRemoved.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsRemoved.val = dlgResults.resultsPnl.totalPointsRemoved.add('statictext', undefined, totalPointsRemoved);
      dlgResults.resultsPnl.totalPointsRemoved.val.characters = 10;
      dlgResults.resultsPnl.totalPointsRemoved.val.helpTip = "The number of redundant points that were removed.";
      dlgResults.resultsPnl.separator1 = dlgResults.resultsPnl.add('panel');
      dlgResults.resultsPnl.totalPointsStarting = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsStarting.txt = dlgResults.resultsPnl.totalPointsStarting.add('statictext', undefined, 'Total points starting: ');
      dlgResults.resultsPnl.totalPointsStarting.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsStarting.val = dlgResults.resultsPnl.totalPointsStarting.add('statictext', undefined, totalPointsStarting);
      dlgResults.resultsPnl.totalPointsStarting.val.characters = 10;
      dlgResults.resultsPnl.totalPointsStarting.helpTip = "The total number of points before processing.";
      dlgResults.resultsPnl.totalPointsRemaining = dlgResults.resultsPnl.add('group');
      dlgResults.resultsPnl.totalPointsRemaining.txt = dlgResults.resultsPnl.totalPointsRemaining.add('statictext', undefined, 'Total points remaining: ');
      dlgResults.resultsPnl.totalPointsRemaining.txt.alignment = 'right';
      dlgResults.resultsPnl.totalPointsRemaining.val = dlgResults.resultsPnl.totalPointsRemaining.add('statictext', undefined, totalPointsRemaining);
      dlgResults.resultsPnl.totalPointsRemaining.val.characters = 10;
      dlgResults.resultsPnl.totalPointsRemaining.val.helpTip = "The total number of points after processing.";
      dlgResults.resultsPnl.alignChildren='right';
      dlgResults.resultsPnl.orientation='column';
      dlgResults.note = dlgResults.add('group');
      dlgResults.note.txt = dlgResults.note.add('statictext', undefined, 'Combined results across paths qualified based on options');
      dlgResults.tolerance = dlgResults.add('group');
      dlgResults.tolerance.txt = dlgResults.tolerance.add('statictext', undefined, "Tolerance applied (in PostScript points): ");
      dlgResults.tolerance.val = dlgResults.tolerance.add('statictext', undefined, tolerance);
      /* Add execution buttons */
      dlgResults.executeGrp = dlgResults.add('group', undefined, 'Execute:');
      dlgResults.executeGrp.orientation='row';
      dlgResults.executeGrp.buildBtn1= dlgResults.executeGrp.add('button',undefined, 'OK', {name:'ok'});
      dlgResults.executeGrp.buildBtn1.onClick= resultsActionOk;
      dlgResults.frameLocation = [100, 100];
      dlgResults.show();
    function resultsActionOk() {
      exitError = 0;
      dlgResults.hide();

    you have said you are using cc.
    is it fully up to date?
    are you not using cc2014?
    when run from ESTK are you sure it is pointing to the correct illustrator?

  • Is there a way to get Illustrator to know how many pixels are in an inch?

    Hi, this is my very first post so please be gentle!
    I've scoured these forums and found no solution to this problem.
    I'm using Illustrator CS5 to make graphics for print. I need to print said graphics at 300 DPI, but this seems impossible.
    Illustrator has plenty of settings that tell you it's at 300 DPI, but it never ever is.
    Here's the new file dialog:
    In this example, I'm making an image that I want to print on a letter sized piece of paper. The example is square, but that's not important. 8.5 inches at 300 DPI is 2550 pixels. Watch what happens when I change the unit to pixels:
    Despite the raster effects set to 300 PPI at the bottom, it thinks that 8.5 inches is 612 pixels, which is 72 DPI, NOT 300. Watch what happens when I choose the correct pixel resolution then switch it back to inches:
    It actually thinks I want to print a 35 inch poster with horrible gif resolution.
    You might say that the pixels are the only thing that matters when it comes to print, and you'd be correct, if I didn't want to print via a PDF. When I save a drawing like this at the correct pixel resolution to PDF, then try to print it at the actual size (300 dots to an inch), I get something like this because Acrobat thinks I have a 35 inch high document:
    Well, you might say, why don't you just print it to fit and you'll be fine? Sure, I can tell my print dialog to fit it to the page, but it doesn't fit it to the actual page size, it fits it to the printable area, which is maybe an 1/8th of an inch smaller on every side of the page, which means my 300 dots will never fill an inch exactly on my printer. I could never in a million years print a usable ruler.
    Before you ask, yes the Document Raster Effects Settings are also 300 PPI and it has no effect.
    Does anyone know what I'm doing wrong?

    Coming late, and maybe it's covered, but I noticed this earlier quote: ""I use Save As, then choose PDF from the dropdown menu. The actual size of the PDF will be 72 PPI. I can try printing to PDF, and see if it makes the same giant PDF..."
    I think you may be getting hung up on resolution when there isn't one. PDF files DO NOT HAVE A RESOLUTION. Like Illustrator files, they are a vector format.
    A PDF file might contain no images at all, then it is impossible to talk of resolution at all. Or it might contain images, but these might all be different resolutions. Sometimes, it so happens that all the images have the same resolution, then it is just about possible (but not necessarily useful) to talk about resolution. A number of utilities claim to report the resolution of a PDF but just make it up! Where did you get the 72 dpi figure?
    Another common error is to think of "100% scale" as being a universal thing, and expecting something viewed at 100% to be the same size in all apps, so to think something is wrong when they are not. This is simply an error: each app has its own different idea of what 100% means and you cannot compare apps this way.
    If you want to know the size of a PDF, first realise each page COULD BE a different size, though they usually aren't. Open in Acrobat and hover the mouse in the bottom left corner until the size appears. This is in inches/mm; remember there cannot be a size in pixels.

  • Can I find out how much a placed image is enlarged/reduced in Illustrator?

    I often draw maps using scanned USGS maps as a background image, sort of a hybrid vector/raster map with trails and labels added in Illustrator and the TIFF staying part of the finished map showing contours, texture, etc..
    When I start a map I enlarge the scanned map to fit the book format, then I trace the parts I want to replace. The scale of the scans vary, but for the final product I need them displayed at 100% of actual size, at a standard resolution such as 300 dpi.
    The way I'm used to working in FreeHand is I position the scan to where I want it and the size that works best for the book format. Then I can use the object inspector to verify what the enlargement of the scan is displayed at  (say x=70%, y=70%). I write that down, then open the TIFF in Photoshop and adjust the scan by that percentage (multiply pixel dimensions by 70% and set dpi to 300) and make my other edits. Then when I go back to FreeHand map, the scan relinks; if I change the display percentage in the inspector and I haven't cropped the scan closer, then it snaps into position at 100% and 300 dpi, and the map is ready to make into an EPS for the graphic designer to drop into the book.
    In Illustrator I've found no dialogue box that can tell me the current enlargement or reduction of the scan vs. its original size. Is there such a feature and I just haven't found it?
    In the Control bar when I select the scan there is an item that tells me the ppi (display resolution) of the scan. Hmm.  I guess I could use that and compare it versus the native PPI in Photoshop, and type in the desired number, somewhere, to get the scan resolution at 100% for the Illustrator finished map. It's probably MORE direct once I figure out which figure to type where (in Image/Adjust/Image SIze).  Maybe I don't even need to know the RATIO, just the PPI I have and the PPI I want.
    But to the extent it's useful to know "the scan is 70% smaller than it should be" it's a big piece of missing information - and I wish there were a way to find this out at a glance.
    Ideas?
    An aside: One workaround I've found in Illustrator CS4 is to make an artboard that crops to the display area of the scan, then turn off all but the scan and export the resulting file as a TIFF at 300 dpi. Then bring in that scan and place it aligned to the artboard - it sits right where I want it. THAT part is cool. But I am not 100% comfortable exporting a book's worth of background art that all the TIFFs will come out perfect from Illustrator - I feel a little more comfortable letting Photoshop do the resizing.

    Thanks, Wade. It's not perfect but it starts to do what I want.
    So my first impression is, Oh joy - I'm supposed to use a dialogue box that is three layers down in the pull-down menu, will only work if I pre-select the object, doesn't let me preview the change, and disappears as soon as I make a single adjustment (it can take a lot of nudging to get a scan positioned just right. Click, click, click, click, click).  Got anything better?
    Then I went to see where you "turn the effect on or off." (Your saying it's so gave me a little more perseverance). It is NOT done in the Effects list. Clicking there brings up a warning that I'm about to apply the effect again (though unlike some "apply again" commands, the scale values reset to 100%). The warning also says I can double-click on the effect name to adjust the settings of the first time I applied that effect.
    Now where would I do that? Reading again, it's in the Appearances dialogue box (i.e. somewhere else). Indirect and klutzy as it first seems, it kinda works. Selecting the scan, opening the appearances box, there's a list of ALL the effects applied to the object. Clicking on the particular effect  (transform) brings up the same transform dialogue box WITH the settings I had changed (scale, angle, etc). Now I can change the values, click OK (the transform box disappears again, drat) and see my changes. Click again on the effects list in Appearances, and the transform box comes right back up, so it's fairly easy to apply, rinse, repeat until things are where I want them.
    So as a series of adjustments, the Transform Effect does provide a record of what the current scale settings are, and I think I can make that work. I'll try it out on my partner and see if she says "hooray" or "are you kidding?"
    Why this feature is not obvious, is controlled somewhere entirely different than where it's applied, and why the regular transform dialogue box doesn't work this way, is another matter.

  • Merge InDesign, Illustrator and Photoshop together?

    Wouldn’t it be great to have everything you need in one app?
    Actually, there are currently some applications like this.
    Take a look at DAWs. They deal with recorded audio (similar to bitmap) and MIDI (like vector) at the same time.
    And if you are looking for a visual stuff you can check SideFX Houdini. They have several contexts for dealing with the data: 3d models (sops), various input data (chops), compositing context (you can do image color correction, layering etc.), shader context, programming, rendering contexts etc. And you can have each of them any place you want. This + the fully procedural approach makes Houdini one of its kind application that gives you endless possibilities to build complex effects, models and animations. You can even build your own tools, like city generating assets (as seen in Inception or 2012 movies). You can even write music and manipulate robots in this app (if you want to).
    So it is totally possible to fuse those apps together. Certainly it is a huge amount of work. But think of it: you now have to install Phantasm to apply Curves or Hue/Saturation in Illustrator, you have inner shadow in InDesign and Photoshop but not in Illustrator, you have good Paragraph and Character styles in InDesign but half-assed in PS and Illustrator, also grids, object styles, link management and so on. Wouldn’t it be great to have everything at once? Like in Houdini? You choose image and you can do what can be done with raster, you choose text and context changes to show what can be done with text. I’ve been dreaming about it for years.

    Hi, Dov:
    On Mac OS X and Windows, it's possible to easily switch from one OPEN/ACTIVE/RUNNING application to another, with a simple keystroke shortcut.
    So, in a sense, the tools are in one's toolbelt, ready for use, now. Or, from another view, the tools are in the equivalent of a Swiss Army Knife (SAK,) but not quite. Actually, it's usually awkward to switch from one SAK tool to another - depending on where they're located on the SAK body, some combinations of tools can be open at the same time. For example, the corkscrew, awl, or Phillips screwdriver can be open on the back, while a file, scissor, or eating utensil can be open on one or the other end of the front. The user can orient the SAK one way or another to use an open tool. A few tools can be removed, like the tweezer and toothpick, so there's a tad more flexibility.
    The multiple Creative Suite applications can be open at the same time. However, if the computer lacks sufficient resources, there's an awkward delay in switching from one application to another, while resources scramble to meet the users' requests.
    Perhaps the understood but unstated wish is that the tools were more-efficiently integrated, so that switching from one set of functions to another within an integrated application, would demand less from the resources, compared to the current model of switching from one standalone application to another.
    It's a fascinating wish. However, wish with care. Some SAKs used to have lifetime warranties. "If it breaks, we'll replace it." The problem is that when the broken item is returned, the user is without all the tools during the replacement. In the integrated-application model, the analog is when a bug hits, fixing it will require testing the complement of integrated applications to verify that the fix didn't break something somewhere else. Hence, users may be stuck with the buggy version longer, before a fix can be developed, tested, and certified.
    As hardware continues becoming ever-more powerful, eventually, pauses due to switching among independent applications will be less and less annoying.
    Regards,
    Peter
    Peter Gold
    KnowHow ProServices

  • OLE embedded Adobe Illustrator Artwork files not rendering properly

      I'm using BroadVision's Quicksilver.  I've attempted to embed AI Artwork
    files as OLE objects (linked and not linked), but they don't render within
    Quicksilver.  After working with their support team, they came to the
    conclusion that it was an Adobe Illustrator issue because they were
    able to reproduce the issue in Wordpad (not MS Word).
      The problem can be reproduced by the following steps (tested in Vista,
    XP, & Server 2008):
    :- Open Wordpad
    :- Click Insert -> Object -> Create From File -> Browse -> Find and select a file -> Open
      Other variations on this theme encounter the same problem, including
    pasting it from the clipboard.
      If you open a Wordpad document in MS Word and embed the OLE
    object, it saves a preview of the image which is visible from Wordpad
    if you open it later on (as long as you don't link to the original; if you do,
    and attempt to update the link, the preview image will go away).  However,
    subsequent alterations of the OLE object don't show up in Wordpad -- rather,
    the image that was rendered in Word continues to be displayed (unless, of
    course, you open it in MS Word again and re-save after the link is updated).
      It appears the support team at another company encountered a user
    experiencing the same or similar issues with their product, but on
    Illustrator CS2 as opposed to CS4:
    http://www.graphpad.com/faq/viewfaq.cfm?faq=1309
      Unfortunately, the "export to another format" workaround won't suffice.
    We're working with thousands of Illustrator artwork files that need to be
    version controlled, and other technical documents will link to the same
    Illustrator file.  When an AI file is updated, all technical documents
    need to use the altered version; linking to an exported version of the
    file just creates one more link in the chain that can create problems
    or confusion.
      Even if the version control stuff wasn't an issue, exporting to other
    formats seems rather limited.  If we export to other formats (eg, pdf)
    the images render poorly compared to what they look like in AI.
      We've tried a number of things to work around this:
    * Make sure AI [is/is not] already running
    * Rasterize paths
    * Alter the size of the image in AI
    * Alter the size of the object in the target application
    * 'Save as' with a different version of AI selected (for all versions)
    * Saving as an EPS or PDF -- the former has the same rendering issue
      as AI files; the latter renders but the drawing is blocky, probably because
      the graphics are being rendered at a very low resolution and scaled up
      after the fact.
    * Looking for or changing preferences in Illustrator that might affect it
    * Altering color scheme and various other similar settings
    * CS5 trial version -- same problem as CS4
    * Save the [wordpad] document -> close -> re-open
    * Switching between 'display as icon' and displaying the image
    * Copy & paste from various sources (from AI -> Wordpad,
      MS Word -> Wordpad, etc)
      The only way I can get it to render in Wordpad (or quicksilver for that matter)
    is if I embed the AI file in a Word/RTF document, then embed that in
    the target application (which is awfully convoluted).  Furthermore, if the
    embedded Word/RTF file links to the original file, when you open the
    document containing the embedded Word/RTF it doesn't attempt to
    update from the linked AI file, just the linked Word/RTF file.
      I'm sure there's other things we've tried to resolve this, but that's what comes
    to mind right now.
      If anyone can help with this, or clue me in that it's a bug in AI, I'd sincerely
    appreciate it.
    -Brian

    Well, no offense
    -=-=-=-=-=-=-=-=-=-=-=-=-
    None taken.  I'm helping someone else solve a technical problem, I'm just not questioning their approach; I'm not a tech writer, so I'll pass your suggestions on.
    -=-=-=-=-=-=-=-=-=-=-=-=-
    (...) you are trying  to solve one hell of a crooked workflow on the wrong end and the one  fatal flaw being that you insist on using an office tool to create  layouts and expecting it to render print-ready documents.  That just  cannot work. Even the most stubborn tech writers I occasionally work  with, recognize the need for eventually firing this at InDesign/ InCopy/  Framemaker and associated server versions and fuse the imported RTF/  Word documents and illustrations based on template layouts, scripting  and rule-based formatting, which can all happen automnatically on a  server with the respective software.
    -=-=-=-=-=-=-=-=-=-=-=-=-
    I was mistaken when I described how things are version controlled.  They would prefer to embed the AI images in each document and have each document be version controlled (that is, if the image changes it should /not/ affect other documents).
    However, I wasn't mistaken when I said there are thousands of already developed AI images.  The team working with these images has already procured a volume license for Framemaker and is hesitant to purchase other software unless there's no alternative, or the time savings would justify it.  I wish I could comment on the efficacy of your suggestion, but I'm not a tech writer; I'm unfamiliar with InDesign, InCopy, and FrameMaker.
    -=-=-=-=-=-=-=-=-=-=-=-=-
    So for what it's worth, you are  probably wasting your time and resources on something that by its nature  starts out with a limited process. I'm not even sure if AI fully  supports OLE. I seem to remember having read about it not supporting  several features and commands....
    -=-=-=-=-=-=-=-=-=-=-=-=-
    -=-=-=-=-=-=-=-=-=-=-=-=-
    If we export to other formats (eg, pdf) the images render poorly compared to what they look like in AI.
    What  do you mean? If they look "bad" in Acrobat or something, then you are  simply using the wrong export settings. which is perfectly fixable.
    -=-=-=-=-=-=-=-=-=-=-=-=-
     In Acrobat the SV graphics look beautiful at any scale, but if the PDF is OLE embedded in another application it looks terrible.
    -=-=-=-=-=-=-=-=-=-=-=-=-
    If  they look "bad" within your word documents, then we pretty much return  to what I said in the first paragraph - there's a good chance it's  simply Word rendering the artwork poorly due to its limited abilities of  dealing with graphics of any kind. I would even think that manually  changing the graphics properties would improve appearance then....
    -=-=-=-=-=-=-=-=-=-=-=-=-
    I'm not an expert on OLE; I made the [potentially bad] assumption that Acrobat would be responsible for rendering the graphic when a PDF is OLE embedded, so the application making use of the object would have limited control over the quality of the image it receives (if my assumption were correct anyway).
    I know the host process can specify whether the image is rendered as an EMF or WMF image, otherwise I know very little about the OLE API and what limitations the host process can impose.
    I'll keep tinkering to see if the PDF solution can be made to work.
    In the meantime, would anyone like to make a determination as to whether this is a real bug in AI or not?
    -Brian

  • Save error when exporting to PNG in Illustrator using a Macbook with Yosemite

    Anybody experience the issue of png being saved with "/" in the beginning of the file name when exporting to png in Illustrator? This only happens when I use my mac not my PC.
    Due to the save error my PC cannot identify the files and when the files are linked in Indesign they are not copied when packaging the indesign file.
    Any advice on the issue are most appreciated

    I don't have a lot of experience with this kind of problem, but the first thing I'd check is the parameter block you're passing the action call. I don't know why it would matter if the dialog appeared or not, unless the export settings block wasn't being filled in with everything it needs?
    You might try recording an export you perform manually via the action palette, and then saving it to a file. You can open it up manually and compare it (even if it's a binary block) to what you're doing in code. You might spot something that way.
    I don't know what else to suggest though. It's unlikely to be an SDK bug, though it could be a bug in the action-aware part of the exporter.

Maybe you are looking for

  • Itunes won't open because of audio configuation

    When I try and open itunes I get this Itunes cannot run because it has detected a problem with your audio configuration What should I do?

  • HTTP adapter URL Parameter

    HI we are currently integrating a http to rfc connection with the URL in the format of http://sdn.sap.com?name=Joe&country=India we want to pass the url parameters name and country to a rfc in sap but we are having difficulties using the apply URL Pa

  • My macbook pro gives me small shocks when plug in

    my macbook pro gives me small shocks when plug in.\ en he trill a little bit :/

  • Can't create own ringtones anymore

    it's unbelievable at how greedy iphone can be at disabling creating your own ringtones, to update the itunes just get rid of this ability smacks of nothing but greed, hope your pleased with your greedy pathetic little selves

  • Is iWeb 09 for Tiger as well as Leopard ?

    Well- that's all I wanted to ask ! I use 10.4.11 + Tiger, and didn't really want to update because I know that both 10.5 and Leopard were not fully compatible with Logic Studio, which I use daily. However, I received a strong tip that it's much easie