===========================================================
           INSIDE OLE BY KRAIG BROCKSCHMIDT
                    COMPANION DISC
       COPYRIGHT (C) 1995 BY KRAIG BROCKSCHMIDT
===========================================================

This file describes the contents of the directories found on the
sample CD.  For complete information about individual source
code files, consult the comments in the files themselves.


ROOT DIRECTORY ON CD
----------------------

    CODE\*.*        Contains the sample code tree, which should
                    be copied to C:\INOLE.

    16BITOLE.WRI    "Notes Concerning 16-Bit OLE" describing
    16BITOLE.RTF    differences between the book text, which is
                    written for 32-bit OLE, and 16-bit OLE.

    APPA.WRI        Appendix A, "An Introduction to C++"
    APPA.RTF        Which supplements Chapters 1 and 2 for C
                    programmers who need a familiarity with C++
                    to read this book effectively.

    APPB.WRI        "The Details of Standard Marshaling," a
    APPB.RTF        supplement to Chapter 6.


    BUILD.TXT       Details about the sample code build process.
    CONTENTS.TXT    This file you are now reading.
    ERRATA.TXT      Corrections to the printed text.
    README.TXT      Read this first!

    SETUP.EXE       The setup program that will copy the sample
    SETUP.INI       code to your machine from the CD.
    SETUP.TXT



INSTALLATION DIRECTORY FOR SAMPLE CODE:
----------------------------------------

COMMON FILES THAT OCCUR IN MANY DIRECTORIES


    File            Description
    --------------------------------------------
    about.dlg       Dialog template for About box

    client.cpp      Client-area object code for samples based on
                    CLASSLIB (primarily Cosmo, Component Cosmo,
                    and Patron)

    <sample>.ico    Program icon
    <sample>.rc     Resources for the sample

    document.cpp    Document window object code for all samples based on
                    CLASSLIB (primariliy Cosmo, Component Cosmo,
                    and Patron)

    document.ico    Document window icon for MDI samples based on
                    CLASSLIB (primariliy Cosmo, Component Cosmo,
                    and Patron)

    gizmo120.bmp    Toolbar images for 120dpi
    gizmo72.bmp     Toolbar images for 72dpi
    gizmo96.bmp     Toolbar images for 96dpi

    makeall.bat     Build script for everything in the given
                    directory and in all subdirectories.
    makefile        Makefile

    precomp.cpp     Source file to pull in the right header file
                    for making a precompiled header.

    resource.h      Definitions of resource identifiers.

    win16.def       16-bit module definitions
    win16.def       16-bit registry information

    win32.def       32-bit module definitions
    win32.def       32-bit registry information




ROOT DIRECTORY

    File            Description
    --------------------------------------------
    inole-a.mak     Definitions of symbols, compiler flags,
                    linker flags, and makefile rules.
    inole-b.mak     Linker scripts
    makeall.bat     Global build script
    mksamp1.bat     Default script for building an MDI or SDI
                    sample, depending on the SDI environment variable.
    mksamp2.bat     Default script for building a simple sample
    mksamp3.bat     Default script for building a simple sample in
                    a second-level directory (one deeper than mksamp2.bat)



BUILD DIRECTORY

    Binary EXE and DLL files for all the samples.  INOLE.DLL is
    the most important, which should be in your PATH when attempting
    to run most of the book's samples.



COSMO SAMPLES IN VARIOUS DIRECTORIES

    Cosmo is a sample intended to show how you can convert
    Windows API-based application features into OLE-based
    features, and serves as the primary example for compound
    document content objects.  It evolves throughout the book
    as decsribed below:

    Directory           Description
    --------------------------------------
    CHAP01\COSMO        Fully functional version of Cosmo written
                        entirely with the Windows API using no OLE
                        whatsoever.

    CHAP07\COSMO        File I/O is convered to use Compound Files.

    CHAP12\COSMO        Clipboard code is converted to use the OLE
                        clipboard protocol and data objects.

    CHAP13\COSMO        Adds OLE Drag & Drop

    CHAP14\COSMO        Adds OLE Automation support to the entire
                        application (this chapter's sample is based on
                        Chapter 12's version)

    CHAP18\COSMO        Adds OLE Documents support for embedding,
                        using Chapter 13's version as a base (to avoid
                        complicating the scene with OLE Automation).
                        Cosmo is a server for a gaphical "Figure" type
                        of content.

    CHAP21\COSMO        Adds OLE Documents support for linking,
                        improving on Chapter 18's sample.

    CHAP23\COSMO        Adds in-place activation support to the
                        Chapter 21 sample


    CHAP18\COSMO1.0     Cosmo's 1.0 version, which supported
                        OLE Documents using OLE version 1.  Not
                        fully supported under 32-bit.  Provided
                        only as an example for conversion and
                        emulation as described in OLE1.WRI.



    COSMO SOURCE FILES
    ------------------

    This table lists Cosmo's specific files (excluding those
    that were listed as "common" above), the chapter where the
    file first appears, and the purpose of that file.

                Appears
    File        in chapter:     Description
    ----------------------------------------------------------
    cosmo.cpp       1           Frame window handling for cosmo.
                                Also receives the IOleInPlaceFrame
                                code in Chapter 23.
    cosmo.h         1           Main header file

    document.cpp    1           Document object code, implements
                                IOleInPlaceUIWindow in Chapter 23.

    polyline.cpp    1           Object code for Polyline window
                                class, where the figure is drawn
    polyline.h      1           Polyline's header file
    polywin.cpp     1           Polyline's window procedure

    dropsrc.cpp     13          Implementation of drop source object
                                for OLE Drag & Drop
    droptgt.cpp     13          Implementation of drop target object
                                for OLE Drag & Drop

    iclassf.cpp     14,18       Implementation of Cosmo's class factory
                                object.  It appears in Chapter 14 for
                                OLE Automation.  A different one appears
                                in Chapters 18 and beyond for OLE Documents.

    cosmole.h       18          Header file for OLE Documents specifics.

    figure.cpp      18          The "embedded" or "linked" content object
                                implementatation that wraps the Polyline
                                code into a "Figure" content object.

    idataobj.cpp    18          IDataObject implementation for the Figure.
    ioleobj.cpp     18          IOleObject implementation for the Figure.
    iperstor.cpp    18          IPersistStorage implementation for the
                                Figure.

    iperfile.cpp    21          IPersistFile implementation for the Figure
                                to support linking.

    iipaobj.cpp     23          IOleInPlaceActiveObject implementation for
                                the Figure's in-place activation.
    iipobj.cpp      23          IOleInPlaceObject implementation for
                                the Figure's in-place activation.


    These appear only in Chapter 14:
    -----------------------------------
    autoapp.cpp     "Application" object code for OLE Automation
    autobase.cpp    Base class implementation used for all OLE Automation
                    objects in autoapp.cpp, autofig.cpp, and autofigs.cpp.
    autofig.cpp     "Figure" object code for OLE Automation
    autofigs.cpp    "Figures" collection object code for OLE Automation
    cosmo000.odl    Cosmo's ODL script defining its OLE Automation
                    interfaces.




