diff --git a/documentation/source/duim-reference/conventions.rst b/documentation/source/duim-reference/conventions.rst index f543a217ef..5a62531462 100644 --- a/documentation/source/duim-reference/conventions.rst +++ b/documentation/source/duim-reference/conventions.rst @@ -33,10 +33,10 @@ use the interfaces being described. If you wish, you can run these examples interactively by typing them into the Dylan Playground. A number of additional, longer examples are provided as part of the -Harlequin Dylan installation, and are installed on your hard disk +Open Dylan installation, and are installed on your hard disk automatically. You can look at these examples and load them into the environment by clicking on the examples button in the main window of the -Harlequin Dylan environment. +Open Dylan environment. Longer examples are also provided and discussed fully in the *Building Applications using DUIM*, which you should refer to for an introduction diff --git a/documentation/source/duim-reference/frames.rst b/documentation/source/duim-reference/frames.rst index caa29d0e25..d113fc30e2 100644 --- a/documentation/source/duim-reference/frames.rst +++ b/documentation/source/duim-reference/frames.rst @@ -174,28 +174,13 @@ exposed by the DUIM-Gadgets library, two of its subclasses are exposed by the DUIM-Frames library: :class:`` and :class:``. See :ref:`gadgets-subclasses-of-page` for an introduction to these classes. -DUIM-Commands Library -===================== - -All commands-related interfaces are now defined directly in the Commands -library. However, these same interfaces are imported to and re-exported -from DUIM-Frames, so they can be used in almost the same way as for -Harlequin Dylan 1.0. You should continue to look for commands-related -documentation in this chapter. - -A consequence of the introduction of the Commands library is that a -slight change in syntax is required in the definition of commands in -command tables. In Harlequin Dylan 1.0, two approaches could be taken -when specifying a command in a table. For example, a menu item could be -specified by either of the following: - -.. code-block:: dylan - - menu-item "My Command" = make(, function: my-command), - menu-item "My Command" = my-command, +Commands Interface +================== -Beginning with Harlequin Dylan 1.1, only the last of these may be used. -This may require you to change some of your code. +The DUIM-Frames library makes extensive use of commands-related +interfaces defined in the :lib:`commands` library. These interfaces +are imported to and re-exported from DUIM-Frames, so it is not +necessary to import :lib:`commands` explicitly. DUIM-Frames Module ================== diff --git a/documentation/source/duim-reference/gadgets.rst b/documentation/source/duim-reference/gadgets.rst index e697d77108..748f73039d 100644 --- a/documentation/source/duim-reference/gadgets.rst +++ b/documentation/source/duim-reference/gadgets.rst @@ -3611,7 +3611,7 @@ are exported from the *duim-gadgets* module. :seealso: - - :class;`` + - :class:`` - :gf:`list-control-view` - :type:`` diff --git a/documentation/source/getting-started-ide/com-projects.rst b/documentation/source/getting-started-ide/com-projects.rst index a6a639c9a8..30e903d389 100644 --- a/documentation/source/getting-started-ide/com-projects.rst +++ b/documentation/source/getting-started-ide/com-projects.rst @@ -44,423 +44,423 @@ Creating the server stubs library First we use the New Project wizard to create a Dylan library defining server-side stubs for the encryption interface. -Choose **File > New...** from the main window. +Choose :menuselection:`File --> New...` from the main window. -#. Select **Project** and click **OK**. +#. Select :guilabel:`Project` and click :guilabel:`OK`. -The New Project wizard appears. + The New Project wizard appears. -#. In the Project Type section, select "Interface to COM Type Library" - and click **Next**. +#. In the Project Type section, select :guilabel:`Interface to COM Type Library` + and click :guilabel:`Next`. -The next page allows you to name a type library to be translated. Most -COM components store the location of their type libraries in the Windows -Registry. These registered type libraries are listed in the Installed -Type Libraries section of the window. You can select a type library from -the list, or click **Browse...** in the Location pane to select a type -library file from disk. + The next page allows you to name a type library to be translated. Most + COM components store the location of their type libraries in the Windows + Registry. These registered type libraries are listed in the Installed + Type Libraries section of the window. You can select a type library from + the list, or click :guilabel:`Browse...` in the Location pane to select a type + library file from disk. -.. figure:: images/motwiz.png - :align: center + .. figure:: images/motwiz.png + :align: center - Choosing a type library file to convert. + Choosing a type library file to convert. -In this case, we use a type library supplied with Open Dylan. + In this case, we use a type library supplied with Open Dylan. -#. Click **Browse...** and navigate to the Open Dylan examples folder. +#. Click :guilabel:`Browse...` and navigate to the Open Dylan examples folder. -The folder required is called Examples and is placed under the top-level -Open Dylan folder. + The folder required is called Examples and is placed under the top-level + Open Dylan folder. -It is usually *C:\\Program Files\\Open Dylan\\Examples*. + It is usually :file:`C:\\Program Files\\Open Dylan\\Examples`. #. Go to the *Documentation\\RotNExample* subfolder and choose the - *RotNExample.tlb* file. -#. Click **Next** to continue to the next page of the wizard. - -.. figure:: images/motstub.png - :align: center + :file:`RotNExample.tlb` file. +#. Click :guilabel:`Next` to continue to the next page of the wizard. - Choosing the kind of skeleton code to generate. + .. figure:: images/motstub.png + :align: center -The next page allows you to choose what kind of stubs to generate from -the type library. There are two options: + Choosing the kind of skeleton code to generate. -Dispatch client interfaces + The next page allows you to choose what kind of stubs to generate from + the type library. There are two options: -- Defines Dylan code to allow you to interface to COM servers. + Dispatch client interfaces + Defines Dylan code to allow you to interface to COM servers. -Dispatch server skeletons + Dispatch server skeletons + Defines Dylan code to allow you to create COM servers implementing + the interfaces described in the type library. -- Defines Dylan code to allow you to create COM servers implementing - the interfaces described in the type library. + Because we are writing the server side of the application, we want to + generate dispatch server skeleton code. -Because we are writing the server side of the application, we want to -generate dispatch server skeleton code. +#. Select :guilabel:`Dispatch server skeletons`. +#. Click :guilabel:`Next` to continue to the next page of the wizard. -#. Select "Dispatch server skeletons". -#. Click **Next** to continue to the next page of the wizard. - -.. figure:: images/motinters.png - :align: center + .. figure:: images/motinters.png + :align: center - Choosing interfaces and classes from the type library. + Choosing interfaces and classes from the type library. -The next page presents a list of COM classes and interfaces contained in -the selected type library. You can select which to translate by choosing -"Translate selected" and then clicking to select individual items, -dragging or using the Shift key to select ranges, and using the Ctrl key -to select additional items. Choose "Translate all" and all classes and -interfaces in the type library will be translated. This is different -from selecting all items under "Translate selected" because if classes -or interfaces are added to the type library later, they will only be -translated if you selected "Translate all". + The next page presents a list of COM classes and interfaces + contained in the selected type library. You can select which to + translate by choosing :guilabel:`Translate selected` and then + clicking to select individual items, dragging or using the Shift + key to select ranges, and using the Ctrl key to select additional + items. Choose :guilabel:`Translate all`, and all classes and + interfaces in the type library will be translated. This is + different from selecting all items under :guilabel:`Translate + selected`, because if classes or interfaces are added to the type + library later, they will only be translated if you selected + :guilabel:`Translate all`. -#. Choose "Translate all", so that both the RotNExample COM class and +#. Choose :guilabel:`Translate all`, so that both the RotNExample COM class and the IRotNExample interface are translated. -#. Click **Next**. +#. Click :guilabel:`Next:guilabel:`. -Now we reach the Project Name and Location page. This and all subsequent -pages are the same as those that you see for other kinds of project in -the New Project wizard. Follow the remaining steps to finish defining -the server stubs project. + Now we reach the :guilabel:`Project Name and Location` page. This + and all subsequent pages are the same as those that you see for + other kinds of project in the New Project wizard. Follow the + remaining steps to finish defining the server stubs project. -#. Change the name of the project to *RotNExample-server-stubs*. +#. Change the name of the project to ``RotNExample-server-stubs``. #. Choose a suitable Location for the project. -#. Make sure that the "Dynamic Link Library (DLL)" option is chosen in +#. Make sure that the :guilabel:`Dynamic Link Library (DLL)` option is chosen in the Project Settings and Templates section. -#. Make sure that the "Include any available templates" option is *not* +#. Make sure that the :guilabel:`Include any available templates` option is *not* checked. -#. Click **Next** to continue. +#. Click :guilabel:`Next` to continue. -We are now at the Use Libraries page. We are only defining the stubs for -the server, so we do not need any unusual libraries. + We are now at the Use Libraries page. We are only defining the stubs for + the server, so we do not need any unusual libraries. -#. Choose the "Minimal" option. -#. Click **Next** to continue. +#. Choose the :guilabel:`Minimal` option. +#. Click :guilabel:`Next` to continue. -We are now at the final page of the New Project wizard. + We are now at the final page of the New Project wizard. -#. Make any changes you want to the Source File Headers section. -#. Click **Finish**. +#. Make any changes you want to the :guilabel:`Source File Headers` section. +#. Click :guilabel:`Finish`. -The new project appears. + The new project appears. -.. figure:: images/motproj.png - :align: center + .. figure:: images/motproj.png + :align: center - The server stubs project. + The server stubs project. -In addition to the usual files, this project contains a file named -*type-library.spec*. This is a specification file. It provides -information to the type library tool. + In addition to the usual files, this project contains a file named + :file:`type-library.spec`. This is a specification file. It + provides information to the type library tool. #. Double-click on the specification file. -An editor window opens on the specification file. - -The specification file looks something like this: - -.. code-block:: dylan - - Origin: COM-type-library - Type-library: C:\\Program Files\\Open Dylan\\Examples\\...\\RotNExample.tlb - Module: type-library-module - Module-file: type-library-module.dylan - Generate: dispatch-servers - Stub-file: stubs.dylan - -As you can see, the specification file contains all the information -provided to the type library portion of the New Project wizard. - -However, no skeleton code has yet been generated. The type library tool, -which generates the skeleton code, only runs when you build the project. - -#. Build the project with **Project > Build**. - -The build process adds some new files to the project. These files were -generated by the type library tool. - -The file *type-library-module.dylan* defines a module in which the -translated code resides. This module exports all translated symbols. If -you look at *module.dylan*, you will see that the main module -re-exports all of these symbols. - -The file *stubs.dylan* contains the Dylan code generated by the type -library tool. It defines a class for an implementation of the -IRotNExample interface, and generic functions for the methods and -properties of the interface: - -.. code-block:: dylan - - /* Dispatch interface: IRotNExample version 0.0 - * GUID: {822ED42A-3EB1-11D2-A3CA-0060B0572A7F} - * Description: An example interface for Open Dylan's Getting - * Started manual. */ - - define open dispatch-interface () - uuid "{822ED42A-3EB1-11D2-A3CA-0060B0572A7F}"; - virtual property IRotNExample/key :: type-union(, - ), name: "key", disp-id: 12288; - function IRotNExample/encrypt (arg-pre :: ) => - (arg-result :: ), name: "encrypt", disp-id: 24576; - function IRotNExample/decrypt (arg-pre :: ) => - (arg-result :: ), name: "decrypt", disp-id: 24577; - end dispatch-interface ; - define open generic IRotNExample/key (this :: ) => - (arg-result :: type-union(, )); - define open generic IRotNExample/key-setter (arg-result :: - type-union(, ), this :: ) - => (arg-result :: type-union(, )); - define open generic IRotNExample/encrypt (this :: , - arg-pre :: ) => (result :: , arg-result :: - ); - define open generic IRotNExample/decrypt (this :: , - arg-pre :: ) => (result :: , arg-result :: - ); - -This defines a class ```` which implements the given -interface. The implementation is not complete until methods are provided -for the generics. This can be done by adding methods in the same -library, or by defining a subclass of ```` in another -library and defining methods on the subclass. We will take the latter -approach. - -There is also generated code corresponding to the COM class RotNExample -from the type library: - -.. code-block:: dylan - - /* COM class: RotNExample version 0.0 - * GUID: {C44502DB-3EB1-11D2-A3CA-0060B0572A7F} - * Description: Implementation of IRotNExample. - */ - - define constant $RotNExample-class-id = as(, - "{C44502DB-3EB1-11D2-A3CA-0060B0572A7F}"); - /* You should define your coclass something like this: - define coclass $RotNExample-type-info - name "RotNExample"; - uuid $RotNExample-class-id; - default interface ; - end coclass; - */ - -Note that the ``define coclass`` is within a comment, since you may want -to define a COM class based on a subclass of ````. + An editor window opens on the specification file. + + The specification file looks something like this: + + .. code-block:: dylan + + Origin: COM-type-library + Type-library: C:\\Program Files\\Open Dylan\\Examples\\...\\RotNExample.tlb + Module: type-library-module + Module-file: type-library-module.dylan + Generate: dispatch-servers + Stub-file: stubs.dylan + + As you can see, the specification file contains all the information + provided to the type library portion of the New Project wizard. + + However, no skeleton code has yet been generated. The type library tool, + which generates the skeleton code, only runs when you build the project. + +#. Build the project with :menuselection:`Project --> Build`. + + The build process adds some new files to the project. These files were + generated by the type library tool. + + The file :file:`type-library-module.dylan` defines a module in + which the translated code resides. This module exports all + translated symbols. If you look at :file:`module.dylan`, you will + see that the main module re-exports all of these symbols. + + The file :file:`stubs.dylan` contains the Dylan code generated by the type + library tool. It defines a class for an implementation of the + ``IRotNExample`` interface, and generic functions for the methods and + properties of the interface: + + .. code-block:: dylan + + /* Dispatch interface: IRotNExample version 0.0 + * GUID: {822ED42A-3EB1-11D2-A3CA-0060B0572A7F} + * Description: An example interface for Open Dylan's Getting + * Started manual. */ + + define open dispatch-interface () + uuid "{822ED42A-3EB1-11D2-A3CA-0060B0572A7F}"; + virtual property IRotNExample/key :: type-union(, + ), name: "key", disp-id: 12288; + function IRotNExample/encrypt (arg-pre :: ) => + (arg-result :: ), name: "encrypt", disp-id: 24576; + function IRotNExample/decrypt (arg-pre :: ) => + (arg-result :: ), name: "decrypt", disp-id: 24577; + end dispatch-interface ; + define open generic IRotNExample/key (this :: ) => + (arg-result :: type-union(, )); + define open generic IRotNExample/key-setter (arg-result :: + type-union(, ), this :: ) + => (arg-result :: type-union(, )); + define open generic IRotNExample/encrypt (this :: , + arg-pre :: ) => (result :: , arg-result :: + ); + define open generic IRotNExample/decrypt (this :: , + arg-pre :: ) => (result :: , arg-result :: + ); + + This defines a class ```` which implements the given + interface. The implementation is not complete until methods are + provided for the generics. This can be done by adding methods in + the same library, or by defining a subclass of ```` + in another library and defining methods on the subclass. We will + take the latter approach. + + There is also generated code corresponding to the COM class RotNExample + from the type library: + + .. code-block:: dylan + + /* COM class: RotNExample version 0.0 + * GUID: {C44502DB-3EB1-11D2-A3CA-0060B0572A7F} + * Description: Implementation of IRotNExample. + */ + + define constant $RotNExample-class-id + = as(, "{C44502DB-3EB1-11D2-A3CA-0060B0572A7F}"); + /* You should define your coclass something like this: + define coclass $RotNExample-type-info + name "RotNExample"; + uuid $RotNExample-class-id; + default interface ; + end coclass; + */ + + Note that the ``define coclass`` is within a comment, since you may want + to define a COM class based on a subclass of ````. Creating the server ------------------- Now we create the actual server application. -Choose **File > New...** from the main window. +Choose :menuselection:`File --> New...` from the main window. -#. Select *Project* and click **OK**. +#. Select :guilabel:`Project` and click :guilabel:`OK`. -The New Project wizard appears. + The New Project wizard appears. -#. In the Project Type section, select "GUI Application (EXE)" and click - **Next**. -#. Name the project *RotNExample-server*. -#. Make sure that the "Include any available templates" option is *not* +#. In the Project Type section, select :guilabel:`GUI Application (EXE) and click + :guilabel:`Next`. +#. Name the project ``RotNExample-server``. +#. Make sure that the :guilabel:`Include any available templates` option is *not* checked. -#. Make sure that "Production mode" is selected in the Compilation Mode - section of the Advanced Project Settings dialog. - -This option will be set already if you have been following all steps -from the start of this chapter. - -#. Click **Next** to continue. -#. Choose the "Simple" libraries option and click **Next** to continue. -#. Choose the "Standard IO streams and string formatting" option from - "IO and system support", and click **Next**. -#. Choose the "Win32 API" option from "GUI support", and click **Next**. -#. Choose the "OLE Automation" option from "OLE Automation support" and - click **Next**. -#. Choose the "NoneY" option from "Database support" and click **Next**. -#. Click **Finish**. - -The RotNExample-server project window appears. - -#. In the new project's window, edit *library.dylan*, and add to the +#. Make sure that :guilabel:`Production mode` is selected in the :guilabel:`Compilation Mode` + section of the `Advanced Project Settings` dialog. + + This option will be set already if you have been following all steps + from the start of this chapter. + +#. Click :guilabel:`Next` to continue. +#. Choose the :guilabel:`Simple` libraries option and click :guilabel:`Next` to continue. +#. Choose the :guilabel:`Standard IO streams and string formatting` option from + :guilabel:`IO and system support`, and click :guilabel:`Next`. +#. Choose the :guilabel:`Win32 API` option from :guilabel:`GUI support`, and click :guilabel:`Next`. +#. Choose the :guilabel:`OLE Automation` option from :guilabel:`OLE + Automation support` and click :guilabel:`Next`. +#. Choose the :guilabel:`None` option from :guilabel:`Database + support` and click :guilabel:`Next`. +#. Click :guilabel:`Finish`. + + The RotNExample-server project window appears. + +#. In the new project's window, edit :file:`library.dylan`, and add to the ``define library`` declaration the following line: -.. code-block:: dylan + .. code-block:: dylan - use RotNExample-server-stubs; + use RotNExample-server-stubs; #. Add the same line to the ``define module`` declaration in - *module.dylan*. - -To implement the IRotNExample interface, we will create a subclass of -````. Because ```` was created with ``define -dispatch-interface``, we must use ``define COM-interface`` to create -the subclass. - -.. note:: The remainder of this section of the example involves adding - code to *RotNExample-server.dylan*. A version of this file with all the - code we add in this section is available in the Open Dylan - installation folder, under - *Examples\\Documentation\\RotNExample\\RotNExample-server.dylan*. You - may want to copy that file into place in your project folder rather than - typing code in. - -#. Add the following code to *RotNExample-server.dylan*. - -.. code-block:: dylan - - define COM-interface () - slot IRotNExample/key :: - type-union(, ) = 13; - end; - -If you add this by hand, make sure not to put it after the top-level -call to *main*. - -We provide here an implementation for the *IRotNExample/key* slot, which -was defined as a virtual slot in the superclass. This slot must accept -the ```` type, since any 32-bit integer which does not fit -in the range of a Dylan :drm:`` will be passed as a -````. - -The next task is to define the *IRotNExample/encrypt* and -*IRotNExample/decrypt* methods. Although it is not obvious from the -definition of ````, these methods must take as their first -parameter the instance of ```` they operate on, and -return as a first result a COM error code. - -#. Add the following code to *RotNExample-server.dylan*. - -.. code-block:: dylan - - define method IRotNExample/encrypt - (this :: , pre :: ) - => (result :: , post :: ) - if (instance?(this.IRotNExample/key, )) - let post = make(, size: pre.size); - for (char keyed-by index in pre) - post[index] := rot-char-by-n(char, this.IRotNExample/key); - end for; - values($S-OK, post) - else - values($E-INVALIDARG, "") - end if - end; - - define method IRotNExample/decrypt - (this :: , pre :: ) - => (result :: , post :: ) - if (instance?(this.IRotNExample/key, )) - let post = make(, size: pre.size); - for (char keyed-by index in pre) - post[index] := rot-char-by-n(char, -this.IRotNExample/key); - end for; - values($S-OK, post) - else - values($E-INVALIDARG, "") - end if - end; - -Note that this code is careful not to crash when *IRotNExample/key* is a -````. ``$S-OK`` represents success. ``$E-INVALIDARG`` is a -generic failure representing some kind of invalid argument value. - -The above method uses the *rot-char-by-n* function, which we must also -add. - -#. Add the following code to *RotNExample-server.dylan*. - -.. code-block:: dylan - - define function rot-char-by-n - (char :: , n :: ) - => (r :: ) - let char-as-int = as(, char); - local method rot-if-in-range - (lower :: , upper :: ) => () - if (lower <= char-as-int & char-as-int <= upper) - char-as-int := lower + modulo(char-as-int - lower + n, - upper - lower + 1); - end if; - end method; - rot-if-in-range(as(, 'a'), as(, 'z')); - rot-if-in-range(as(, 'A'), as(, 'Z')); - as(, char-as-int) - end; - -This function rotates alphabetic characters forward *n* positions, -wrapping around if the character passes "Z". When *n* is 13, this -implements the classic Rot13 cipher often used to hide offensive -material on USENET. - -In order to create our server, we must also create a COM class for it. - -#. Add the following code to *RotNExample-server.dylan*. - -You may want to copy the ``define coclass`` code from *stubs.dylan* in -the *RotNExample-server-stubs* project and modify it. - -.. code-block:: dylan - - define coclass $RotNExample-type-info - name "RotNExample"; - uuid $RotNExample-class-id; - default interface ; - end coclass; - -Now we simply have to add a Windows event loop as the main body of the -server program. - -#. Modify the ``main`` method in *RotNExample-server.dylan* to look like + :file:`module.dylan`. + + To implement the IRotNExample interface, we will create a subclass + of ````. Because ```` was created with + ``define dispatch-interface``, we must use ``define COM-interface`` + to create the subclass. + + .. note:: The remainder of this section of the example involves adding + code to :file:`RotNExample-server.dylan`. A version of this file with all the + code we add in this section is available in the Open Dylan + installation folder, under + :file:`Examples\\Documentation\\RotNExample\\RotNExample-server.dylan`. You + may want to copy that file into place in your project folder rather than + typing code in. + +#. Add the following code to :file:`RotNExample-server.dylan`. + + .. code-block:: dylan + + define COM-interface () + slot IRotNExample/key :: type-union(, ) = 13; + end; + + If you add this by hand, make sure not to put it after the top-level + call to *main*. + + We provide here an implementation for the *IRotNExample/key* slot, which + was defined as a virtual slot in the superclass. This slot must accept + the ```` type, since any 32-bit integer which does not fit + in the range of a Dylan :drm:`` will be passed as a + ````. + + The next task is to define the *IRotNExample/encrypt* and + *IRotNExample/decrypt* methods. Although it is not obvious from the + definition of ````, these methods must take as their first + parameter the instance of ```` they operate on, and + return as a first result a COM error code. + +#. Add the following code to :file:`RotNExample-server.dylan`. + + .. code-block:: dylan + + define method IRotNExample/encrypt + (this :: , pre :: ) + => (result :: , post :: ) + if (instance?(this.IRotNExample/key, )) + let post = make(, size: pre.size); + for (char keyed-by index in pre) + post[index] := rot-char-by-n(char, this.IRotNExample/key); + end for; + values($S-OK, post) + else + values($E-INVALIDARG, "") + end if + end; + + define method IRotNExample/decrypt + (this :: , pre :: ) + => (result :: , post :: ) + if (instance?(this.IRotNExample/key, )) + let post = make(, size: pre.size); + for (char keyed-by index in pre) + post[index] := rot-char-by-n(char, -this.IRotNExample/key); + end for; + values($S-OK, post) + else + values($E-INVALIDARG, "") + end if + end; + + Note that this code is careful not to crash when ``IRotNExample/key`` is a + ````. ``$S-OK`` represents success. ``$E-INVALIDARG`` is a + generic failure representing some kind of invalid argument value. + + The above method uses the *rot-char-by-n* function, which we must also + add. + +#. Add the following code to :file:`RotNExample-server.dylan`. + + .. code-block:: dylan + + define function rot-char-by-n + (char :: , n :: ) + => (r :: ) + let char-as-int = as(, char); + local method rot-if-in-range + (lower :: , upper :: ) => () + if (lower <= char-as-int & char-as-int <= upper) + char-as-int := lower + modulo(char-as-int - lower + n, + upper - lower + 1); + end if; + end method; + rot-if-in-range(as(, 'a'), as(, 'z')); + rot-if-in-range(as(, 'A'), as(, 'Z')); + as(, char-as-int) + end; + + This function rotates alphabetic characters forward *n* positions, + wrapping around if the character passes "Z". When *n* is 13, this + implements the classic `Rot13 `_ + cipher often used to hide offensive material on Usenet. + + In order to create our server, we must also create a COM class for it. + +#. Add the following code to :file:`RotNExample-server.dylan`. + + You may want to copy the ``define coclass`` code from :file:`stubs.dylan` + in the *RotNExample-server-stubs* project and modify it. + + .. code-block:: dylan + + define coclass $RotNExample-type-info + name "RotNExample"; + uuid $RotNExample-class-id; + default interface ; + end coclass; + + Now we simply have to add a Windows event loop as the main body of the + server program. + +#. Modify the ``main`` method in :file:`RotNExample-server.dylan` to look like the following. -.. code-block:: dylan - - define method main () => () - if (OLE-util-register-only?()) - register-coclass($RotNExample-type-info, - "Harlequin.RotNExample"); - else - let factory :: - = make-object-factory($RotNExample-type-info); - with-stack-structure (pmsg :: ) - while (GetMessage(pmsg, $NULL-HWND, 0, 0)) - TranslateMessage(pmsg); - DispatchMessage(pmsg); - end while; - end with-stack-structure; - revoke-registration(factory); - end if; - end method main; - -With this code in place, if the server is invoked from the command line -with */RegServer* as an argument, ``OLE-util-register-only?`` will return -``#t``. The call to ``register-coclass`` creates a type library (with -extension .TLB) and registers the type library and the server itself in -the Windows registry. - -Note that the server provides no way to exit. We can make it exit -whenever our interface object is destroyed. This is a little simplistic, -since it does not correctly handle the case in which two servers are -created, but it will suffice for our example. - -#. Add the following code to *RotNExample-server.dylan*. - -.. code-block:: dylan - - define method terminate (this :: ) => () - next-method(); - PostQuitMessage(0); // Cause main event loop to terminate. - end; - -The ``PostQuitMessage`` call causes the next call to ``GetMessage`` (in -the main event loop) to return ``#f``, and thus cause the program to exit. - -#. Build the project with **Project > Build**. - -During the build, you will be prompted for the location of the project -file *RotNExample-server-stubs.hdp*. + .. code-block:: dylan + + define method main () => () + if (OLE-util-register-only?()) + register-coclass($RotNExample-type-info, + "Harlequin.RotNExample"); + else + let factory :: + = make-object-factory($RotNExample-type-info); + with-stack-structure (pmsg :: ) + while (GetMessage(pmsg, $NULL-HWND, 0, 0)) + TranslateMessage(pmsg); + DispatchMessage(pmsg); + end while; + end with-stack-structure; + revoke-registration(factory); + end if; + end method main; + + With this code in place, if the server is invoked from the command line + with ``/RegServer`` as an argument, ``OLE-util-register-only?`` will return + ``#t``. The call to ``register-coclass`` creates a type library (with + extension .TLB) and registers the type library and the server itself in + the Windows registry. + + Note that the server provides no way to exit. We can make it exit + whenever our interface object is destroyed. This is a little simplistic, + since it does not correctly handle the case in which two servers are + created, but it will suffice for our example. + +#. Add the following code to :file:`RotNExample-server.dylan`. + + .. code-block:: dylan + + define method terminate (this :: ) => () + next-method(); + PostQuitMessage(0); // Cause main event loop to terminate. + end; + + The ``PostQuitMessage`` call causes the next call to ``GetMessage`` (in + the main event loop) to return ``#f``, and thus cause the program to exit. + +#. Build the project with :menuselection:`Project --> Build`. + + During the build, you will be prompted for the location of the project + file *RotNExample-server-stubs.hdp*. Creating the client stubs library --------------------------------- @@ -468,67 +468,71 @@ Creating the client stubs library Now we create a project for the client-side stubs of the encryption interface. -Choose **File > New...** from the main window. +Choose :menuselection:`File --> New...` from the main window. -#. Select **Project** and click **OK**. +#. Select :guilabel:`Project` and click :guilabel:`OK`. -The New Project wizard appears. + The New Project wizard appears. -#. In the Project Type section, select "Interface to COM Type Library" - and click **Next**. -#. Click **Browse...** and navigate to the Open Dylan examples folder. +#. In the :guilabel:`Project Type` section, select :guilabel:`Interface to COM Type Library` + and click :guilabel:`Next`. +#. Click :guilabel:`Browse...` and navigate to the Open Dylan examples folder. -The folder required is called Examples and is placed under the top-level -Open Dylan folder. + The folder required is called Examples and is placed under the top-level + Open Dylan folder. -It is usually *C:\\Program Files\\Open Dylan\\Examples*. + It is usually :file:`C:\\Program Files\\Open Dylan\\Examples`. -#. Go to the *Documentation\\RotNExample* subfolder and choose the - *RotNExample.tlb* file. -#. Click **Next** to continue to the next page of the wizard. -#. Select "Dispatch client interfaces" and click **Next** to continue to - the next page of the wizard. -#. Choose "Translate all" on the next page, so that both the RotNExample - COM class and the IRotNExample interface are translated. Click **Next**. +#. Go to the :file:`Documentation\\RotNExample` subfolder and choose the + :file:RotNExample.tlb` file. +#. Click :guilabel:`Next` to continue to the next page of the wizard. +#. Select :guilabel:`Dispatch client interfaces` and click + :guilabel:`Next` to continue to the next page of the wizard. +#. Choose :guilabel:`Translate all` on the next page, so that both the RotNExample + COM class and the IRotNExample interface are translated. Click :guilabel:`Next`. #. Change the name of the project to *RotNExample-client-stubs*. #. Choose a suitable Location for the project. -#. Make sure that the "Dynamic Link Library (DLL)" option is chosen in - the Project Settings and Templates section. -#. Make sure that the "Include any available templates" option is *not* +#. Make sure that the :guilabel:`Dynamic Link Library (DLL)` option is chosen in + the :guilabel:`Project Settings and Templates` section. +#. Make sure that the :guilabel:`Include any available templates` option is *not* chosen. -#. Click **Next** to continue. +#. Click :guilabel:`Next` to continue. -We are now at the Use Libraries page. We are only defining the stubs for -the client, so we do not need any unusual libraries. + We are now at the :guilabel:`Use Libraries` page. We are only + defining the stubs for the client, so we do not need any unusual + libraries. -#. Choose the "Simple" option and click **Next**. -#. Choose the "Standard IO streams and string formatting" option from - "IO and system support", and click **Next**. -#. Choose the "Win32 API" option from "GUI support", and click **Next**. +#. Choose the :guilabel:`Simple` option and click :guilabel:`Next`. +#. Choose the :guilabel:`Standard IO streams and string formatting` option from + :guilabel:`IO and system support`, and click :guilabel:`Next`. +#. Choose the :guilabel:`Win32 API` option from :guilabel:`GUI + support`, and click :guilabel:`Next`. -Note that the "OLE Automation" option on the "OLE Automation support" -page is automatically selected. That is what we want. + Note that the :guilabel:`OLE Automation` option on the + :guilabel:`OLE Automation support` page is automatically + selected. That is what we want. -#. Click **Next**. -#. Choose the "None" option from "Database support" and click **Next**. +#. Click :guilabel:`Next`. +#. Choose the :guilabel:`None` option from :guilabel:`Database + support` and click :guilabel:`Next`. -We are now at the final page of the New Project wizard. + We are now at the final page of the New Project wizard. #. Make any changes you want to the Source File Headers section. -#. Click **Finish**. +#. Click :guilabel:`Finish`. -The new project appears. + The new project appears. -As with the server stubs project, we have to build this project to make -the type library tool run. + As with the server stubs project, we have to build this project to make + the type library tool run. -#. Build the project with **Project > Build**. +#. Build the project with :menuselection:`Project --> Build`. -As before, files are added to the project. The -*type-library-module.dylan* file serves the same purpose as with the -server stubs. The difference is that *stubs.dylan* contains different -code. It defines a dispatch-client class for the *IRotNExample* -interface: + As before, files are added to the project. The + :file:`type-library-module.dylan` file serves the same purpose as with the + server stubs. The difference is that :file:`stubs.dylan` contains different + code. It defines a dispatch-client class for the *IRotNExample* + interface: .. code-block:: dylan @@ -548,106 +552,106 @@ interface: (arg-result :: ), name: "decrypt", disp-id: 24577; end dispatch-client ; -This defines a class ```` which allows a client to use the -described interface. + This defines a class ```` which allows a client to use the + described interface. -There is also generated code corresponding to the COM class RotNExample -from the type library: + There is also generated code corresponding to the COM class RotNExample + from the type library: -.. code-block:: dylan + .. code-block:: dylan - /* COM class: RotNExample version 0.0 - * GUID: {C44502DB-3EB1-11D2-A3CA-0060B0572A7F} - * Description: Implementation of IRotNExample. - */ + /* COM class: RotNExample version 0.0 + * GUID: {C44502DB-3EB1-11D2-A3CA-0060B0572A7F} + * Description: Implementation of IRotNExample. + */ - define constant $RotNExample-class-id = - as(, "{C44502DB-3EB1-11D2-A3CA-0060B0572A7F}"); - define function make-RotNExample () - => (default-interface :: ) - let default-interface = make(, - class-id: $RotNExample-class-id); - values(default-interface) - end function make-RotNExample; + define constant $RotNExample-class-id = + as(, "{C44502DB-3EB1-11D2-A3CA-0060B0572A7F}"); + define function make-RotNExample () + => (default-interface :: ) + let default-interface = make(, + class-id: $RotNExample-class-id); + values(default-interface) + end function make-RotNExample; -This function creates an instance of the RotNExample COM class, and -returns its default (and only) interface. + This function creates an instance of the RotNExample COM class, and + returns its default (and only) interface. Creating the client ------------------- Now we create the actual client application. -Choose **File > New...** from the main window. +Choose :menuselection:`File --> New...` from the main window. -#. Select **Project** and click **OK**. +#. Select :guilabel:`Project` and click :guilabel:`OK`. -The New Project wizard appears. + The New Project wizard appears. #. In the Project Type section, select "Console Application (EXE)" and - click **Next** to continue to the next wizard page. + click :guilabel:`Next` to continue to the next wizard page. #. Name the project *RotNExample-client*. #. Choose a suitable Location for the project. #. Make sure the "Include any available templates" option is *not* chosen. -#. Click **Next**. +#. Click :guilabel:`Next`. #. Choose the Simple libraries option, and choose the "Standard IO streams and string formatting" and "OLE Automation" options. -#. Proceed to the last page of the wizard and click **Finish**. -#. In the new project, edit *library.dylan*, and add to the ``define +#. Proceed to the last page of the wizard and click :guilabel:`Finish`. +#. In the new project, edit :file:`library.dylan`, and add to the ``define library`` declaration the following line: -.. code-block:: dylan + .. code-block:: dylan - use RotNExample-client-stubs; + use RotNExample-client-stubs; #. Add the same line to the ``define module`` declaration in - *module.dylan*. + :file:module.dylan`. -We now add code to make the client encrypt and decrypt a simple string -with the default key of 13 and with the key set to 3. + We now add code to make the client encrypt and decrypt a simple string + with the default key of 13 and with the key set to 3. -.. Note:: The remainder of this section of the example involves adding - code to *RotNExample-client.dylan*. A version of this file with all the - code we add in this section is available in the Open Dylan - installation folder, under - *Examples\\Documentation\\RotNExample\\RotNExample-client.dylan*. You - may want to copy that file into place in your project folder rather than - typing code in. + .. Note:: The remainder of this section of the example involves adding + code to :file:`RotNExample-client.dylan`. A version of this file + with all the code we add in this section is available in the Open + Dylan installation folder, under + :file:`*Examples\\Documentation\\RotNExample\\RotNExample-client.dylan`. You + may want to copy that file into place in your project folder rather + than typing code in. -#. Modify the ``main`` method in *RotNExample-client.dylan* to look like +#. Modify the ``main`` method in :file:`RotNExample-client.dylan` to look like the following. -.. code-block:: dylan - - define method main () => () - with-ole - format-out("Client connecting to server.\\n"); - let server = make-RotNExample(); - local method encrypt-and-decrypt () => () - let plaintext = "And he was going ooo-la, oooooo-la..."; - format-out("Plaintext is %=, encrypting.\\n", plaintext); - let ciphertext = IRotNExample/encrypt(server, plaintext); - format-out("Ciphertext is %=, decrypting.\\n", ciphertext); - let decrypted = IRotNExample/decrypt(server, ciphertext); - format-out("Decrypted text is %=.\\n", decrypted); - end method; - encrypt-and-decrypt(); - server.IRotNExample/key := 3; - format-out("Set key to %d.\\n", server.IRotNExample/key); - encrypt-and-decrypt(); - format-out("Client releasing server.\\n"); - release(server); - end with-ole; - end method main; - -The ``with-ole`` macro initializes OLE at entry and uninitializes it at -exit. - -#. Build the project with **Project > Build**. - -During the build, you will be prompted for the location of the project -file *RotNExample-client-stubs.hdp*. + .. code-block:: dylan + + define method main () => () + with-ole + format-out("Client connecting to server.\\n"); + let server = make-RotNExample(); + local method encrypt-and-decrypt () => () + let plaintext = "And he was going ooo-la, oooooo-la..."; + format-out("Plaintext is %=, encrypting.\\n", plaintext); + let ciphertext = IRotNExample/encrypt(server, plaintext); + format-out("Ciphertext is %=, decrypting.\\n", ciphertext); + let decrypted = IRotNExample/decrypt(server, ciphertext); + format-out("Decrypted text is %=.\\n", decrypted); + end method; + encrypt-and-decrypt(); + server.IRotNExample/key := 3; + format-out("Set key to %d.\\n", server.IRotNExample/key); + encrypt-and-decrypt(); + format-out("Client releasing server.\\n"); + release(server); + end with-ole; + end method main; + + The ``with-ole`` macro initializes OLE at entry and uninitializes it at + exit. + +#. Build the project with :menuselection:`Project --> Build`. + + During the build, you will be prompted for the location of the project + file :file:`RotNExample-client-stubs.hdp`. Testing the client and server pair ---------------------------------- @@ -664,50 +668,50 @@ return ``#t``, and the server to call ``register-coclass``. Open the RotNExample-server project and build it. -#. Select *Project > Settings...* in the RotNExample-server project +#. Select :menuselection:`Project --> Settings...` in the RotNExample-server project window. -The Project Settings dialog appears. + The Project Settings dialog appears. #. On the Debug page, put */RegServer* in the Arguments field, and click - *OK*. + :guilabel:`OK`. #. Start the RotNExample-server application. -The server application registers itself and exits immediately. You can -tell that the server has exited by watching the stop button in the -project window become unavailable. + The server application registers itself and exits immediately. You + can tell that the server has exited by watching the stop button in + the project window become unavailable. -Now that the server is registered, it can be invoked by the client. But -we are going to start the server manually in the environment before -starting the client. That way, if the server fails, we can debug it in -the environment. + Now that the server is registered, it can be invoked by the + client. But we are going to start the server manually in the + environment before starting the client. That way, if the server + fails, we can debug it in the environment. -First, however, we need to remove the */RegServer* argument from the -project settings, so that the server can run normally. + First, however, we need to remove the ``/RegServer`` argument from the + project settings, so that the server can run normally. -#. Select **Project > Settings...** in the RotNExample-server project +#. Select :menuselection:`Project --> Settings...` in the RotNExample-server project window. -The Project Settings dialog appears. + The Project Settings dialog appears. -#. On the Debug page, remove */RegServer* from the Arguments field, and - click **OK**. +#. On the Debug page, remove ``/RegServer`` from the Arguments field, and + click :guilabel:`OK`. #. Start RotNExample-server. #. Start RotNExample-client. -The client should execute, and print something like this:: - - Client connecting to server. - Plaintext is "And he was going ooo-la, oooooo-la...", encrypting. - Ciphertext is "Naq ur jnf tbvat bbb-yn, bbbbbb-yn...", - decrypting. - Decrypted text is "And he was going ooo-la, oooooo-la...". - Set key to 3. - Plaintext is "And he was going ooo-la, oooooo-la...", encrypting. - Ciphertext is "Dqg kh zdv jrlqj rrr-od, rrrrrr-od...", - decrypting. - Decrypted text is "And he was going ooo-la, oooooo-la...". - Client releasing server. + The client should execute, and print something like this:: + + Client connecting to server. + Plaintext is "And he was going ooo-la, oooooo-la...", encrypting. + Ciphertext is "Naq ur jnf tbvat bbb-yn, bbbbbb-yn...", + decrypting. + Decrypted text is "And he was going ooo-la, oooooo-la...". + Set key to 3. + Plaintext is "And he was going ooo-la, oooooo-la...", encrypting. + Ciphertext is "Dqg kh zdv jrlqj rrr-od, rrrrrr-od...", + decrypting. + Decrypted text is "And he was going ooo-la, oooooo-la...". + Client releasing server. Creating vtable and dual interfaces =================================== diff --git a/documentation/source/getting-started-ide/delivery.rst b/documentation/source/getting-started-ide/delivery.rst index 123df96032..812ca9ab89 100644 --- a/documentation/source/getting-started-ide/delivery.rst +++ b/documentation/source/getting-started-ide/delivery.rst @@ -21,10 +21,9 @@ But to deliver your Dylan application to a customer or other third party, you will need to include in your distribution the Open Dylan run-time libraries that the application uses. -This chapter discusses two methods of delivering Dylan applications with -the necessary run-time libraries: using the environment to build a -Release folder, and using Open Dylan's stand-alone run-time library -installer. +This chapter discusses how to deliver Dylan applications with +the necessary run-time libraries using the environment to build a +Release folder. Building a release folder ========================= @@ -42,32 +41,6 @@ You can then distribute the entire *Release* folder as a stand-alone application. Read the Open Dylan license agreement for details of the legal side of redistributing the Open Dylan run-time libraries. -Using the run-time library installer -==================================== - -An alternative to building a single release folder is to use Open -Dylan's run-time library installer, a self-extracting executable that -installs all the Open Dylan run-time libraries (DLLs) in a central -location. - -The default location is - -:: - - C:\Program Files\Common Files\Harlequin\System - -The run-time library installer also sets the PATH environment variable -to include this folder. - -Your distributable application should then consist of a copy of your -compiled application files from the project's *Bin* folder, and the -run-time installer. - -The run-time library installer is included on CD-ROM editions of -Open Dylan, and can also be downloaded from Harlequin's World Wide -Web site. You can distribute the run-time installer to customers, or -allow them to download it themselves. - About the run-time library DLLs =============================== diff --git a/documentation/source/getting-started-ide/projects.rst b/documentation/source/getting-started-ide/projects.rst index aee30725c8..7fb0e107d1 100644 --- a/documentation/source/getting-started-ide/projects.rst +++ b/documentation/source/getting-started-ide/projects.rst @@ -20,19 +20,20 @@ We now create a new project for a simple "Hello World" application that will run in an MS-DOS console window. We create the project by clicking the New Project (|image0|) button in -the main window, or by choosing **File > New** in any window. +the main window, or by choosing :menuselection:`File --> New...` in any window. -Click the New Project button in the main window. +Click the :guilabel:`New Project` button in the main window. -The New Project wizard appears. +The :guilabel:`New Project` wizard appears. .. figure:: images/pwiz.png :align: center The New Project wizard. -The New Project wizard guides us through the process of creating a new -project. Across a series of pages, it gathers the following information: +The :guilabel:`New Project` wizard guides us through the process of +creating a new project. Across a series of pages, it gathers the +following information: - The type of target file (.EXE or .DLL) that should be created when the project is built. @@ -45,9 +46,9 @@ creates a new project, consisting of the following files: - A project file. The file has the same name as you give the project, but with a .HDP extension. -- A Dylan source file, called *library.dylan*, that defines a library +- A Dylan source file, called :file:`library.dylan`, that defines a library with the same name as the project -- A Dylan source file, called *module.dylan*, that defines a module +- A Dylan source file, called :file:`module.dylan`, that defines a module with the same name as the project - An initial Dylan source file into which we can write application code. The file has the same name as the project, but with a .DYLAN @@ -65,10 +66,10 @@ code to be included in your project. And for GUI applications that use the DUIM library, there can also be: -- A Dylan source file, called *frame.dylan*, that defines the +- A Dylan source file, called :file:`frame.dylan`, that defines the application's DUIM frame and a set of default menus. -The *frame.dylan* file appears only if you ask for template code to be +The :file:`frame.dylan` file appears only if you ask for template code to be included in your project. We discuss this in `Projects for GUI applications`_. @@ -87,7 +88,7 @@ application, so we need to change this option setting from the default. Select "Console Application (EXE)" in the Project type box. -Click **Next**. +Click :guilabel:`Next`. We now move to the second page. @@ -134,7 +135,7 @@ automatically generated project and source files. The New Project wizard will create the folder in the Location box automatically if it does not already exist. -Click **Next**. +Click :guilabel:`Next`. We now move to the third page. @@ -145,30 +146,32 @@ The next stage in creating our project is to decide which libraries and modules it is going to use. The third page of the wizard offers three different ways to do this. Each of the three options is described below. -- Minimal If we choose this the project uses the Functional-Dylan - library only. -- Functional-Dylan is a convenience library that combines the standard - Dylan library with a language extensions library called - Functional-Extensions. Thus Functional-Dylan provides a "Harlequin - dialect" of Dylan. (The standard Dylan library, without Harlequin's - extensions, is also included in the set of Open Dylan - libraries.) -- Simple If we choose this the wizard presents a series of choices we +Minimal + If we choose this, the project uses the :lib:`common-dylan` + library only. This is a convenience library that combines the + standard :lib:`dylan` library with several extensions modules such + as :mod:`dylan-extensions`. The :lib:`common-dylan` library also + includes the standard (unextended) :mod:`dylan` module. + +Simple + If we choose this, the wizard presents a series of choices we can make to determine which libraries and modules the project should use. -- Custom If we choose this the wizard presents a table of all the + +Custom + If we choose this, the wizard presents a table of all the libraries and modules available, and allows us to select the ones we want our project to use. -All our Hello project needs to do is print a text message saying "Hello -World" to the standard output in an MS-DOS console window. The -Functional-Dylan library contains a function to do this, so for our -project we can select the Minimal button and move on to the next page in -the wizard. +All our Hello project needs to do is print a text message saying +"Hello World" to the standard output in a console window. The +:lib:`common-dylan` library contains a function to do this, so for our +project we can select the :guilabel:`Minimal` button and move on to +the next page in the wizard. -Select **Minimal** in the Use Libraries box. +Select :guilabel:`Minimal` in the :guilabel:`Use Libraries` box. -Click **Next**. +Click :guilabel:`Next`. We now move to the final page. @@ -201,7 +204,7 @@ additional one that Open Dylan accepts. Change the default keyword text as you wish, or turn the keywords off altogether. -Click **Finish**. +Click :guilabel:`Finish`. Now we have supplied all the information the wizard asks for, it creates the new Hello project and opens it. @@ -212,7 +215,7 @@ Examining the files in the Hello project :ref:`hello-project` shows our new Hello project. The default view shows the Sources page, where we can see the files -*library.dylan*, *module.dylan*, and *Hello.dylan*. +:file:`library.dylan`, :file:`module.dylan`, and :file:`Hello.dylan`. .. _hello-project: @@ -222,9 +225,9 @@ The default view shows the Sources page, where we can see the files The Hello project. The *library.dylan* file defines a Dylan library called *Hello*, which -uses the library *harlequin-dylan*. The *module.dylan* file defines a +uses the library :lib:`common-dylan`. The *module.dylan* file defines a module of the *Hello* library which is also called *Hello*, and which -uses various modules exported from the *harlequin-dylan* library. +uses various modules exported from the :lib:`common-dylan` library. The *Hello.dylan* file is an initial file into which we can write the code for our project. It contains a default start function called *main*, @@ -246,22 +249,22 @@ Add the following code in the definition of *main*: format-out("Hello World\\n"); -Choose **File > Save** to save the change to *Hello.dylan*. +Choose :menuselection:`File --> Save` to save the change to *Hello.dylan*. Now we can build our "Hello World" application. -Choose **Project > Build** in the project window. +Choose :menuselection:`Project --> Build` in the project window. -Test the application by choosing **Project > Start**. +Test the application by choosing :menuselection:`Project --> Start`. -An MS-DOS console window appears, into which "Hello World" is written. +A console window appears, into which "Hello World" is written. Then a notifier dialog appears to confirm that the console application has terminated. -You can find the *hello.exe* file in the *bin* subfolder of the *Hello* -project folder we specified on the second page of the New Project -wizard. See :ref:`projects-on-disk` for more details of where build -products reside. +You can find the :file:`hello.exe` file in the :file:`bin` subfolder +of the *Hello* project folder we specified on the second page of the +:guilabel:`New Project` wizard. See :ref:`projects-on-disk` for more +details of where build products reside. Projects for GUI applications ----------------------------- @@ -276,13 +279,13 @@ Creating a GUI project First, we create the new project for our GUI application. -Click the New Project (|image1|) button in the main window. +Click the :guilabel:`New Project` (|image1|) button in the main window. On the first page, we want to specify the project type. Select "GUI Application (EXE)" in the Project type box. -Click **Next**. +Click :guilabel:`Next`. We now move to the second page of the wizard. @@ -290,28 +293,29 @@ Here, we want to name the project and specify a folder for its files. Name the project *GUI-App* and choose a location for it. -The New Project wizard can set up some skeleton program code for our -project, according to the project's characteristics as we specify them. -Template code is not relevant for all kinds of projects — for instance, -our Hello project would not have benefited from any more initial program -structure than it had — but the wizard will include any that is relevant -if we check the "Include any available templates" box. +The :guilabel:`New Project` wizard can set up some skeleton program +code for our project, according to the project's characteristics as we +specify them. Template code is not relevant for all kinds of projects +— for instance, our Hello project would not have benefited from any +more initial program structure than it had — but the wizard will +include any that is relevant if we check the "Include any available +templates" box. -Make sure the "Include any available templates" box is checked. +Make sure the :guilabel:`Include any available templates` box is checked. -We ignore the **Advanced...** button again. +We ignore the :guilabel:`Advanced...` button again. -Click **Next**. +Click :guilabel:`Next`. We now move to the third page of the wizard. When we created the Hello project, we chose the Minimal option here, to -use only the Functional-Dylan library. Our GUI application also needs to +use only the :lib:`common-dylan` library. Our GUI application also needs to use other libraries for access to the native window system. -Select "Simple" in the Use Libraries box. +Select :guilabel:`Simple` in the :guilabel:`Use Libraries` box. -Click **Next**. +Click :guilabel:`Next`. We now proceed through a series of pages allowing us to specify our project requirements in high-level terms, without knowing the names of @@ -327,7 +331,8 @@ On the first page we can specify the what I/O and system support we want in our project. For each option, the wizard shows which libraries the project will use. -Leave the default settings on this page as they are, and click **Next**. +Leave the default settings on this page as they are, and click +:guilabel:`Next`. The next page is for specifying GUI support details. Here, we can decide whether we want to do the window programming for the application by @@ -335,25 +340,25 @@ using DUIM, Open Dylan's high-level GUI toolkit, or by using the Win32 API libraries described in the *C FFI and Win32* library reference. We want to use DUIM in this project. -Select "Dylan User Interface Manager (DUIM)". +Select :guilabel:`Dylan User Interface Manager (DUIM)`. -Click **Next**. +Click :guilabel:`Next`. Now the wizard offers different pages, which we don't explain here. We will keep clicking *Next* until we get to the last page of the wizard. This is the page for specifying source file headers, as we saw in `The final page in the New Project wizard`_. -Click **Next** until the last page of the wizard appears. +Click :guilabel:`Next` until the last page of the wizard appears. If you made any changes to this page last time, they will have been -preserved. Whenever you click **Finish**, the wizard saves all these +preserved. Whenever you click :guilabel:`Finish`, the wizard saves all these headers (except *Synopsis:* ) and some other details, and reinstates them next time you create a project. See `Saving settings in the New Project wizard`_ for a list of the details that the wizard saves. -Make any changes you want to here, and then click **Finish**. +Make any changes you want to here, and then click :guilabel:`Finish`. The wizard creates the new GUI-App project and opens it. @@ -364,11 +369,11 @@ Now, we examine the template code that the wizard has set up for us in the GUI-App project sources. The GUI-App project contains the same basic set of files as Hello. There -is a *library.dylan* file, a *module.dylan* file, and a *GUI-App.dylan* -file. In addition, there is a *GUI-App-info.dylan* file and a -*frame.dylan* file. +is a :file:`library.dylan` file, a :file:`module.dylan` file, and a :file:`GUI-App.dylan` +file. In addition, there is a :file:`GUI-App-info.dylan` file and a +:file:`frame.dylan` file. -The *GUI-App-info.dylan* file appears whenever you choose "GUI +The :file:`GUI-App-info.dylan` file appears whenever you choose "GUI Application (EXE)" as the target type on the first page of the wizard. It contains some simple code that you might want to use for identifying your application and its version number. @@ -380,9 +385,9 @@ windows. More knowledge of DUIM is necessary to understand the code in actually does when we build the project. All projects including template code can be built without requiring any further work. -Choose **Project > Build** in the GUI-App project window. +Choose :menuselection:`Project --> Build` in the GUI-App project window. -Choose **Application > Start**. +Choose :menuselection:`Project --> Start`. An application window appears. @@ -392,12 +397,14 @@ An application window appears. The GUI-App skeleton application. We can see from the window that the template code creates a skeleton -application with File, Edit, and Help menus. There is even some -functionality attached to the basic application. If we choose **File > -New**, an editor pane is initialized, into which we can type. The other -**File** and **Edit** menu commands have their standard effects. The **Help > -About** command uses some of the constants from *GUI-App-info.dylan* to -identify the application as "GUI-App Version 1.0". +application with :guilabel:`File`, :guilabel:`Edit`, and +:guilabel:`Help` menus. There is even some functionality attached to +the basic application. If we choose :menuselection:`File --> New`, an +editor pane is initialized, into which we can type. The other +:guilabel:`File` and :guilabel:`Edit` menu commands have their +standard effects. The :menuselection:`Help --> About` command uses some of the +constants from :file:`GUI-App-info.dylan` to identify the application as +"GUI-App Version 1.0". Creating a project using the Custom library option ================================================== @@ -407,7 +414,7 @@ allows complete control over the libraries and modules a project will use. This section explains how to choose libraries and modules using this option. -After selecting Custom and clicking *Next*, the wizard shows a page +After selecting Custom and clicking :guilabel:`Next`, the wizard shows a page with three list panes. We can make selections from each list pane. At first, the only list enabled is the Choose Library Groups list. @@ -436,26 +443,27 @@ Select "Core" in the Library Group list. .. figure:: images/p2frag2-0.png :align: center - Functional-Dylan is the default library for use in new projects. + The :lib:`common-dylan` library is the default for use in new projects. -So, by default, a project would use the library Functional-Dylan. (Note -that Functional-Dylan is the default library for use in new projects. +So, by default, a project would use the library :lib:`common-dylan`. (Note +that :lib:`common-dylan` is the default library for use in new projects. Your copy of Open Dylan may have more library groups.) -If we now select Functional-Dylan in the Library list, we can see which -modules from the Functional-Dylan library a default project would +If we now select :lib:`common-dylan` in the Library list, we can see which +modules from the common-dylan library a default project would include. -Select "Functional-Dylan" in the Library list. +Select :mod:`common-dylan` in the module name list. .. figure:: images/p2frag2_2-0.png :align: center - Default modules from Functional-Dylan for use in new projects. + Default modules from Common-Dylan for use in new projects. -Although the list shows that the Dylan and Functional-Extensions modules -are not used, they are actually used indirectly, since the -Functional-Dylan module is simply a repackaging of those two modules. +Although the list shows that the :mod:`dylan` and +:mod:`common-extensions` modules are not used, they are actually used +indirectly, since the :mod:`common-dylan` module is simply a +repackaging of those two modules. Remember that, in Dylan, the library is the unit of compilation, and modules are simply interfaces to functionality within a library. By @@ -469,27 +477,28 @@ be any smaller on disk, or in memory when it is running. Saving settings in the New Project wizard ========================================= -Whenever you click **Finish** on the last page of the New Project wizard, -the wizard stores some of the choices and text-field settings you made -so that they are available next time you create a project. The details -that are saved persistently are as follows. +Whenever you click :guilabel:`Finish` on the last page of the New +Project wizard, the wizard stores some of the choices and text-field +settings you made so that they are available next time you create a +project. The details that are saved persistently are as follows. - The parent of the folder in the Location box. The parent folder is saved in the expectation that you will want to create several projects in sibling folders. -- In the *Advanced...* dialog (see `Advanced project settings`_), - the contents of the Start Function box and the setting of - Compilation Mode. -- The setting of the "Include any available templates" check-box. +- In the :guilabel:`Advanced...` dialog (see `Advanced project settings`_), + the contents of the :guilabel:`Start Function` box and the setting of + :guilabel:`Compilation Mode`. +- The setting of the :guilabel:`Include any available templates` check-box. On the last wizard page: -- The contents of the Source File Headers boxes, except for *Synopsis:*. +- The contents of the :guilabel:`Source File Headers` boxes, except + for :guilabel:`Synopsis:`. -*Synopsis:* is not saved because it is likely to change with each new -project. +:guilabel:`Synopsis:` is not saved because it is likely to change with +each new project. Nothing from the first page is saved. @@ -499,18 +508,20 @@ Nothing from the first page is saved. Advanced project settings ========================= -The *Advanced...* button on the first page of the New Project wizard -leads to the Advanced Project Settings dialog. The dialog has five +The :guilabel:`Advanced...` button on the first page of the New Project wizard +leads to the :guilabel:`Advanced Project Settings` dialog. The dialog has five sections. -The Library and Module Names section allows you to specify names for -your project's main library and module. The default value in both cases -is the name of the project. +The :guilabel:`Library and Module Names` section allows you to specify +names for your project's main library and module. The default value in +both cases is the name of the project. -The remaining sections — Start Function, Version Information, Compilation -Mode, and Windows Subsystem — all control settings that you can both set -here and change after creating a project by choosing **Project > -Settings...**. See `Project settings`_ for details. +The remaining sections — :guilabel:`Start Function`, +:guilabel:`Version Information`, :guilabel:`Compilation Mode`, and +:guilabel:`Windows Subsystem` — all control settings that you can both +set here and change after creating a project by choosing +:menuselection:`Project --> Settings...`. See `Project settings`_ for +details. Adding, moving, and deleting project sources ============================================ @@ -524,10 +535,10 @@ re-order them, and how to delete them from the project. Inserting files into a project ------------------------------ -To insert a new file or subproject into a project, choose **Project > -Insert File...** in the project window. The project window prompts you -with the *Insert File into Project* dialog, through which you can find a -file to insert. +To insert a new file or subproject into a project, choose +:menuselection:`Project --> Insert File...` in the project window. The +project window prompts you with the :guilabel:`Insert File into +Project` dialog, through which you can find a file to insert. The file you choose will appear below the currently selected file in the list, unless you insert a subproject (a .HDP file), which will appear at @@ -551,8 +562,8 @@ Moving the position of a file within a project ---------------------------------------------- To move a file to a new position in a project, select the file in the -Sources page and use **Project > Move File Up** and **Project > Move File -Down**. +Sources page and use :menuselection:`Project --> Move File Up` and +:menuselection:`Project --> Move File Down`. .. index:: single: projects; deleting files from @@ -561,13 +572,15 @@ Deleting files from a project ----------------------------- To delete a file from a project, select the file in the Sources page and -choose **Project > Remove File**. You could also select **Edit > Cut**, -**Edit > Delete**, or the scissors toolbar icon. +choose :menuselection:`Project --> Remove File`. You could also select +:menuselection:`Edit --> Cut`, +:menuselection:`Edit --> Delete`, or the scissors toolbar icon. Open Dylan asks you if you are sure you want to delete the file from the project, because you cannot undo the operation. Note that the file is not deleted from disk, just removed from the Sources list in the -project. You can always put it back with **Project > Insert File**. +project. You can always put it back with +:menuselection:`Project --> Insert File`. .. note:: The project window's Definitions page shows the definitions that were part of the project when it was last compiled. The list is taken @@ -589,18 +602,19 @@ The New Project wizard always adds a *start function* to the end of the last file in the project. The Dylan language does not require that a program define an explicit -start function, such as *main* in C or Java. However, when you are -debugging or interacting, Open Dylan finds it useful to know what -you consider to be your program's start function. It allows the name of -your start function to be recorded in its project information. By -default, this name will be *main*, and corresponds to the *main* -function that the New Project creates by default in the *project-name* -*.dylan* file for all new projects. However, you are free to change the -name if you like — there is nothing special about it. +start function, in contrast with ``main`` functions in C or +Java. However, when you are debugging or interacting, Open Dylan finds +it useful to know what you consider to be your program's start +function. It allows the name of your start function to be recorded in +its project information. By default, this name will be ``main``, and +corresponds to the ``main`` function that the New Project wizard creates by +default in the *project-name* *.dylan* file for all new +projects. However, you are free to change the name if you like — there +is nothing special about it. The *project-name* *.dylan* file for all new projects will contain a definition of *main* and a call to it. Projects that include template -code will contain this definition of *main* : +code will contain this definition of ``main`` : .. code-block:: dylan @@ -626,25 +640,27 @@ with this expression: end; The name of the Start Function is one of the project settings you can -change in the **Project > Settings...** dialog. It appears on the Debug page -in the Start Function section. The default name is *main*, but you can +change in the :menuselection:`Project --> Settings...` dialog. It appears on the :guilabel:`Debug` page +in the :guilabel:`Start Function` section. The default name is ``main``, but you can change it to any valid Dylan name you like. If you do so, make sure to -replace the call to *main* with a call to your new start function. The +replace the call to ``main`` with a call to your new start function. The source file is not updated automatically. -Note that you can make the wizard use a different start function name in -new project files by changing the default setting in the Advanced -Project Settings dialog. Click **Advanced...** on the second wizard page to -produce the dialog. In this case, the generated project code will call -the correct new name without requiring you to make a change by hand. +Note that you can make the wizard use a different start function name +in new project files by changing the default setting in the +:guilabel:`Advanced Project Settings` dialog. Click +:guilabel:`Advanced...` on the second wizard page to produce the +dialog. In this case, the generated project code will call the correct +new name without requiring you to make a change by hand. The debugger uses the start function name to know where to pause a -program that you start up in interaction mode with **Application > -Interact** or the Interact (|image2|) toolbar button, or in debugging -mode with **Application > Debug**. When you start a program either way, -the debugger allows the program to execute normally, but sets a -breakpoint on the start function so that interaction or debugging begins -at a point where the entire program has already been initialized. +program that you start up in interaction mode with +:menuselection:`Application --> Interact` or the Interact (|image2|) +toolbar button, or in debugging mode with :menuselection:`Application +--> Debug`. When you start a program either way, the debugger allows +the program to execute normally, but sets a breakpoint on the start +function so that interaction or debugging begins at a point where the +entire program has already been initialized. If no start function is nominated for a project, the program pauses precisely before it exits but after everything in it has executed. This @@ -665,16 +681,17 @@ is usually what we want for a DLL, but not for an application. Project settings ================ -The **Project > Settings...** dialog allows you to set options for -compiling, linking, and debugging projects. There are separate pages for -each category, each described below. +The :menuselection:`Project --> Settings...` dialog allows you to set +options for compiling, linking, and debugging projects. There are +separate pages for each category, each described below. Compile page ------------ -The **Project > Settings...** dialog's Compile page controls the compilation -mode setting for the current project. Any project can be compiled in one -of two modes: Interactive Development mode, and Production mode. See +The :menuselection:`Project --> Settings...` dialog's +:guilabel:`Compile` page controls the compilation mode setting for the +current project. Any project can be compiled in one of two modes: +Interactive Development mode, and Production mode. See :ref:`compilation-modes` for details of the modes. .. index:: @@ -690,11 +707,13 @@ is linked as an executable or as a DLL, and what its name will be. It also allows you to specify version information for the target and the Windows subsystem it runs in. -.. note:: The default linker used in Open Dylan is a GNU linker. If - you own Microsoft Developer Studio, you can use the Microsoft linker - instead. To change the default linker, go to the main window and choose - **Options > Environment Options...**, then choose that dialog's Build - page. +.. note:: The default linker used in Open Dylan is selected at + installation time. To change the default linker, go to the + main window and choose :menuselection:`Tools --> Environment + Options...`, then choose that dialog's :guilabel:`Build` + page. The :guilabel:`Build script` option will allow you to + choose the Jam build script corresponding to a different + linker. Target File section of the Link page ------------------------------------ @@ -718,7 +737,7 @@ See :ref:`versioning` for details. Windows Subsystem section of the Link page ------------------------------------------ -The **Project > Settings...** dialog's Link page has a Win32 Subsystem +The :menuselection:`Project --> Settings...` dialog's Link page has a Win32 Subsystem section that allows you to specify that the target should run in the "Windows GUI" (WINDOWS) subsystem or the "Windows Console" (CONSOLE) subsystem. You may wish to change this value if you change the code of a @@ -736,18 +755,19 @@ to run in the "Windows GUI" (WINDOWS) subsystem. Debug page ---------- -The **Project > Settings...** dialog's Debug page allows you to specify a -command line with which to execute the project target, and the start -function for the project. +The :menuselection:`Project --> Settings...` dialog's +:guilabel:`Debug` page allows you to specify a command line with which +to execute the project target, and the start function for the project. The command line facility is especially useful for testing console applications from within the development environment. If there are -values in the Command Line section of this dialog when you run a project -target with *Project > Start* (and similar commands), Open Dylan -uses them to execute the application. It creates a new process from the -executable named in the Executable field and passes it the arguments -from the Arguments field. Thus the values in these fields should form a -valid MS-DOS command line when concatenated. +values in the Command Line section of this dialog when you run a +project target with :menuselection:`Application --> Start` (and +similar commands), Open Dylan uses them to execute the application. It +creates a new process from the executable named in the Executable +field and passes it the arguments from the Arguments field. Thus the +values in these fields should form a valid command line when +concatenated. See `The project start function`_ for details of the start function. @@ -763,12 +783,13 @@ Project files and LID files =========================== Open Dylan's project files can be exported in a portable library -interface format called LID (library interchange description). Harlequin -and other Dylan vendors have chosen LID as the standard interchange -format for Dylan libraries. LID files describe libraries in a flat ASCII -text format for ease of interchange between different Dylan systems. The -*Core Features and Mathematics* reference volume describes the LID -format. LID files must have the extension .LID. +interface format called LID (library interchange description). The +Open Dylan project and other Dylan vendors have chosen LID as the +standard interchange format for Dylan libraries. LID files describe +libraries in a flat ASCII text format for ease of interchange between +different Dylan systems. The *Core Features and Mathematics* reference +volume describes the LID format. LID files must have the extension +.LID. Opening a LID file as a project ------------------------------- @@ -778,15 +799,16 @@ into a project file and opened in a project window. (This process does not modify the original LID file on disk.) In order to open a LID file as a text file in an editor, open the LID -file using **File > Open** and select the file type filter "Dylan Library -Interchange Descriptions (as text)" before clicking **Open**. +file using :menuselection:`File --> Open...` and select the file type +filter "Dylan Library Interchange Descriptions (as text)" before +clicking :guilabel:`Open`. Exporting a project into a LID file ----------------------------------- To export a project as a LID file for use in other Dylan -implementations, use **File > Save As** and choose the file type "Dylan -Library Interchange Descriptions". +implementations, use :menuselection:`File --> Save As...` and choose the +file type "Dylan Library Interchange Descriptions". Note that a LID file created by export will list source files by name only, and without paths. In addition it will not contain any of the diff --git a/sources/databases/tests/stress-tool/README.html b/sources/databases/tests/stress-tool/README.html index 38fcbf3e46..f293aa75f6 100644 --- a/sources/databases/tests/stress-tool/README.html +++ b/sources/databases/tests/stress-tool/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: Database Stress Tool + Open Dylan Example: Database Stress Tool diff --git a/sources/duim/examples/interface-builder/README.html b/sources/duim/examples/interface-builder/README.html index 50377551df..4f976ae50f 100644 --- a/sources/duim/examples/interface-builder/README.html +++ b/sources/duim/examples/interface-builder/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: interface-builder + Open Dylan Example: interface-builder diff --git a/sources/duim/examples/scribble/README.html b/sources/duim/examples/scribble/README.html index be8e57e347..da46a5ef58 100644 --- a/sources/duim/examples/scribble/README.html +++ b/sources/duim/examples/scribble/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: scribble + Open Dylan Example: scribble @@ -23,7 +23,7 @@

