Jun 98 Online
Volume Number: 14
Issue Number: 6
Column Tag: MacTech Online
Plug In and Reach Out
by Jeff Clites, online@mactech.com
A plug-in architecture can be a clever way to add power and value to your application.
It allows third parties to extend the capabilities of your product, and allows you to do
the same without the need to redistribute the entire application to end users, and
without the danger of adding bugs to the core code as you add features.
The Component Manager
It is natural to think of an application plug-in as analogous to a system extension, but
there is a crucial difference: extensible applications are specifically designed to work
with plug-ins, and have a well-defined interface through which the plug-ins operate,
while INITs usually do their work despite the lack of such an interface, relying on
low-level mechanisms such as trap patching. As a result, plug-ins don't bring the
instability often associated with system extensions, and they tend to provide an
application with a specific service or capability, rather than modifying global
behavior.
Despite this distinction, certain parts of the Mac OS are designed to accommodate
plug-ins, and they do so using a powerful tool that you can use to give your own
applications a plug-in architecture: the Component Manager. Apple likens the
Component Manager to a Resource Manager which acts on function objects rather than
data objects. If you have ever executed a compiled script from within an application,
you have used the Component Manager. Many parts of the Mac OS are implemented via
components - AppleScript and Frontier are Scripting Components, QuickTime uses
components for image decompression and for video effects, and the Translation
Manager uses components to enable Mac OS Easy Open to covert files between formats.
You can write components which will only be used by your application, or which will
provide their services globally, to any application which requests them. Start learning
about the Component Manager from its chapter in Inside Macintosh: More Macintosh
Toolbox, and then visit the QuickTime 3.0 documentation for recent changes. Also be
sure to look at the sample code which Apple has provided. There is older code, which
shows you how to write a simple component, and newer code on the QuickTime 3.0 web
site which demonstrates how you can write components which apply video effects or
allow applications to import images stored in a new format. To round things out, there
is a Technote describing how the Component Manager handles PowerPC native
components.
Inside Macintosh: More Macintosh Toolbox
http://devworld.apple.com/dev/techsupport/insidemac/MoreToolbox/MoreTo
olbox-2.html
Inside Macintosh: QuickTime Components
http://devworld.apple.com/dev/techsupport/insidemac/QTComponents/QTCo
mponents-2.html
QuickTime 3.0 Developer Index
http://www.apple.com/quicktime/preview/develop/index.htm
Component Manager Sample Code
ftp://dev.apple.com/devworld/./Sample_Code/QuickTime/Component_Manage
r.sit.hqx
QuickTime 3.0 Sample Code
http://www.apple.com/quicktime/preview/develop/samplecode.html
Technote 1004: On QuickTime Component Manager 3.0 & PowerPC Native
Components
http://devworld.apple.com/dev/technotes/tn/tn1004.html
The most expansive example of using a component to supply services to multiple
applications is Internet Config, the source to which is in the public domain. Internet
Config has become indispensable as more and more applications become
internet-savvy, and it's a great example of using a component to save programmers
from the need to code in the same functionality over and over. The author's ftp site has
the source, which you can use as an example of good component design, and a
programmer's kit which shows you how to use Internet Config from within your
application. Dan Crevier has also written IC++, a C++ wrapper class for Internet
Config, which illustrates how you can make it even easier for you (or others) to call
your component from inside an application.
Internet Config FTP Site
ftp://ftp.quinn.echidna.id.au/Others/Quinn/Config/
IC++ Wrapper Class for Internet Config
http://www.boingo.com/dan/software/Programming.html
Using the Internet Configuration System
http://www.mactech.com/articles/mactech/Vol.11/11.04/Internet-Config/t
ext.html
Implementing Shared Internet Preferences With Internet Config
http://www.mactech.com/articles/develop/issue_23/quinn.html
Probably the most well-known type of application plug-ins are Photoshop plug-ins;
in fact, and entire industry has been built around them. You can get in on the fun by
downloading the Photoshop SDK from Adobe, which also has SDKs for plug-ins to their
other applications, including Illustrator and Acrobat. There are actually several
different types of Photoshop plug-ins - the most common are filters, which directly
manipulate images, but there are also image acquisition plug-ins, which let you drives
devices such as scanners from within the application, and import and export plug-ins.
It's possible to support Photoshop plug-ins in your own application, and many third
parties do this to increase, for instance, the image-manipulation power of their
applications. NIH Image is one example. It is an image processing and analysis
application developed by the National Institutes of Health and is widely used for
scientific imaging. Not only is it free, but its source code is in the public domain. It
supports some Photoshop plug-ins, so it can serve as a test bed for those developers
who want to experiment but don't own Photoshop, or who are designing their plug-ins
for the widest range of compatibility. The source code, of course, can help those
looking to support Photoshop plug-ins in their own application, or who want a model
for a plug-in architecture in general. The NIH Image ftp site also has a directory full
of plug-ins, some with source code, to serve as examples to developers and to augment
Adobe's SDK.
Adobe Developers Relations SDKs
http://www.adobe.com/supportservice/devrelations/sdks.html
NIH Image Home Page
http://rsb.info.nih.gov/nih-image/
NIH Image Mailing List
http://www.soils.agri.umn.edu/infoserv/lists/nih-image/
Last, But Not Least
A plug-in architecture is a Good Thing. It can reduce the size of your application,
decrease its memory footprint, and promote good design by encouraging you to factor
your application into functionally independent pieces and prepare it for future
enhancements. While implementing a new design strategy, it's always good to have
some printed material on hand. Plug-ins are code fragments at heart, and the
definitive text on these is A Fragment of Your Imagination, by Joe Zobkiw. It has
chapters on the Component Manager and on Photoshop filters, as well as covering
system extensions and most other related topics, and there is even an accompanying
web site.
A Fragment of Your Imagination
http://www.triplesoft.com/fragment/
These and other links are available from the MacTech Online web pages at
http://www.mactech.com/online/.