- Adobe indesign cs4 pdf free

Looking for:

Adobe indesign cs4 pdf free -  

Click here to DOWNLOAD

     

Create A Hyperlink in PDF File Using InDesign CS4 | PDF

 

Better World Books. Uploaded by ttscribe5. Search icon An illustration of a magnifying glass. User icon An illustration of a person's head and chest. Sign up Log in. Web icon An illustration of a computer application window Wayback Machine Texts icon An illustration of an open book.

Books Video icon An illustration of two cells of a film strip. Video Audio icon An illustration of an audio speaker. Audio Software icon An illustration of a 3. Please note that the content in this guide is protected under copyright law even if it is not distributed with software that includes an end user license agreement. The content of this guide is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Adobe Systems Incorporated.

Adobe Systems Incorporated assumes no responsibility or liability for any errors or inaccuracies that may appear in the informational content contained in this guide. Please remember that existing artwork or images that you may want to include in your project may be protected under copyright law. The unauthorized incorporation of such material into your new work could be a violation of the rights of the copyright owner.

Please be sure to obtain any permission required from the copyright owner. Any references to company names in sample templates are for demonstration purposes only and are not intended to refer to any actual organization. All other trademarks are the property of their respective owners. Notice to U. Government End Users. Consistent with 48 C. Government end users a only as Commercial Items and b with only those rights as are granted to all other end users pursuant to the terms and conditions herein.

Unpublished-rights reserved under the copyright laws of the United States. For U. Government End Users, Adobe agrees to comply with all applicable equal opportunity laws including, if appropriate, the provisions of Executive Order , as amended, Section of the Vietnam Era Veterans Readjustment Assistance Act of 38 USC , and Section of the Rehabilitation Act of , as amended, and the regulations at 41 CFR Parts through , , and The affirmative action clause and regulations contained in the preceding sentence shall be incorporated by reference.

Contents Introduction. It also is appropriate reading for experienced InDesign programmers who need a refresher. It introduces the files in the SDK, covers development tools, and pro- vides an initial plug-in development tutorial.

If you are new to InDesign development, completing the Getting Started tutorial will provide you the context necessary to review or try what is discussed in this document. Before getting too far into the technical details, it is important to understand that all InDesign products are developed from the same code base.

A plug-in can be written to load under any combination of InDesign products. Many Adobe plug-ins are compiled and deployed with all three applications. Each product application comprises a small executable that loads and initializes plug-ins.

Each executable does very little that is recogniz- able by an end user; instead, nearly all features are contributed by plug-ins. Plug-in classification There are several ways to classify InDesign plug-ins. For example, you may create an InCopy-only plug-in. Model plug-ins are those that write data to an InDesign document.

User-interface plug-ins are those that contain user interfaces. A plug-in can be both a model and user-interface plug-in, but this is not a best practice, and such a plug-in will not load in InDesign Server.

Third-party plug-ins cannot be con- sidered required. Working with bosses and instantiated boss objects is at the heart of InDesign plug-in development. This is demonstrated below. Interfaces and implementations Interfaces are purely abstract classes, commonly used in object-oriented systems to provide a common contract between callers and different underlying types.

Interfaces are not instantiated but instead can be implemented, meaning a subclass inherits the interface and provides definitions for all the pure virtual functions. The subclass is then instantiated. For example, InDesign includes several implementations of the IShape interface. Each implementation is unique, but all are accessible via the IShape interface.

Figure 1 gives you an idea what a boss looks like in memory. If it has more, each resource must be assigned a unique resource ID. This particular resource ID is a simple integer ID, unique within the plug-in. Since these IDs are not used outside the plug-in, typi- cally they are simple integers 1, 2, 3, Aside from those keywords and the braces, commas, and semi-colon, everything is a bit ID.

The second field is used to specify a parent boss. The example specifies a parent of kInvalidClass, meaning there is no parent. This is useful when you need to add functionality to existing InDesign objects; for example, the kDocBoss repre- sents an InDesign document. You may find it useful to create an AddIn for the kDocBoss.

The syntax for an AddIn is similar to a boss definition, but it specifies an existing boss in the first field. The second field, which specifies a parent in the Class definition, must be set to kInvalid- Class. Unique prefix-based IDs Each boss, interface, and implementation has a unique ID that identifies it within the space of all InDesign bosses, interfaces, or implementations.

The boss, interface, and implementation ID spaces are separate spaces, so your plug-in can safely use the same number for an interface and a boss, but there should be no overlap within a space; e.

The bit prefix you receive is reserved for use in your plug-in, giving you a maximum value of values for bosses, interfaces, or any other prefix-based IDs. Typically, this is more than enough for any plug-in; in fact, sometimes this is enough for a set of plug-ins. Table 1 lists the InDesign naming conventions for boss, interface, and implementation con- stants. This will help you quickly differentiate between bosses and interfaces and keep them separate from other groups of unique IDs.

For an example of such a file, see any of the sample plug-ins. IPMUnknown Interface classes that are used as a component of a boss are either provided by the SDK, such as ICommand, or written by the plug-in developer to provide some plug-in-specific function.

They can contain any types of methods, but to work as a component of a boss, they must inherit from IPMUnknown. AddRef and Release deal with reference counting. QueryInterface provides access to the other interfaces on the boss. If the boss contains an interface for the passed-in ID, it calls AddRef and returns a pointer to the interface; otherwise, it returns nil.