Scribble Example Project

  • Using a popup menu.
    • -

    In Functional Developer Professional and Enterprise editions there +

    In Open Dylan Professional and Enterprise editions there is a companion example called OLE Scribble which demonstrates converting this DUIM application to an OLE control.

    diff --git a/sources/duim/examples/tic-tac-toe/frame.dylan b/sources/duim/examples/tic-tac-toe/frame.dylan index bc10244520..cbca0c7fc7 100644 --- a/sources/duim/examples/tic-tac-toe/frame.dylan +++ b/sources/duim/examples/tic-tac-toe/frame.dylan @@ -6,7 +6,7 @@ Copyright: Original Code is Copyright (c) 1995-2004 Functional Objects, Inc. License: See License.txt in this distribution for details. Warranty: Distributed WITHOUT WARRANTY OF ANY KIND -define constant $application-name = "Functional Developer Tic-Tac-Toe"; +define constant $application-name = "Open Dylan Tic-Tac-Toe"; define constant $application-version = "version 1.0"; define constant $ttt-square-color = $red; diff --git a/sources/duim/examples/win32-scribble/README.html b/sources/duim/examples/win32-scribble/README.html index 41def90d63..cc7abe4d28 100644 --- a/sources/duim/examples/win32-scribble/README.html +++ b/sources/duim/examples/win32-scribble/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: scribble + Open Dylan Example: scribble @@ -18,7 +18,7 @@

    Win32 Scribble Example Project

  • Printing a DUIM window
    • -

    In Functional Developer Professional and Enterprise editions there +

    In Open Dylan Professional and Enterprise editions there is a companion example called OLE Scribble which demonstrates converting this DUIM application to an OLE control.

    diff --git a/sources/duim/tests/gui/README.html b/sources/duim/tests/gui/README.html index 2a73706e35..a758c99bf0 100644 --- a/sources/duim/tests/gui/README.html +++ b/sources/duim/tests/gui/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: duim-gui-test-suite + Open Dylan Example: duim-gui-test-suite @@ -21,7 +21,7 @@

    DUIM Test Suite Example Project

    The file names are intended to be suggestive of their contents. If you can't find something, try using the Find tool in the -Functional Developer IDE to search over all the files in the project +Open Dylan IDE to search over all the files in the project to find what you're looking for.

    diff --git a/sources/environment/project-wizard/project-wizard.dylan b/sources/environment/project-wizard/project-wizard.dylan index 8a7a20d07e..778c83e278 100644 --- a/sources/environment/project-wizard/project-wizard.dylan +++ b/sources/environment/project-wizard/project-wizard.dylan @@ -1087,7 +1087,7 @@ format-to-string("libraries which %s will generate automatically from the IDL fi vertically (y-spacing: 4) make(, label: "&Minimal", id: #"minimal"); indenting ($radio-indent) labels -"Your project will use only the functional-dylan library. There will be no more"; +"Your project will use only the common-dylan library. There will be no"; "more pages for choosing libraries."; end; end; end; @@ -1919,7 +1919,7 @@ define method do-note-page-required-fields-changed end method; // Add some requirement for the chooser-page? E.g., must at least include -// dylan or functional-dylan? +// dylan or common-dylan? // None of the fields for the header-page are required. diff --git a/sources/examples/console/hello-world/README.html b/sources/examples/console/hello-world/README.html index 75251ffbb3..2aa7c3f193 100644 --- a/sources/examples/console/hello-world/README.html +++ b/sources/examples/console/hello-world/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: hello-world + Open Dylan Example: hello-world diff --git a/sources/examples/console/towers-of-hanoi/README.html b/sources/examples/console/towers-of-hanoi/README.html index c4b1ae09af..068261aea3 100644 --- a/sources/examples/console/towers-of-hanoi/README.html +++ b/sources/examples/console/towers-of-hanoi/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: Towers of Hanoi + Open Dylan Example: Towers of Hanoi diff --git a/sources/examples/documentation/reversi/board.dylan b/sources/examples/documentation/reversi/board.dylan index 842b47c16c..976e29525f 100644 --- a/sources/examples/documentation/reversi/board.dylan +++ b/sources/examples/documentation/reversi/board.dylan @@ -253,7 +253,7 @@ define frame () make(, label: "Help", children: vector(make(, - label: "About Functional Developer Reversi", + label: "About Open Dylan Reversi", activate-callback: method (button) about-reversi(sheet-frame(button)) @@ -387,7 +387,7 @@ define method play-reversi let frame = make(, size: board-size, - title: "Functional Developer Reversi"); + title: "Open Dylan Reversi"); start-frame(frame); frame end method play-reversi; @@ -460,5 +460,5 @@ define method reversi-frame-choose-algorithm end method reversi-frame-choose-algorithm; define method about-reversi (frame :: ) => () - notify-user("Functional Developer Reversi version 1.0", owner: frame) + notify-user("Open Dylan Reversi version 1.0", owner: frame) end method about-reversi; diff --git a/sources/examples/odbc/database-viewer/README.html b/sources/examples/odbc/database-viewer/README.html index 74c1c46d5e..6c9ca57ca7 100644 --- a/sources/examples/odbc/database-viewer/README.html +++ b/sources/examples/odbc/database-viewer/README.html @@ -1,7 +1,7 @@ - Functional Developer Example: Database Viewer + Open Dylan Example: Database Viewer diff --git a/sources/harp/harp-coff/cv4-builder.dylan b/sources/harp/harp-coff/cv4-builder.dylan index e1dae7514e..930a2ff853 100644 --- a/sources/harp/harp-coff/cv4-builder.dylan +++ b/sources/harp/harp-coff/cv4-builder.dylan @@ -9,10 +9,6 @@ Warranty: Distributed WITHOUT WARRANTY OF ANY KIND //// Basic CodeView Housekeeping - -define constant $dylan-version - = "Functional DeveloperWorks (R) Dylan compiler Version 1.0"; - define constant $dylan-flags = #x04098010; // 04 = Machine: Intel 80486 // 09 = Language Dylan @@ -26,7 +22,7 @@ define constant $dylan-flags = #x04098010; define method initialize-debug-section (builder :: , object-file-name :: , - #key version = $dylan-version, + #key version = release-full-name(), section-name = ".debug$S") => () let section = select-debug-section(builder, section-name); diff --git a/sources/harp/harp-coff/library.dylan b/sources/harp/harp-coff/library.dylan index 04ef4098e3..fadf76205e 100644 --- a/sources/harp/harp-coff/library.dylan +++ b/sources/harp/harp-coff/library.dylan @@ -13,6 +13,7 @@ define library harp-coff use big-integers; use collections; use io; + use release-info; use coff-manager; use coff-builder; use binary-outputter; diff --git a/sources/harp/harp-coff/module.dylan b/sources/harp/harp-coff/module.dylan index b87fada485..e6af50f77a 100644 --- a/sources/harp/harp-coff/module.dylan +++ b/sources/harp/harp-coff/module.dylan @@ -16,6 +16,7 @@ end module; define module cv4-builder use dylan-and-big-ints; + use release-info; use coff-representation, export: { string-data, symbol-name }; use coff-builder, export: all; export diff --git a/sources/ole/examples/bank/Client/README.html b/sources/ole/examples/bank/Client/README.html index 9bf42c62fa..f005accf3c 100644 --- a/sources/ole/examples/bank/Client/README.html +++ b/sources/ole/examples/bank/Client/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: OLE Bank-Client + Open Dylan Example: OLE Bank-Client @@ -12,13 +12,13 @@

    OLE Bank-Client

    This project contains an example program that demonstrates the use of -custom COM interfaces in Functional Developer. It is the +custom COM interfaces in Open Dylan. It is the client part of the OLE Bank Client/Server -example. It uses the Functional Developer COM library to access +example. It uses the Open Dylan COM library to access the Windows COM functionality. It uses the DUIM library for its user interface.

    -

    The COM library is documented in the Functional Developer +

    The COM library is documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    Building and Testing the Application

    diff --git a/sources/ole/examples/bank/README.html b/sources/ole/examples/bank/README.html index e592dd10ac..60d215f0d9 100644 --- a/sources/ole/examples/bank/README.html +++ b/sources/ole/examples/bank/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: OLE Bank Client/Server + Open Dylan Example: OLE Bank Client/Server @@ -24,13 +24,13 @@

    OLE Bank Client/Server

    The database layer consists of a Microsoft Access(tm) relational database. -The server communicates with the database using Functional Developer's sql-odbc library.

    +The server communicates with the database using Open Dylan's sql-odbc library.

    The server provides a single COM object that represents the bank, and a collection of COM objects representing accounts. The bank object has operations for opening, closing, and retrieving accounts from the database. An account has operations for querying -and updating its balance. The server uses Functional Developer's +and updating its balance. The server uses Open Dylan's OLE-Automation library to implement dual interfaces for all its objects, allowing use with both vtable and dispatch interface clients.

    @@ -41,8 +41,8 @@

    OLE Bank Client/Server

    client passes the requests on to the server and provides a local view of account information obtained from the server. The client provided here implements vtable access to the server via -Functional Developer's COM library. The user interface is implemented -using the Functional Developer DUIM library.

    +Open Dylan's COM library. The user interface is implemented +using the Open Dylan DUIM library.

    To try out this application, first see the Server README file for instructions on diff --git a/sources/ole/examples/bank/Server/README.html b/sources/ole/examples/bank/Server/README.html index 1c66d9c184..9bb1663591 100644 --- a/sources/ole/examples/bank/Server/README.html +++ b/sources/ole/examples/bank/Server/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: OLE Bank-Server + Open Dylan Example: OLE Bank-Server @@ -11,7 +11,7 @@

    OLE Bank-Server

    This project contains an example program that demonstrates the use of -dual COM interfaces and database access in Functional Developer. It is the +dual COM interfaces and database access in Open Dylan. It is the server part of the OLE Bank Client/Server example. It uses the macros and utility functions provided by the OLE-Automation library, rather than the low-level Windows OLE @@ -19,7 +19,7 @@

    OLE Bank-Server

    sql-odbc library to communicate with the database. And it uses the DUIM library to provide a simple user interface.

    -

    The OLE-Automation and sql-odbc libraries are documented in the Functional Developer +

    The OLE-Automation and sql-odbc libraries are documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    ODBC requirements

    @@ -49,7 +49,7 @@

    Registering the Database with ODBC

    This example includes a sample bank database, bankDB.mdb, in the project directory (typically in C:\Program -Files\Functional Objects\Dylan\Examples\ole\bank\server). Before we +Files\Open Dylan\Examples\ole\bank\server). Before we can access this database using ODBC, we need to register it under a data source name in the ODBC control panel. This installation step also tells ODBC which driver to use when connecting to the diff --git a/sources/ole/examples/bank/asp-vb-client/README.html b/sources/ole/examples/bank/asp-vb-client/README.html index 58084f2471..291ad5702c 100644 --- a/sources/ole/examples/bank/asp-vb-client/README.html +++ b/sources/ole/examples/bank/asp-vb-client/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: OLE Bank ASP VB Client + Open Dylan Example: OLE Bank ASP VB Client diff --git a/sources/ole/examples/button-ocx/README.html b/sources/ole/examples/button-ocx/README.html index 1628714c03..01505d9bb1 100644 --- a/sources/ole/examples/button-ocx/README.html +++ b/sources/ole/examples/button-ocx/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: button-ocx + Open Dylan Example: button-ocx @@ -14,7 +14,7 @@

    button-ocx library

    gadget as an OLE Control (also known as an "OCX" or "ActiveX Control").

    This example uses the DUIM-OLE-Control library which is -documented in the Functional Developer "OLE, COM, ActiveX and DBMS" +documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    The file control.dylan defines a frame containing a single diff --git a/sources/ole/examples/ocx-scribble/README.html b/sources/ole/examples/ocx-scribble/README.html index b8655e0c3d..6b43eec217 100644 --- a/sources/ole/examples/ocx-scribble/README.html +++ b/sources/ole/examples/ocx-scribble/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: ocx-scribble + Open Dylan Example: ocx-scribble @@ -15,7 +15,7 @@

    ocx-scribble library

    ActiveX Control).

    This example uses the DUIM-OLE-Control library which is -documented in the Functional Developer "OLE, COM, ActiveX and DBMS" +documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    diff --git a/sources/ole/examples/ole-scribble/README.html b/sources/ole/examples/ole-scribble/README.html index 0565479537..75f65f89b8 100644 --- a/sources/ole/examples/ole-scribble/README.html +++ b/sources/ole/examples/ole-scribble/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: ole-scribble + Open Dylan Example: ole-scribble @@ -14,7 +14,7 @@

    ole-scribble library

    written using DUIM which can be used as an embedded OLE part.

    This example uses the DUIM-OLE-Server library which is -documented in the Functional Developer "OLE, COM, ActiveX and DBMS" +documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    This is a simple drawing program, where the user can do arbitrary diff --git a/sources/ole/examples/sample-automation-controller/README.html b/sources/ole/examples/sample-automation-controller/README.html index 7c443b527b..801829d330 100644 --- a/sources/ole/examples/sample-automation-controller/README.html +++ b/sources/ole/examples/sample-automation-controller/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: Sample-automation-controller + Open Dylan Example: Sample-automation-controller @@ -16,7 +16,7 @@

    Sample-automation-controller library

    Windows OLE API. The program issues commands to the companion program in the project sample-automation-server.

    -

    The OLE-Automation library is documented in the Functional Developer +

    The OLE-Automation library is documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    Before running this program, first either start or register the server diff --git a/sources/ole/examples/sample-automation-server/README.html b/sources/ole/examples/sample-automation-server/README.html index 1345bc8a9d..1533bd32c6 100644 --- a/sources/ole/examples/sample-automation-server/README.html +++ b/sources/ole/examples/sample-automation-server/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: Sample-automation-server + Open Dylan Example: Sample-automation-server @@ -16,7 +16,7 @@

    Sample-automation-server library

    Windows OLE API. The program responds to commands issued by the companion program in the project sample-automation-controller.

    -

    The OLE-Automation library is documented in the Functional Developer +

    The OLE-Automation library is documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    This program by itself doesn't do anything except put an empty window diff --git a/sources/ole/examples/sample-duim-container/README.html b/sources/ole/examples/sample-duim-container/README.html index 66cea13845..bba3ac4cd1 100644 --- a/sources/ole/examples/sample-duim-container/README.html +++ b/sources/ole/examples/sample-duim-container/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: Sample-DUIM-container + Open Dylan Example: Sample-DUIM-container @@ -10,12 +10,12 @@

    Sample-DUIM-container library

    -

    This project contains an example program that demonstrates use of the -Functional Developer DUIM-OLE-container library to support embedding of -graphical objects produced by other programs. It uses the Functional Developer DUIM +

    This project contains an example program that demonstrates use of +the Open Dylan DUIM-OLE-container library to support embedding +of graphical objects produced by other programs. It uses the DUIM framework for the user interface.

    -

    See the Functional Developer "OLE, COM, ActiveX and DBMS" reference +

    See the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual for documentation of the DUIM-OLE-container library which the program uses.

    diff --git a/sources/ole/examples/sample-ole-container/README.html b/sources/ole/examples/sample-ole-container/README.html index 185d2a0c06..91139a3848 100644 --- a/sources/ole/examples/sample-ole-container/README.html +++ b/sources/ole/examples/sample-ole-container/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: sample-ole-container + Open Dylan Example: sample-ole-container @@ -15,7 +15,7 @@

    sample-ole-container library

    by other programs. It uses the low-level OLE API for the compound documents and the low-level Win32 API for user interface.

    -

    See the Functional Developer "OLE, COM, ActiveX and DBMS" reference +

    See the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual for documentation of the OLE library which the program uses.

    @@ -34,8 +34,8 @@

    sample-ole-container library

    and uses the same low-level OLE and user interface APIs as the C++ program. See the example project win32-ole-container for an implementation of the same functionality using the higher-level OLE container framework provided -by Functional Developer. The example project sample-duim-container -additionally uses the Functional Developer DUIM framework for its user interface. +by Open Dylan. The example project sample-duim-container +additionally uses the Open Dylan DUIM framework for its user interface.

    .

    Program internals

    diff --git a/sources/ole/examples/sample-ole-server/README.html b/sources/ole/examples/sample-ole-server/README.html index fcfa0c0b5e..bd68a619a0 100644 --- a/sources/ole/examples/sample-ole-server/README.html +++ b/sources/ole/examples/sample-ole-server/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: sample-ole-server + Open Dylan Example: sample-ole-server @@ -14,7 +14,7 @@

    sample-ole-server library

    low-level OLE interface to create a graphical object that can be embedded in compound documents.

    -

    See the Functional Developer "OLE, COM, ActiveX and DBMS" reference manual for +

    See the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual for documentation of the OLE library which the program uses.

    The example was translated to Dylan from a C++ program in directory @@ -31,7 +31,7 @@

    sample-ole-server library

    version, and uses the same low-level OLE and user interface APIs as the C++ program. See the example project win32-ole-server for an implementation of the same functionality using the higher-level -server framework provided by Functional Developer.

    +server framework provided by Open Dylan.

    Program internals

    diff --git a/sources/ole/examples/win32-invisible-control/README.html b/sources/ole/examples/win32-invisible-control/README.html index 675f880fb0..45caebaaa3 100644 --- a/sources/ole/examples/win32-invisible-control/README.html +++ b/sources/ole/examples/win32-invisible-control/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: win32-invisible-control + Open Dylan Example: win32-invisible-control @@ -19,7 +19,7 @@

    win32-invisible-control library

    some service through its IDispatch interface(s).

    The OLE-control-framework library is documented in the -Functional Developer "OLE, COM, ActiveX and DBMS" reference manual.

    +Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    The program consists of the following source files:

    diff --git a/sources/ole/examples/win32-ole-container/README.html b/sources/ole/examples/win32-ole-container/README.html index 1892742f42..c0b2a46368 100644 --- a/sources/ole/examples/win32-ole-container/README.html +++ b/sources/ole/examples/win32-ole-container/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: win32-ole-container + Open Dylan Example: win32-ole-container @@ -11,10 +11,10 @@

    win32-ole-container library

    This project contains an example program which demonstrates use of the -Functional Developer's ole-container library to support embedding of +Open Dylan's ole-container library to support embedding of graphical OLE objects produced by other programs.

    -

    The OLE-Container library is documented in the Functional Developer +

    The OLE-Container library is documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    This example provides the same simple functionality as the diff --git a/sources/ole/examples/win32-ole-server/README.html b/sources/ole/examples/win32-ole-server/README.html index 52136f2b39..798d0c834c 100644 --- a/sources/ole/examples/win32-ole-server/README.html +++ b/sources/ole/examples/win32-ole-server/README.html @@ -1,6 +1,6 @@ - Functional Developer Example: win32-ole-server + Open Dylan Example: win32-ole-server @@ -15,7 +15,7 @@

    win32-ole-server library

    use of the OLE-Server library to create a graphical object that can be embedded in compound documents.

    -

    The OLE-Server library is documented in the Functional Developer +

    The OLE-Server library is documented in the Open Dylan "OLE, COM, ActiveX and DBMS" reference manual.

    This example provides the same functionality as the C++ program in diff --git a/sources/registry/generic/factorial-small b/sources/registry/generic/factorial-small index 019668c4ff..2d6d0a0467 100644 --- a/sources/registry/generic/factorial-small +++ b/sources/registry/generic/factorial-small @@ -1,2 +1 @@ -abstract://dylan/app/factorial/factorial-small.lid - +abstract://dylan/examples/console/factorial/factorial-small.lid