Try the all-new QuickBooks Online for FREE.  No credit card required.

IDL ActiveX Controls

Document Sample
IDL ActiveX Controls Powered By Docstoc

Technical whitepaper describing COM, ActiveX,
and the IDL ActiveX Control
      ActiveX has taken the world of Microsoft Windows development by storm. ActiveX has rapidly gained
      acceptance as a component programming standard and represents an incredibly fast growing

          ActiveX furnishes Windows programmers with a set of technologies that enable software components
          to interact, regardless of the language in which they were written. Programs can now be written by
          incorporating or plugging-in commercially-available components. One of the most popular of the
          ActiveX programming environments is Visual Basic (VB), with an estimated user base of over 2.5
          million. But ActiveX is not limited to VB and can be incorporated into almost any Windows
          development environment including VC++, FoxPro and Delphi.

          The IDL (Interactive Data Language) ActiveX Control introduces advanced data analysis and
          visualization capabilities to Windows developers, and allows them to maintain preferred syntax−VB
          syntax when used in VB, * MFC classes when used in C++, Pascal interface with Delphi, and VBA
          interface for MS Office applications. It transforms a familiar visual programming environment into a
          valuable scientific toolkit. In addition, the IDL ActiveX Control delivers Microsoft standard graphical
          user interface controls to IDL developers. Graphical user interface development in IDL is no longer
          limited to internal IDL widget availability. IDL programmers can now tap into the huge, pre-built GUI
          market of ActiveX Controls and Visual Basic components. This is an ideal setting for accelerating
          market growth of IDL.

          The IDL ActiveX control differs from many repackaged component technologies that offer scaled-
          down, single-function versions of larger applications. The IDL ActiveX Control does not pre-determine
          which IDL functionality will be needed and does not insulate the user from the Interactive Data
          Language. Through a single ActiveX interface, the IDLDrawWidget, IDL features are exposed. Since
          the control augments IDL instead of replacing it, familiarity with IDL programming is essential.

      ActiveX began with an effort to enhance the functionality of existing programs by combining the
      features of two programs so they appear to work as one. The resulting combination was known as a
      compound document. Object linking and embedding (OLE) technology brought the concept to life.
      Through OLE, it became possible to link one document to another or embed one program within
      another. A classic example of a compound document is an Microsoft Excel spreadsheet embedded
      within a Microsoft Word document.

          As this technology evolved, engineers raised the sights and focused on a much broader picture. They
          posed the question: “How can various software components provide services to one another?” To
          answer that question, a set of technologies was created that addressed much more than compound
          document creation.

          Component Object Model (COM) technology was at the core of these first enhancements to object
          linking and embedding and opened the door to radically new concepts concerning how applications
          could interact. Microsoft extended OLE to apply to any COM-based software technology. COM
          provides a programming standard that enables communication and resource sharing at the library,
          application, and system software level. By utilizing COM technology as a foundation, object linking
          and embedding was moving beyond compound document functionality toward a much broader role.
          Microsoft extended OLE to apply to any COM-based software technology. The broader role that
          Microsoft was striving for came quickly for OLE and COM. There was rapid industry acceptance and
          implementation. COM-based applications suddenly were everywhere. Early World Wide Web
          development relied heavily on COM technology. In 1996, Microsoft differentiated the Web’s use of
          COM from OLE’s original definition of COM for enabling compound document technology by
        See Appendix for glossary of COM and ActiveX technology acronym definitions.
        creating a new acronym. The term ActiveX was derived to represent the many new facets of COM-
        based programming. OLE once again focused on COM technology as it related to the creation of
        compound documents.

      COM provides a means for one software program to access the services provided by another
      application. COM defines the standard through which different software components exchange services
      or functionality.

        COM simplifies the task of building large, reusable software applications. It does this by providing:
        • Object-based design and development environment.
        • Unified approach for accessing functions in libraries, processes, or operating system services.
        • Language independence.
        • Simplified versioning.

        Prior to the development of the Component Object Model, there was no standard Windows approach
        for this type of software service communication. Without COM, each service access configuration
        required a unique protocol. By providing a standard protocol through which all scenarios could work,
        COM eliminated much of the complexity involved with software component communication. It offered
        the Windows programming community a master architecture that spanned libraries, applications,
        system software, and networks.

    How COM Works
       In the Component Object Model, software services are implemented through a COM object (an object
       is a self-contained entity that consists of both data and procedures to manipulate the data). Through its
       architecture, the COM object usually supports multiple interfaces, each of which includes a number of
       methods. A method is typically a function or procedure that is called by the client and performs a
       specific action. Software utilizing the COM object is known as the client. Requests, or calls from the
       client, trigger the procedures held within each COM method. When the client requests a service, a
       pointer is activated that communicates to the COM interface. Each COM interface requires the
       activation of a unique pointer from the client. If an interface is comprised of multiple methods, they are
       usually related functionally to each other in some way.

        The implementation of an object always occurs within a server. The server can either be a Dynamic
        Link Library (DLL), which is loaded as needed when an application is running, or a separate process of
        its own.


                                          Pointers           Interface

                                                             Interface            COM Object

                     Client                                                    Server
                 (Visual Basic)                                                (IDL)

             A client with pointers to two of a COM object’s interfaces - from Chappell, Understanding ActiveX and OLE.