COMPONENT COSMO SAMPLES IN VARIOUS DIRECTORIES

    Component Cosmo is a variation of Cosmo which uses a
    COM-based version of a Polyline object, which is an internal
    C++ class in Cosmo.  It evolves in a similar vein to
    Cosmo throughout the early part of the book as decsribed below:

    Directory           Description
    --------------------------------------
    CHAP05\COCOSMO      First manifestration of Component Cosmo
                        in the chapter where Polyline is first made
                        a COM component.  Communication between
                        CoCosmo and Polyline happens through a
                        custom interface as well as connection points.

    CHAP08\COCOSMO      Uses IPersist* interfaces to save and load
                        Polyline data instead of custom interface
                        members.

    CHAP10\COCOSMO      Uses IDataObject to exchange data with the
                        Polyline object instead of custom interface
                        members.

    CHAP12\COCOSMO      Converts existing clipboard support to use
                        the OLE Clipboard.

    CHAP13\COCOSMO      Adds OLE Drag & Drop.

    There are no revisions of Component Cosmo after this, although
    a README.TXT in the COCOSMO directory of chapters 19, 21, 23,
    and 24 describe simple modifications to make CoCosmo work with
    later versions of Polyline.


    COCOSMO SOURCE FILES
    --------------------

    This table lists Component Cosmo's specific files (excluding those
    that were listed as "common" above), the chapter where the
    file first appears, and the purpose of that file.

                Appears
    File        in chapter:     Description
    ----------------------------------------------------------
    cocosmo.cpp     5           Frame object code
    cocosmo.h       5           Main application header file
    iadvsink.cpp    10          Implementation of a simple object
                                with IAdviseSink to receive data
                                change notifications from the Polyline.

    dropsrc.cpp     13          Implementation of drop source object
                                for OLE Drag & Drop
    droptgt.cpp     13          Implementation of drop target object
                                for OLE Drag & Drop




POLYLINE SAMPLES IN VARIOUS DIRECTORIES

    Polyline begins life in Chapter 5 as a COM object that is
    broken out of Cosmo.  Instead of being an internal C++ object,
    Polyline becomes a COM object with a custom interface, and
    over time we add more interfaces to the object, eventually
    making it into a compound document content object and a
    partial OLE Control.  Various manifestations of Component
    Cosmo use versions of this sample, which evolves as described
    in the table below:


    Directory           Description
    --------------------------------------
    CHAP05\POLYLINE     First manifestation of Polyline which implements
                        a custom interface IPolyline5, as well as
                        connection point support for its own notification
                        set, IPolylineAdviseSink5.

    CHAP08\POLYLINE     Persistence support removed from IPolyline5
                        which now becomes IPolyline8, and added through
                        IPersistStorage and IPersistStreamInit.

    CHAP10\POLYLINE     Data exchange support removed from IPolyline8
                        which now becomes IPolyline10, and added through
                        IDataObject and support for sending data changes
                        through IAdviseSink.

    CHAP19\POLYLINE     Adds support for OLE Documents embedding with
                        the interfaces IOleObject, IRunnableObject,
                        IViewObject2, and those necessary for caching.

    CHAP21\POLYLINE     Adds support for a container's linking to
                        embedding feature, which means handling
                        monikers and implementing IExternalConnection.

    CHAP23\POLYLINE     Adds in-place activation support with
                        IOleInPlaceObject and IOleInPlaceActive object,
                        and is marked OLEMISC_ACTIVATEWHENVISIBLE.

    CHAP24\POLYLINE     Becomes a partial OLE Control with IOleControl
                        and IDispatch, and supports its own property page.


    POLYLINE SOURCE FILES
    ----------------------