A reference count is maintained for the boss, not for the individual interfaces. When you call AddRef or Release on an interface, the reference count for the entire boss object is adjusted. Sometime after the reference count reaches zero this is not guaranteed to happen right away , the object model deletes the boss from memory. When your code needs to manage a reference to a boss object, you must call AddRef.

If this is not done, you run the risk of the boss being deleted while still in use. Likewise, when the refer- ence is no longer needed, the reference count must be deleted by calling Release.

If this is not done, you will create a boss leak which, in turn, creates memory leaks. In essence, you are allocating system resources and never freeing them.

Unless AddRef is called, the code cannot assume that fBar will point to a valid object when it is used later. In this case, MyClass holds a reference to the boss and needs to call AddRef. Destructors are not called until after the boss's reference count reaches zero. In this case, the reference count would never reach zero, so the destructor would never be called. Do not make this mistake! In other cases, it is entirely appropriate to pass an interface pointer to a function without calling AddRef.

For example, consider the CallBar example below. This method does not need to hold a reference to the boss. It simply performs some operation on the passed-in pointer; it does not save it for later use.

Most often, your code will acquire a reference to a boss, use it within a local scope, and eventually need to call Release. The object is created on the stack and initialized with a reference-counted interface pointer. When the InterfacePtr goes out of scope, it calls Release in its destructor.

It is important to understand what is really happening and the true benefits of using InterfacePtr. In this case, the InterfacePtr constructor calls QueryInterface on obj if it is non-nil. While we recommend including such an enumeration, it is not required. If IBar did not include such an enumeration, this code would fail to compile.

If it is, an InterfacePtr is constructed, but its data member is nil. If the data member is non-nil, the InterfacePtr destructor calls Release when the object goes out of scope. The constructor does nothing if the InterfacePtr's data member is nil. It is overloaded, to behave as if you are dealing with a real pointer; however, in the debug build, it asserts that the actual pointer is non- nil. This provides an opportunity to find crashes right before they occur.

In this example, the function might need to return abruptly due to an error condition. Since it uses an InterfacePtr, the code can just return. The InterfacePtr, which is constructed on the stack, is destructed on return, so Release is called automatically. Often, InDesign plug-in code queries for several interfaces.

If they are not stored in an InterfacePtr, the code must make sure each code path results in appropriate calls to Release. InterfacePtr tips and tricks Sometimes, you might want to set an InterfacePtr after it is constructed. This is common if the InterfacePtr can be initialized to different objects. There may be cir- cumstances where you need to remove the data from an InterfacePtr without calling Release.

For this case, InterfacePtr also supplies a forget method. The forget method sets the Inter- facePtr data to nil and returns the original data to the caller; therefore, it can be used to transfer ownership from an InterfacePtr to a caller. Often, you can re-use an existing interface. Sometimes, however, you will need to write an interface from scratch. Thus, we include IPMUknown. Each interface you write will be similar, but you will provide your own name, ID, and set of pure virtual functions.

Writing your own implementation Interfaces and implementations go together. Conceptually, the interface comes first, but it is not unusual to develop an interface and its implementation together. It also is not unusual to develop an implementation for an existing, Adobe-supplied interface. Because of how InDesign code is referenced, the compiler can be fooled into optimizing it away. This prevents the compilers from optimizing your code away because it appears not to be referenced.

It also adds a helper method, PreDirty , which is used only for persistent interfaces. The CPMUn- known mechanism is preferred, for its simplicity. This is required to initialize data in CPMUnknown. This variable follows a naming convention you see in most InDesign source files.

Each implementation you write will be somewhat similar. Constructing a boss instance There are several global functions for constructing or instantiating boss objects in the SDK header file CreateObject. There are different functions for creating persistent and non-persis- tent boss instances.

There is a slightly better way to do this, if the interface supports the kDe- faultIID enumeration. A nil pointer is returned if the designated boss cannot be cre- ated. This may seem unlikely, but it is possible for several reasons, most notably a missing plug- in. Persistence A persistent boss object can be removed from main memory and later reconstructed, unchanged. InDesign stores such objects in database files. An InDesign document really is just a database of persistent boss objects.

Each persistent boss instance can be identified by an inte- ger key called a UID unique identifier. The application maintains several different databases for various purposes. The application defaults, clipboard, and user-interface settings are saved in different databases.

Also, as men- tioned previously, each InDesign document is a database file. To do that, the boss must have at least one persistent implementations. Writing your own persistent implementation Persistent and non-persistent implementations are very similar.

If the values differ, it calls PreDirty before changing fMyInt. In short, the object model must know before you change a persistent object.

This allows the undo architecture to take snapshots, so changes can be rolled back if needed. This method is responsible for reading and writing the object's persistent data using the passed-in IPMStream. Examples of Persistent Implementations There are many examples of persistent implementations in the SDK sample projects.

For a fairly straightforward example, consider the Frame Label project. See the FrmLblData. There also is no need to create an instance, because the application already manages these bosses. Most examples differ from the above only in inconsequential ways.

For example, a mutator SetXXX method may not check to see that a data member has really changed before calling PreDirty ; this check is an optimization. What differs across examples is the data the implementation manages. Each ReadWrite method is crafted to match the data to be persisted.

It is a good idea to look at a handful of examples. Happily, such a guide exists and you can download it for free. Great stuff, and guaranteed to help you win any InDesign trivia contest and achieve Alpha Geek status.

Linda Judd. Please log in again. The login page will open in a new tab. After logging in you can close it and return to this page. Advanced Search. Forgot Password? Join today. Not a member? Recommended For You.