Object Class
   When a group of objects share some common characteristic, they are grouped into a class. A class
   defines all the common properties of the objects that belong to it. For example, there might be a class
   called “shape” that contains objects which are circles, rectangles, and triangles. In object programming,
   the object’s class must be known in order to activate it. The COM Library maintains the directory of all
   available COM object classes on a particular system. When the client activates a COM-based function,
   the COM library specifies the associated COM object class. The COM library also identifies the initial
   COM interface. That COM interface supplies the initial pointer. The COM library then activates the
   appropriate server for that COM object. It also passes back to the client a pointer to the requested
   interface. Pointers to additional interfaces for that COM object are then provided directly to the client
   from the object. To summarize: the COM library activates the process and supplies the initial pointer to
   any COM object.

Component Software
   Traditionally, software developers embark on new engineering projects at the very bottom of a long
   ladder. Every new application that is developed is treated as a unique project and built from the ground
   up. Imagine for a moment if computers were built this way. Every CPU, disk drive and monitor would
   be a custom project with no parts ready to assemble. Hardware engineering efficiency is achieved by
   building on the work of others, which results in reusable components. This process simplifies
   engineering, creates well-defined specifications, reduces time-to-market, and lowers cost to the

    Just as the computer component industry supports hardware reuse, COM objects provide a similar,
    reusable framework for software. Everything is geared for connectivity. Wide-spread standardization
    allows multiple language support. Individual component functionality is pre-defined and unique. Well-
    specified interfaces provide a standard path for linkage. The results are the same as in the electronic
    component market − it simplifies engineering, creates well-defined specifications, reduces time-to-
    market, and lowers cost to the consumer.

   COM simplifies the task of building large, reusable software applications. It does this in several ways:
   • Object-based design and development environment.
   • Single approach for accessing different kinds of software service, whether it’s in a library, in
       another process, or in the system software.
   • Language independence.
   • Easy versioning.
   • Full support of Microsoft at the operating system level.

The Future
   ActiveX-styled technologies are best suited for Microsoft Windows 95/98 and Windows NT
   environments. But, no matter how popular these operating systems are, single-vendor environments will
   always be challenged. And if a technology works, and works as well as COM and ActiveX, there will
   be efforts to migrate that technology to platforms beyond Windows.

    Following their lead of years past, Microsoft is working to make that port easier, instead of more
    difficult. Microsoft already supports ActiveX for the Macintosh. Software AG is porting COM,
    DCOM, ActiveX and other technologies to UNIX and IBM’s OS/390. By porting Microsoft code,
    Digital and HP have committed to providing these technologies on their operating systems.

    Component software represents the next tidal wave of software development and ActiveX is a major
    contributor. But there is reluctance in some development circles to adopt technology wholly-owned by
    Microsoft. There will always be competitive pressure from dissenters. Today, all dissention is rallying
    behind JavaBeans, a specification developed by Sun Microsystems that defines how Java objects
    interact. A JavaBean is similar to an ActiveX control. The principal difference between ActiveX
        controls and JavaBeans is that ActiveX controls can be developed in any programming language but
        executed only on a Windows platform, whereas JavaBeans can be developed only in Java but can run
        on any platform.

        The latest news from Microsoft announced DNA (Distributed InterNet Applications) architecture. It is
        the first application architecture to integrate the Internet, client/server and PC models of computing for
        a new class of distributed computing models. It focuses on answering pressure from Internet activity
        growth and information flow to expand and define services provided by development models through
        the Component Object Model.

        COM has grown to play a key role in almost all aspects of software development, from applications to
        operating systems. It may evolve but its importance as a pivotal technology is not going to go away any
        time soon.

      The IDL ActiveX Control provides a powerful way to integrate all the data analysis and visualization
      features of IDL with other programming environments that support ActiveX controls. IDL can now be
      integrated with applications written in C, C++, Visual Basic, Fortran, Delphi, etc. This makes it
      possible to design a software interface with Microsoft Visual Basic and have IDL provide visualization
      services. The IDL ActiveX Control is designed to run in the background of containing applications as a
      graphics and analysis engine. The IDL ActiveX Control only serves to enhance IDL’s position in the
      industry as the data analysis and visualization development environment.

    Major Features
       • The IDL ActiveX Control makes it possible to display IDL graphics within an OLE container that
           supports IDL controls.
       • The IDL ActiveX Control can respond to events such as mouse clicks or menu selections
           regardless of whether they are generated by an external program or IDL itself.
       • The IDL ActiveX Control greatly simplifies the process of moving data to and from IDL and an
           external program.
       • The interface to the IDL ActiveX Control appears native to the external application.

        The ActiveX interface to IDL consists of a unified control called the IDLDrawWidget. When this
        control is included in a project, it exposes IDL and provides the interface between IDL and the external
        application. The control also initializes IDL and handles all data storage and data conversion

       In ActiveX nomenclature, methods are special statements that execute on behalf of an object in a
       program. With IDL, the ExecuteStr method can be used to execute an IDL statement, function, or
       procedure when the user actives a button in a Visual Basic interface.

       Properties are used to specify various attributes of an IDLDrawWidget such as its color, width, and
       height. Properties may be set by configuring them during design in Visual Basic or at runtime by
       executing statements in the program code.

       Events are functions or procedures that can be handled by IDL’s External Development Environment
       (EDE) application on behalf of the IDLDrawWidget.
        The IDL ActiveX Control utilizes IDL 5.1 or higher for its data analysis and graphics display
        capabilities. A Runtime or IDL 5.1 development license must be present to initialize the control. It will
        not run in DEMO mode.

        Each installation of an application developed with the IDL ActiveX Control requires a Runtime or
        developer license of IDL.

    Benefits Summary… best of both worlds
       The implementation of the IDL ActiveX Control enables developers to drive IDL graphics and analysis
       capabilities inside COM-based applications. It simplifies the process of sharing data between IDL and
       the Windows developer’s language of choice. Programmers can use component-oriented environments
       with which they are familiar to generate cutting-edge graphical user interfaces while relying on IDL’s
       visualization and analysis power. The IDL ActiveX Control also makes it possible to tap into the
       component software market and develop IDL applications based on reusable software components.

        The IDL ActiveX Control facilitates IDL’s adoption in corporate settings by catering to popular visual
        programming environments that are common enterprise systems.

      It should be noted that this example was drawn from RSI’s External Development Guide, and is
      installed by default in RSI\IDL51\external\ActiveX, in IDL 5.1.

        In the following example, a simple interface
        is created in Visual Basic that triggers IDL
        to respond to events and display an image.
        The result of the example program consists
        of two buttons (“Plot Data” and “Exit”), a
        graphics display area, and a text box. All of
        these elements reside on top of what is
        called a form in Visual Basic. Clicking the
        “Plot Data” button causes IDL to respond by
        producing a simple DIST(40) surface plot.
        Clicking the “Exit” button causes IDL and
        Visual Basic to free memory and exit.

    Drawing The Interface
       In Visual Basic, this is accomplished by creating a new VB project, adding the IDL ActiveX Control,
       and drawing the interface components. The “Plot Data” and “Exit” buttons were created with the
       CommandButton widget, the text box was created the TextBox widget, and the graphics display was
       created with the IDLDrawWidget.

    Initializing IDL
         With addition of the IDLDrawWidget, we now have access to IDLDrawWidget’s properties and
         methods. The IdlPath and GraphicsLevel properties specify the directory path of the IDL ActiveX
         Control to choose between IDL’s direct and object graphics capabilities. Graphics level 1 associates
         with direct graphics, level 2 with object graphics.
    Since IDL is initialized through VB, we must use VB code to give the application behavior. Visual
    Basic automatically generates the following subroutine when the interface component form is double

    Private Sub Form_Load()
    End Sub

    The Form_Load routine is automatically executed when a program starts running and can be used to
    initialize IDL, create the IDLDrawWidget, and direct output from IDL to a text box. Code to
    accomplish these tasks is placed between these two statements. IDL needs to be initialized with the
    InitIDL method before VB can interact with the IDLDrawWidget. InitIDL takes the hWnd of the
    form containing the IDLDrawWidget as an argument and returns 1 or less than 1, depending on
    whether or not IDL’s initialization was successful.

    Private Sub Form_Load()
    End Sub

    A conditional statement is included to display an error message and exit the program if IDL failed to

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
    End Sub

Creating the Draw Window
   When a box is drawn with the “IDLDrawWidget” icon in the toolbar, a container frame for the
   IDLDrawWidget is created. This container is analogous to an IDL widget base. The graphics window
   that will be used by IDL is created with the CreateDrawWidget method.

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
    End Sub

Directing IDL Output to a Text Box
    The SetOutPutWnd method of the IDLDrawWidget displays an output returned by IDL in a text box. It
    takes the hWnd of the text box as an argument. The text box is named IDL_Output_Box, hence:

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
       IDLDrawWidget1.SetOutputWnd (IDL_OutputBox.hWnd)
    End Sub

Responding to Events and Issuing IDL Commands
    The easiest way for IDL and VB to communicate is to allow VB to manage the events and pass
    instructions to IDL. The “Plot Data” button will automatically create the following subroutine:

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
       IDLDrawWidget1.SetOutputWnd (IDL_OutputBox.hWnd)
    End Sub

    Private Sub Plot_Button_Click()
    End Sub

    VB will execute any statements within this subroutine when the user clicks “Plot Data.” Instructions are
    passed on to IDL via the ExecuteStr method to the IDLDrawWidget. The ExecuteStr takes a string as
    an argument. This string is passed to IDL for execution as if it were entered at the IDL command line.
    The following five statements instruct IDL to produce the surface plot in the example program:

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
       IDLDrawWidget1.SetOutputWnd (IDL_OutputBox.hWnd)
    End Sub

    Private Sub Plot_Button_Click()
       IDLDrawWidget1.ExecuteStr (“Z = SHIFT(DIST(40), 20, 20)”)
       IDLDrawWidget1.ExecuteStr (“Z = EXP(-(Z/10)^2)”)
       IDLDrawWidget1.ExecuteStr (“SURFACE,Z”)
       IDLDrawWidget1.ExecuteStr (“PRINT,SIZE(Z)”)
    End Sub

Cleaning Up and Exiting
   Exiting is a two step process. IDL is given a chance to clean up and exit by issuing the DoExit method.
   The VB program then exits with an END statement.

    Private Sub Form_Load()
       If n<=0 Then
           MsgBox (“IDL failed to initialize”)
       End If
       IDLDrawWidget1.SetOutputWnd (IDL_OutputBox.hWnd)
    End Sub

    Private Sub Plot_Button_Click()
       IDLDrawWidget1.ExecuteStr (“Z = SHIFT(DIST(40), 20, 20)”)
       IDLDrawWidget1.ExecuteStr (“Z = EXP(-(Z/10)^2)”)
       IDLDrawWidget1.ExecuteStr (“SURFACE,Z”)
       IDLDrawWidget1.ExecuteStr (“PRINT,SIZE(Z)”)
    End Sub

    Private Sub Exit_Button_Click()
    End Sub
The completed VB code appears as:

                 1 Private Sub Form_Load()
                 2     n=IDLDrawWidget1.InitIDL(Form1.hWnd)
                 3     If n <= ) Then
                 4         MsgBox (“IDL failed to initialize”)
                 5         End
                 6     End If
                 7     IDLDrawWidget1.CreateDrawWidget
                 8     IDLDrawWidget1.SetOutputWnd (IDL_Output_Box.hWnd)
                 9 End Sub
              10 Private Sub Plot_Button_Click()
              11     IDLDrawWidget1.ExecuteStr (“Z=SHIFT(DIST(40),20,20)”)
              12     IDLDrawWidget1.ExecuteStr (“Z=EXP(-(Z/10)^2)”)
              13     IDLDrawWidget1.ExecuteStr (“SURFACE,Z”)
              14     IDLDrawWidget1.ExecuteStr (“PRINT,SIZE(Z)”)
              15 End Sub

                16 Private Sub Exit_Button_Click()
                17     IDLDrawWidget1.DoExit
                18     End
                19 End Sub

    This example shows how easy it is to use Visual Basic as a GUI builder and the simplicity with which
    IDL and Visual Basic communicate.

    For a more complex example, refer to the
    thunderstorm demo, included with the IDL 5.1
    release (RSI/IDL51/examples/tstorm). In this
    example, Visual Basic was used to create an easy
    to navigate interface, revealing pressure, wind,
    and temperature data sets associated with a
    severe thunderstorm.

                                                                          “Tstorm” Demo


   ActiveX Controls
       An ActiveX Control is a stand-alone software component who’s function is pre-defined and performs in
       a standard way. It exemplifies component software. The ActiveX Control specification defines this
       standard and sets the stage for plug-in component architecture. An ActiveX Control is a component of
       functionality that can be purchased and added to a Windows application. In essence, an entire
       application can now be built from pre-existing parts (reusable software components).

       Bear in mind that ActiveX Controls are not, by themselves, applications. They are service providers
       (servers) that plug into a control container. As with other ActiveX technologies, interactions between
       participating software units are specified by various interfaces supported by COM. In the case of
       ActiveX controls, the involved software units are the control and its container. An ActiveX Control
       may incorporate many other ActiveX technologies, all of which are COM-based. As an example,
       controls often support embedding interfaces as well as automation, allowing access to their methods.

       Automation is a means in which a developer can access an application’s functionality through COM-
       object support. This is not source code exposure, but component exposure. Automation provides
       programmers with the means to pull a feature from an existing application and add the same feature to
       their own project. For instance, since Microsoft Excel supports automation, programmers can
       incorporate existing Excel features into their work. With automation, Excel is no longer just an end-
       user application, it has become a valuable, programming toolkit.

       A network architecture in which each computer or process on the network is either a client or a server.
       Servers are powerful computers or processes dedicated to managing disk drives (file servers), printers
       (print servers), or network traffic (network servers). Clients are PCs or workstations on which users run
       applications. Clients rely on servers for resources such as files, devices, and even processing power.
       Another type of network architecture is known as a peer-to-peer architecture because each node has
       equivalent responsibilities. Both client/server and peer-to peer architectures are widely used and each
       has unique advantages and disadvantages. Client/server architectures are sometimes called two-tier

   Compound Documents
      Compound document technology addresses the need for integration between applications, effectively
      allowing different applications to work together smoothly, producing what appears to be a single
      document. It allows using existing applications to work in various portions of a document, totally
      independent of each other. As previously mentioned, OLE defines the interface standards and allows
      this kind of interaction between a wide variety of applications and vendors, not just Microsoft’s Office

   Distributed COM
       Distributed COM (DCOM) is mechanism for COM objects to provide their services across machine
       boundaries. Originally, COM implementation was restricted to a single machine. COM objects could
       be implemented on the same machine as their client but they couldn’t reside on other machines in the
       network. DCOM removes this restriction with the remote procedure call (RPC), allowing a client to
       execute an object across a network. DCOM also provides support for security services by controlling
       which clients can use a COM object.
   Short for Dynamic Link Library, a library of executable functions or data that can be used by a
   Windows application. Typically, a DLL provides one or more particular functions and a program
   accesses the functions by creating either a static or dynamic link to the DLL. A static link remains
   constant during program execution while a dynamic link is created by the program as needed. DLLs
   can also just contain data. DLL files usually end with the extension .dll, .exe, .drv, or .fon. A DLL can
   be used by several applications at the same time. Some DLLs are provided with the Windows operating
   system and are available for any Windows application. Other DLLs are written for a particular
   application and are loaded with the application.

   Microsoft Foundation Classes−a large library of C++ classes developed by Microsoft. MFC provides
   an enormous head start for C++ application development. One of the hardest parts of developing C++
   programs is designing a logical hierarchy of classes. With MFC, this work is already done. MFC is
   bundled with several C++ compilers and is also available as part of the Microsoft Developer’s

   A moniker is itself a COM object but has a singular purpose: to provide a mechanism through which a
   client can initialize an individual COM object. It hides the initialization details from the client/user.

    The ability to execute more than one task at the same time, a task being a program. The terms
    multitasking and multiprocessing are often used interchangeably, although multiprocessing sometimes
    implies that more than one CPU is involved. In multitasking, only one CPU is involved but it switches
    from one program to another so quickly that it gives the appearance of executing all of the programs at
    the same time.

    There are two basic types of multitasking: preemptive and cooperative. In preemptive multitasking the
    operating system parcels out CPU time slices to each program. In cooperative multitasking each
    program can control the CPU for as long as it needs it. If a program is not using the CPU, however, it
    can allow another program to use it temporarily. OS/2, Windows 95, Windows NT, Amiga, and UNIX
    operating systems use preemptive multitasking whereas Windows 3.x and the Multifinder (Macintosh)
    use cooperative multitasking.

    The thread is a unit of execution through a single program. A multithreaded program creates threads to
    perform additional tasks at the same time. Multiple threads allow for background operations in Word or
    a database server to connect to simultaneous users. The programmer must carefully design the
    application in such a way that all the threads can run at the same time without interfering with each

Parallel Programming
   Parallel programming is creating a single program in such a way that it can simultaneously execute on
   more than one processor. Parallel programming can utilize multiple threads or tasks by creating
   multiple-control flows. Each flow can behave as a single program but is actually a piece of a bigger
   process. This means, that a large computational problem can be divided into workable units and each
   unit can be processed at the same time, reaching a conclusion much faster than solving it as one long,
   linear process.

    Parallel programming can actually be carried out on a single processor machine, as long as there is a
    multitasking operating system. OS/2, for example, is a multitasking operating system that supports tools
    for spawning multiple threads but must execute on a machine with a single processor.
        Perhaps the best-known example of a program used in parallel with other programs is a print spooler.
        The print spooler allows you to print while continuing with your work. The operating system knows not
        to dedicate its entire resources to printing; this would keep you from doing anything else while printing.
        Also, the operating system knows not to dedicate itself to your current task; this would stop the print
        task. The print spooler operates in parallel with any other programs running at that time.

        Persistence refers to an object’s ability to store data that can be shared by multiple COM-objects.
        Structured storage utilizes the persistence of COM data and allows objects to share a single disk file. In
        order for this to work, Structured Storage defines two kinds of COM objects − storages and streams. In
        the world of object-programming, these COM-objects are comparable to directories and files of
        common file systems. Structured Storage provides a new way for different applications to share a single
        file. This file can contain data from many different COM-objects, each storing its data in a unique
        storage or stream.

    Uniform Data Transfer
        Uniform data transfer is the COM standard for data exchange. For applications to be COM compliant,
        they must support particular COM interfaces. The methods contained within these required interfaces
        define the standards by which data is described, moved, and stored.

     Multithreading and Visual Basic, Dino Esposito, Dr. Dobb’s Journal, 12/96
     How To Add ActiveX Content to Your Web Pages, Far Point Technologies, Inc. 1996
     Understanding ActiveX and OLE, David Chappell, Microsoft Press
     Technologies for Simplifying Application Development , Norma Dorst, Desktop Engineering, 3/98
     ActiveX/COM, Don Box, Microsoft Systems Journal, 1/97
     ActiveX, Paul Bonner, Windows Sources, 4/97
     Microsoft Announces Comprehensive Architecture For Next Generation of Applications , MS Press
     Release, 9/23/97.
     What Is Windows DNA?,
     ActiveX Demystified, David Chappell, David Linthicum, BYTE, 9/97
     Exploding the Myth of ActiveX Portability, Hank Marquis, BackOffice, 4/98

            IDL is a registered trademark of Research Systems, Inc. All other and/or brand names are the property of their respective owners

Shared By:
Tags: white, paper