mirrors/eiffel-org
1
0
Fork 0
mirror of https://github.com/EiffelSoftware/eiffel-org.git synced 2025-12-07 15:22:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added release 19.05.

Browse Source 
git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@2152 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
2019-05-19 11:17:36 +00:00
parent 2c8d6d6f35
commit 5c23b7c968
2939 changed files with 62245 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/create-object.wiki Normal file
View File

@@ -0,0 +1,27 @@
[[Property:title|Create an object]]
[[Property:weight|1]]
[[Property:uuid|b2ef8e81-a045-dce2-725f-c8db5ab1b6db]]
An EiffelBuild [[EiffelBuild Notation|object]] is a representation of an EiffelVision 2 component and its properties.
To create a new instance of an object, [[EiffelBuild Notation|pick]] a type from the [[Type selector|type selector]] and [[EiffelBuild Notation|drop]] onto an existing [[EiffelBuild Notation|object]] (Accessible from the [[Layout constructor|layout constructor]] or [[Builder window|builder window]] ). You will only be able to complete the [[EiffelBuild Notation|drop]] if the targeted [[EiffelBuild Notation|object]] will accept a new object of the transported type.
{{note|Once an [[EiffelBuild Notation|object]] has been [[Create an object|created]] , it will always be contained in a parent [[EiffelBuild Notation|object]] until [[Delete an object|deleted]] . }}
==Creating Window and Dialog Objects==
Window and dialog objects are created by picking a type from the [[Type selector|type selector]] and dropping into the [[Widget selector|widget selector]] . If the target of the drop is a directory within the widget selector, the new object is created within that directory, otherwise in the root of the project location. Window and dialog objects are generated as individual classes by EiffelBuild.
{{note|If there are no other windows or directories in the project, the newly created object is set as the root window.}}
==Creating objects for re-use==
If you wish to create an object that may be re-used in multiple locations within your EiffelBuild project, pick the type from the [[Type selector|type selector]] and drop into the [[Widget selector|widget selector]] . This ensures that at generation time, the object is generated as a seperate class (as with all objects in the [[Widget selector|widget selector]] ). Objects within the [[Widget selector|widget selector]] may be used in a client fashion within other object structures as required, and any changes made to these objects are reflected at all locations in which they are used.
{{seealso|<br/>
[[Type selector|Type selector]] <br/>
[[Reparent an Object|Reparent an object]] <br/>
[[Delete an object|Delete an object]] }}

16
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/delete-object.wiki Normal file
View File

@@ -0,0 +1,16 @@
[[Property:title|Delete an object]]
[[Property:weight|2]]
[[Property:uuid|87dbc23d-4f9c-bd2a-8451-30031b494d37]]
To remove an [[EiffelBuild Notation|object]] from your EiffelBuild system, [[EiffelBuild Notation|pick]] the object you wish to delete, and [[EiffelBuild Notation|drop]] it on [[Image:icon-delete-small-color]] in the [[Main toolbar|main toolbar]] .
You may also delete via the keyboard by pressing the delete key while the tool containing the objects representation has the focus. Whichever [[EiffelBuild Notation|object]] has the selection is deleted.
{{note|To restore a deleted object, you may use the [[History|History]] }}
{{seealso|<br/>
[[History|History]] <br/>
[[Type selector|Type selector]] }}

24
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/eiffelbuild-starting-project/eiffelbuild-creating-new-project.wiki Normal file
View File

@@ -0,0 +1,24 @@
[[Property:title|EiffelBuild: Creating a new project]]
[[Property:weight|0]]
[[Property:uuid|8668676c-a189-5512-319e-34d70d4039e3]]
When a project is not open in Build, there are only two menu options available. 'File' and 'Help'. To create a new project, select 'file', 'New project' as illustrated below:
[[Image:new-project]]
This will bring up a directory dialog from which you can select the directory in which you wish to create the new Build project.
Selecting a directory that does not already contain a Build project will create a new project in that directory and the Build tools will become available for development of the newly created project. If a directory was selected that already contains a Build project, the following dialog will be displayed:
[[Image:overwrite-project]]
Selecting 'Ok' will create a new project, overwriting the existing project, and the Build tools will become available for development of the newly created project.
Selecting 'Cancel' will return you to the directory selection dialog, from which you can select the directory in which you wish to create the new Build project.
{{seealso|<br/>
[[Retrieving a project from a Build project file|Retrieving a project from a Build project file]] <br/>
}}

5
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/eiffelbuild-starting-project/index.wiki Normal file
View File

@@ -0,0 +1,5 @@
[[Property:title|EiffelBuild: Starting a project]]
[[Property:weight|0]]
[[Property:uuid|803e2034-dec3-340c-e68e-fdbaefac8a5a]]

21
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/eiffelbuild-starting-project/retrieving-project-build-project-file.wiki Normal file
View File

@@ -0,0 +1,21 @@
[[Property:title|Retrieving a project from a Build project file]]
[[Property:weight|1]]
[[Property:uuid|556cfd8a-f4df-9778-cbb1-eb4a9d795f01]]
When a project is not open in Build, there are only two menus available, 'File' and 'Help'. To retrieve an existing project, select 'file', 'Open Project
[[Image:open-project]]
A directory dialog will be displayed from which you can select the Build project file that you wish to retrieve. All build project files are named 'build_project.bpr' and are qualified by the directory in which they reside.
You may also open a recent EiffelBuild project via the 'Recent Projects' entry of the 'file' menu as shown below:
[[Image:recent-projects]]
This list contains the most recent projects that have been used within EiffelBuild, and if none are available, this list is empty and the menu option disabled.
{{seealso|<br/>
[[EiffelBuild: Creating a new project|Creating a new project]] }}

22
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/import-project.wiki Normal file
View File

@@ -0,0 +1,22 @@
[[Property:title|Import a project]]
[[Property:weight|5]]
[[Property:uuid|ad0b96e1-ca74-5344-44f1-e066205fb76d]]
The contents of an existing project may be imported into the currently open project, permitting re-use of existing structures. All versions of EiffelBuild before 5.4 limited each project to a single titled window, with 5.4 removing this limitation. The ability to import multiple EiffelBuild projects into a single project is useful for maintaining larger systems with many windows.
To import the contents of an existing project, select 'Import Project' from the 'File' menu as illustrated below:
[[Image:import-project]]
Upon selection of the menu item, a file dialog is displayed prompting for the EiffelBuild project to be imported (".bpr" files) . Selecting a valid EiffelBuild project file causes the import to commence, during which, EiffelBuild is unresponsive. Please be patient, as importing a large EiffelBuild project may take a little while, depending on the speed of the system.
Upon completion of the import, there are two possible outcomes:
* No name clashes occurred: No names from the imported project clashes with those of the open project. In this case, notification of success is displayed in the status bar for a short period of time.
* One or more name clashes occurred: One or more objects or constants from the imported project had names that matched that of objects in the open project. As the names are used directly in the generated code, they must be unique within their scope (accessible within the code), and therefore EiffelBuild must resolve these clashes. A dialog is displayed on screen showing all the names that were resolved by EiffelBuild:
[[Image:import-project-clashes]]
{{note|If a name clash occurs, the names of the imported project are modified, not the open project. }}

5
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/index.wiki Normal file
View File

@@ -0,0 +1,5 @@
[[Property:title|EiffelBuild How To's]]
[[Property:weight|0]]
[[Property:uuid|1df547c8-ca5b-f014-5b4f-a39ecefaa746]]

22
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/reparent-object.wiki Normal file
View File

@@ -0,0 +1,22 @@
[[Property:title|Reparent an Object]]
[[Property:weight|4]]
[[Property:uuid|bf920606-6a40-83fc-5069-034d32f8cd7a]]
To reparent an [[EiffelBuild Notation|object]] , you need to [[EiffelBuild Notation|pick]] the [[EiffelBuild Notation|object]] and [[EiffelBuild Notation|drop]] it on the [[EiffelBuild Notation|object]] you wish it to be parented in. The [[EiffelBuild Notation|object]] will be removed from its current parent, and inserted in the new parent at the next available position.
When an [[EiffelBuild Notation|object]] is inserted into a parent, it is always added at the next available position. If you wish to place an [[EiffelBuild Notation|object]] at a particular position within a parent, you must hold down the '''Shift''' key, and drop on an [[EiffelBuild Notation|object]] already contained in parent, Your [[EiffelBuild Notation|object]] will then be inserted in the parent, in the position preceding the child [[EiffelBuild Notation|object]] that you dropped on.
You can access [[EiffelBuild Notation|objects]] from both the [[Builder window|builder window]] and [[Layout constructor|layout constructor]] .
{{note|Although window and dialog objects may be accessed within the [[Widget selector|widget selector]] , it is not possible to build into these objects, you should use the [[Layout constructor|layout constructor]] or [[Builder window|builder window]] directly in this situation. }}
For more information about an [[EiffelBuild Notation|objects]] capacity and permitted children, see the [[EiffelVision Introduction|EiffelVision 2]] documentation.
{{seealso|<br/>
[[Create an object|Create an object]] <br/>
[[Delete an object|Delete an object]] <br/>
[[Builder window|Builder window]] <br/>
[[Layout constructor|Layout constructor]] }}

15
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-how-tos/save-project.wiki Normal file
View File

@@ -0,0 +1,15 @@
[[Property:title|Save a project]]
[[Property:weight|3]]
[[Property:uuid|f2c46797-34c5-5de7-fcad-3447c3db61f5]]
To save the project that is currently open, select '''Save''' from the '''File''' menu or click on [[Image:icon-save-color]] in the [[Main toolbar|main toolbar]] .
Alternatively, you may use the keyboard shortcut - '''Ctrl+S'''
{{note|If no changes have been made to the system, the save command will be disabled. }}
{{seealso|<br/>
[[EiffelBuild: Key shortcuts|Key shortcuts]] }}

35
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/builder-window.wiki Normal file
View File

@@ -0,0 +1,35 @@
[[Property:modification_date|Sat, 06 Apr 2019 15:49:27 GMT]]
[[Property:publication_date|Sat, 06 Apr 2019 15:49:27 GMT]]
[[Property:title|Builder window]]
[[Property:weight|7]]
[[Property:uuid|e82ca336-cab6-bc60-6ddc-b359a7c86811]]
The Builder window provides a view of the [[EiffelBuild Notation|objects]] in your system, in which the [[EiffelBuild Notation|objects]] may be manipulated.
This window may either be shown or hidden (default). To change between these two states, click [[Image:icon-builder-window-color]] on the [[Main toolbar| main toolbar]], or select '''Show/Hide builder window''' from the '''View''' menu.
[[Image:builder-window]]
The content of this window is a representation of the [[EiffelBuild Notation|objects]] you have defined in your project. Each [[EiffelBuild Notation|object]] is represented by the [[EiffelVision Introduction|EiffelVision 2]] control matching its type. For example, an [[EiffelBuild Notation|object]] representing an <eiffel>EV_BUTTON</eiffel> will be displayed in here using an <eiffel>EV_BUTTON</eiffel>. As this view provides direct access to the objects ( [[EiffelBuild Notation|Pick]] any of the controls in this window), it enables you to build your interface within a view which provides rich visual feedback.
Because this window is just a view of the [[EiffelBuild Notation|objects]], it will be always synchronized with the [[Layout constructor| layout constructor]] . This means you can [[Reparent an Object| re-parent objects]] , using the [[EiffelBuild Notation|pick and drop]] transport method, seamlessly between the two views. <br/>
{{note|Holding Ctrl while right clicking on an [[EiffelBuild Notation|object]] in the Builder Window creates a new [[Object editor|object editor]] targeted to the [[EiffelBuild Notation|object]] . Holding Ctrl and Shift while right clicking on an [[EiffelBuild Notation|object]] , highlights it within the [[Layout constructor|layout constructor]] .}}
==Visual Differences==
Although the builder window attempts to show you the interface you are developing, it is not a completely accurate representation (Unlike the [[Display window|display window]] ). The main difference is that all [[EiffelBuild Notation|objects]] representing descendants of EV_CONTAINER are parented in a frame. This was implemented so that you would be able to easily manipulate the containers.
Imagine that this was not the case, and each container [[EiffelBuild Notation|object]] was just represented by an [[EiffelVision Introduction|EiffelVision 2]] object matching its type. Because these containers have no visible screen space when filled with children, manipulation of them would have been difficult, and the functionality of this view would be compromised.
In the screenshot above, you can see that there are two [[EiffelBuild Notation|objects]] representing containers in your project, an <eiffel>EV_VERTICAL_BOX</eiffel>, and an <eiffel>EV_HORIZONTAL_BOX</eiffel> (Excluding the <eiffel>EV_TITLED_WINDOW</eiffel> [[EiffelBuild Notation|object]] represented by this window).
The properties of the [[EiffelBuild Notation|objects]] in your system are always reflected in this window, with a few exceptions:
* `user_can_resize`, `maximum_width`, `maximum_height` and `title_string` are not reflected in this window.
* `minimum_width` and `minimum_height` are not reflected in any of the controls representing [[EiffelBuild Notation|objects]] within this window.
{{seealso|<br/>
[[Display window|Display window]] <br/>
[[Layout constructor| Layout constructor]] }}

40
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/component-selector.wiki Normal file
View File

@@ -0,0 +1,40 @@
[[Property:title|Component selector]]
[[Property:weight|8]]
[[Property:uuid|c70ce7e5-e720-ca96-8f1f-5024e9d6dabe]]
The component selector allows you to build and retrieve user defined [[EiffelBuild Notation|components]] for use in your project.
[[Image:component-selector]]
==Creating a component==
To define a new [[EiffelBuild Notation|component]] , [[EiffelBuild Notation|pick]] the [[EiffelBuild Notation|object]] that you wish to create the component from, and then [[EiffelBuild Notation|drop]] it anywhere in the component selector. The following dialog will appear:
[[Image:component-namer]]
Modify the suggested name as desired, and then click '''OK''' to create the new component. If you click '''Cancel''', the component will not be created.
The component that has been created will contain enough information to allow a copy to be built of the existing object. This includes all the children of the original object (to any depth) and the properties (width, height, color etc)of all objects within the structure. The only properties of the objects that will not be set inside a component are the user defined names, and any events connected to the objects.
==Using a component==
To create a new set of [[EiffelBuild Notation|objects]] from a [[EiffelBuild Notation|component]] , [[EiffelBuild Notation|pick]] the [[EiffelBuild Notation|component]] , and [[EiffelBuild Notation|drop]] onto an [[EiffelBuild Notation|object]] representation. If an object is full, or does not allow other objects of the new type to be contained, then you will not be able to [[EiffelBuild Notation|drop]] on it. <br/>
If the [[EiffelBuild Notation|pick and drop]] completed successfully, then you should have a new set of objects matching the structure of the [[EiffelBuild Notation|component]] .
<span id="delete_component"></span>
==Deleting a component==
To remove a [[EiffelBuild Notation|component]] from your EiffelBuild system, [[EiffelBuild Notation|pick]] it, and then [[EiffelBuild Notation|drop]] it on [[Image:icon-delete-small-color]] in the [[Main toolbar| main toolbar]] .
{{note|The deletion of a [[EiffelBuild Notation|component]] cannot be undone. }}
==Viewing a component==
To view an existing component, use the [[Component viewer|component_viewer]] .
{{seealso|<br/>
[[Component viewer|Component_viewer]] <br/>
[[Builder window|Builder window]] <br/>
[[Layout constructor| Layout Constructor]] }}

30
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/component-viewer.wiki Normal file
View File

@@ -0,0 +1,30 @@
[[Property:title|Component viewer]]
[[Property:weight|10]]
[[Property:uuid|51a8cb3e-7486-7ab4-b608-95acfedd32f7]]
The Component viewer allows you to view the structure of a [[EiffelBuild Notation|component]] without having to create new [[EiffelBuild Notation|objects]] from the [[EiffelBuild Notation|component]] .
This tool is displayed in a separate window, and may either be shown or hidden (default). To change between these two states, click [[Image:icon-component-viewer-color]] on the [[Main toolbar| main toolbar]] , or select '''Show/Hide component viewer''' from the '''View''' menu.
[[Image:component-viewer]]
==Targeting a component==
To target a [[EiffelBuild Notation|component]] into the tool, [[EiffelBuild Notation|pick]] the [[EiffelBuild Notation|component]] from the [[Component viewer|component_viewer]] , and [[EiffelBuild Notation|drop]] on the [[Image:icon-component-viewer-color]] displayed in the tool bar of the component viewer (See screenshots above). Any existing component displayed is simply removed.
Alternatively, you can hold down the Ctrl key while starting a [[EiffelBuild Notation|pick]] on a [[EiffelBuild Notation|component]] in the [[Component selector| component_selector]] . This will automatically target the [[EiffelBuild Notation|component]] to the component viewer. If the viewer is currently hidden, it will also make it visible.
==View types==
Looking at the left-hand screenshot above, you can see that the [[Image:icon-component-display-view-color]] button is depressed, meaning the component viewer is in display view mode. Clicking on [[Image:icon-component-build-view-color]] will put the component viewer into build mode view as shown in the right-hand screenshot. These modes are mutually exclusive and are described below:
* '''Builder view''' - This view is similar to the view used by the [[Display window|display window]] . i.e. the [[EiffelVision Introduction|EiffelVision 2]] controls are displayed exactly as is defined in the [[EiffelBuild Notation|component]] .
* '''Display view''' - This view is similar to the view used by the [[Builder window|builder window]] . i.e. all [[EiffelVision Introduction|EiffelVision 2]] containers are represented by frames so they are immediately visible. This makes the actual structure represented by the [[EiffelBuild Notation|component]] completely visible.
{{note|The type of the "root_object" within the component is displayed in the toolbar of the component viewer. }}
{{seealso|<br/>
[[Builder window|Builder window]] <br/>
[[Layout constructor| Layout constructor]] }}

177
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/constants.wiki Normal file
View File

@@ -0,0 +1,177 @@
[[Property:title|Constants]]
[[Property:weight|12]]
[[Property:uuid|f658bc39-da5f-1f12-ccf6-16b9c08732c2]]
EiffelBuild supports the use of constants, permitting you to define a particular value and use it comprehensively throughout your system. If a constant is in use, any changes are reflected immediately in all clients, providing a quick way of globally changing object properties. The Eiffel code generated by EiffelBuild, generates all constants as actual Eiffel constants for use in your system.
The following constant types are supported by EiffelBuild:
* '''String''' - Representing the Eiffel STRING type.
* '''Integer''' - Representing the Eiffel INTEGER type.
* '''Directory''' - Representing a directory location, of type STRING.
* '''Pixmap''' - Representing an EV_PIXMAP, and either absolute, or built from a directory constant.
* '''Font''' - Representing a font, of type EV_FONT.
* '''Color''' - Representing a color, of type EV_COLOR.
==Constants Dialog==
Modification to all constant types is performed from the constants dialog, accessible from the [[Main toolbar|main toolbar]] via the [[Image:icon-format-onces-color]] button. The constants dialog has the following appearance:
[[Image:constants-dialog]]
The screenshot above, shows the constants dialog displayed for a project containing twelve constants, a few of each available type. Each of the constants in the project are displayed in the multi column list occupying most of the dialog.
The "Type", "Name" and "Value" fields displayed along the bottom of the dialog are used to permit addition and modification of constants. The "OK" button displayed in the top right hand corner of the dialog closes the dialog when modifications to the constants are complete.
===Adding a new constant===
To add a new constant to your project, select the type of the constant that you wish to add from the "Type" combo box. Depending on the type of constant selected, the remaining fields, and associated buttons will be modified appropriately, and the steps required to add the constant differ:
* '''String''' and '''Integer''' - Enter the name in the "Name" field, and value in the "Value" field. The "New" button is only enabled when the name is valid, and a valid entry is set, and clicking it adds the new constant.
* '''Directory''' - Enter a name for the directory in the "Name" field, and then select "New" which displays a choose directory dialog. Selecting a directory from this dialog and pressing "OK" adds the new directory constant to the project.
* '''Pixmap''' - Select the "New" button, which brings up the Pixmap Constant Dialog enabling you to select a constant. The use of this dialog is described further down this page.
* '''Font''' - Enter a name in the "Name" field, and then select "New" which displays a font dialog. Selecting a font from this dialog and pressing "OK" adds the new font constant to the project.
* '''Color''' - Enter a name in the "Name" field, and then select "New" which displays a color dialog. Selecting a color from this dialog and pressing "OK" adds the new color constant to the project.
{{note|After adding a new constant, it is immediately displayed with all constants in the dialog. }}
===Modifying an existing constant===
To modify a constant that already exists, select the constant in the multi column list, and depending on the type of the constant, perform the following:
* '''String''' and '''Integer''' - Modify the value, which in turn, enables the "Modify" button, which must be selected for the value to change. Note that if you change the name, the "New" button is enabled as this will now add a new constant.
* '''Directory''' - Select the "Modify" button which displays a directory dialog, permitting selection of the new value.
* '''Pixmap''' - Select the "Modify" button which displays the Pixmap Constant Dialog, in a mode which permits you to select the new pixmap you wish to use.
* '''Font''' - Select the "Modify" button which displays a font dialog, permitting selection of the new font.
* '''Color''' - Select the "Modify" button which displays a color dialog, permitting selection of the new color.
===Removing constants===
To remove a constant from the project, select it in the multi column list, and select the "Remove" button, or press the delete key. If the constant is not in use within the system, it will be removed, otherwise the following dialog is displayed:
[[Image:constant-in-use]]
As objects are reliant on the constant you are removing, you must confirm that you really wish to remove it from the system. If you select "OK", the constant is removed, and the object property relying on that constant is converted to a manifest value. For example, if you are using an Integer constant with a value of 100, and you remove the constant, the property no longer references the constant, but is set explicitly to 100.
{{note|You may sort the constants displayed in the dialog, by clicking the associated column header. }}
==String constant==
A String constant represents an Eiffel STRING, and may be any valid STRING. For example, in the generated constants file, for a String constant named `modify_button_text`, the following code is generated:
<code>
modify_button_text: STRING
-- `Result' is STRING constant named modify_button_text.
once
Result := "Modify"
end
</code>
==Integer constant==
A Integer constant represents an Eiffel INTEGER, and may be any valid INTEGER value. For example, in the generated constants file, for an Integer constant named `medium_padding`, the following code is generated:
<code>
medium_padding: INTEGER
-- `Result' is INTEGER constant named medium_padding.
once
Result := 8
end</code>
==Directory constant==
A Directory constant is an Eiffel representation of a directory, as a STRING value. For example, in the generated constants file, for a Directory constant named `pixmap_location`, the following code is generated:
<code>
pixmap_location: STRING
-- `Result' is DIRECTORY constant named pixmap_location.
once
Result := "C:\pixmaps"
end</code>
==Pixmap constant==
A pixmap constant is a representation of a pixmap image, and two types are available:
* '''Absolute''' - The generated code contains a constant of type EV_PIXMAP, built from a single, absolute path, based on the location of the original pixmap on disk as follows:
<code>
main_pixmap: EV_PIXMAP
-- `Result' is PIXMAP constant named main_pixmap.
local
a_file_name: FILE_NAME
once
create Result
create a_file_name.make_from_string ("C:\pixmaps\main_pixmap.png")
-- Now set `Result' based on `a_file_name'.
set_with_named_file(Result, a_file_name)
end</code>
* '''Relative''' - The generated code contains a constant of type EV_PIXMAP, built from a file name and a directory constant. This type of pixmap constant is the most frequently used, as it is more flexible. By redefining the value of the directory constant on which it is based, your systems may easily account for the installation location of the pixmap. A relative Pixmap constant is generated as follows:
<code>
main_pixmap: EV_PIXMAP
-- `Result' is PIXMAP constant named main_pixmap.
local
a_file_name: FILE_NAME
once
create Result
create a_file_name.make_from_string (pixmap_location)
a_file_name.set_file_name("main_pixmap.png")
-- Now set `Result' based on `a_file_name'.
set_with_named_file(Result, a_file_name)
end</code>
Where `pixmap_location` is the name of the Directory constant to which the pixmap is relative.
==Font constant==
A Font constant represents an EV_FONT. For example, in the generated constants file, for a font constant named `times_new_roman`, the following code is generated:
<code>
times_new_roman: EV_FONT
-- `Result' is EV_FONT constant named `times_new_roman'.
once
create Result
Result.set_family (feature {EV_FONT_CONSTANTS}.Family_roman)
Result.set_weight (feature {EV_FONT_CONSTANTS}.Weight_regular)
Result.set_shape (feature {EV_FONT_CONSTANTS}.Shape_regular)
Result.set_height_in_points (12)
Result.preferred_families.extend ("Times New Roman")
end</code>
==Color constant==
A Color constant represents an EV_COLOR. For example, in the generated constants file, for a color constant named `red`, the following code is generated:
<code>
red: EV_COLOR
-- `Result' is EV_COLOR constant named `red'.
once
Result := create {EV_COLOR}.make_with_8_bit_rgb (255, 0, 0)
end</code>
===Pixmap constant dialog===
The Pixmap Constant dialog is used to select pixmaps for addition to an EiffelBuild project, and is displayed from the Constants dialog when necessary. The Pixmap Constant dialog has the following appearance:
[[Image:pixmap-selection-dialog]]
An individual pixmap may be selected, or a whole directory of pixmaps may be selected from this dialog for addition. In the screenshot above, a directory containing two pixmaps was selected. The "Build from" option at the bottom of the dialog permits you to select if you wish to add an absolute or relative pixmap, and if multiple pixmaps are being added, the currently selected pixmap from the list above is active. The relative "DIRECTORY" for relative pixmaps is filled in automatically if EiffelBuild finds a directory constant in the system that matches the path chosen. If not, you may enter a name in this field to create a new directory matching the required path. If you do not enter a directory name for one or more relative pixmaps, upon closing the dialog, you will be prompted to enter a name for a directory constant used for these pixmaps.
{{note|If you are selecting new pixmaps, and they appear in the dialog as unchecked, it means that an equivalent pixmap already exists in the project. }}
==Loading constants==
The generation of an EiffelBuild project creates two constants classes, an interface class and an implementation class, named to match the setting from the [[EiffelBuild: Project settings window|project settings]] . For example, if you have specified the name "constants" for the constants, two classes are generated, <eiffel>CONSTANTS</eiffel> and the implementation, <eiffel>CONSTANTS_IMP</eiffel>.
By default, all constant values are hard coded into the implementation class, but it is possible to set these to be loaded from an external file upon execution of the generated system. To do this, the "Load constants from file" setting of the [[EiffelBuild: Project settings window|project settings]] must be checked, which causes a file "constants.txt" to be generated, containing the definitions of all Integer and String constant values. As the system is executed, the values of these constants are loaded from the file, and by providing different versions of the file, at the time of deployment, multiple languages may be accounted for in your generated system.
==Using constants==
Constants may be associated to properties of your [[EiffelBuild Notation|objects]] via an [[Object editor|object editor]] targeted to that [[EiffelBuild Notation|object]] . The [[Image:icon-format-onces-color]] button denotes the use of a constant value. For more information regarding using constants, in [[Object editor|object editors]] , see [[Object editor|object editor]] .
When an EiffelBuild project is generated, all constants are added to a class, inherited by each window class. There is an "_IMP" and interface versions of these classes as with each window. For more information regarding the generation of constants, see [[EiffelBuild: Code Generation|code generation]] .
{{note|To modify pixmap constants based on the current installation of an EiffelBuild generated interface, simply redefine the Directory constant used to access the pixmaps within the interface constants class (not "_IMP"), which is not re-generated if it already exists. }}
{{seealso|<br/>
[[EiffelBuild: Code Generation|Code generation]] <br/>
[[Object editor|Object editor]] <br/>
[[EiffelBuild: Project settings window|Project settings]] }}

20
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/display-window.wiki Normal file
View File

@@ -0,0 +1,20 @@
[[Property:title|Display window]]
[[Property:weight|6]]
[[Property:uuid|baed48d9-3a5a-c1a3-be32-dae7cab6071b]]
The Display window provides a view of the [[EiffelBuild Notation|objects]] in your system, but unlike the [[Layout constructor|layout constructor]] and [[Builder window|builder window]] , the objects cannot be manipulated.
This window may either be shown or hidden (default). To change between these two states, click [[Image:icon-display-window-color]] on the [[Main toolbar|main toolbar]] , or select '''Show/Hide display window''' from the '''View''' menu.
[[Image:display-window]]
This view is provided so that you can really see what your project will look like when it has been generated and is running as a stand alone [[EiffelVision Introduction|EiffelVision 2]] system.
All properties that have been set on the [[EiffelBuild Notation|objects]] in your project are set in the [[EiffelVision Introduction|EiffelVision 2]] control matching its type.
{{seealso|<br/>
[[Builder window|Builder window]] <br/>
[[Layout constructor|Layout constructor]] }}

52
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-code-generation.wiki Normal file
View File

@@ -0,0 +1,52 @@
[[Property:title|EiffelBuild: Code Generation]]
[[Property:weight|15]]
[[Property:uuid|536487f0-f681-3812-87cf-3580c51ef8dd]]
To generate Eiffel code representing your system, select '''Generate code''' from the '''Project''' menu or click [[Image:icon-code-generation-color]] on the [[Main toolbar|main toolbar]] .
The length of time taken to generate your code is dependent on the speed of the system you are running, and the size of your interface, but typically takes a couple of seconds. A progress bar is displayed during the generation of your system.
The code will be generated according to the options you selected in the [[EiffelBuild: Project settings window|project settings]] .
==Generated classes==
The generation of an EiffelBuild project causes the following files to be generated:
* A constants class and its respective implementation class. For example, if the constants class is named as "constants" in the [[EiffelBuild: Project settings window|project settings]] , two classes, CONSTANTS and CONSTANTS_IMP are generated.
* A class and implementation class for each window, dialog and "top level" widget in the system (each of which is contained in the [[Widget selector|widget selector]] ), named to correspond with the name attribute of the object. For example, for a window in the project named "main_window", the files MAIN_WINDOW and MAIN_WINDOW_IMP are generated.
* An optional file named "constants.txt" which contains definitions of all INTEGER and STRING constants. This is only generated if "Load constants from file" is selected in the [[EiffelBuild: Project settings window|project settings]] . The generated code loads the constants from this file, and allows simple modification for localization, i.e. for foreign languages provide a different version of this file with all strings converted.
For each "top level" widget class in the system (contained in the [[Widget selector|widget selector]] ), the following class hierarchy is generated:
[[Image:class-project-diagram]]
If the "generate as client" option is selected for a particular object (changeable from the [[Object editor|object editor]] , only for objects contained in the [[Widget selector|widget selector]] ), a client supplier relationship exists between the generated widget class and the EiffelVision widget, as illustrated below:
[[Image:class-project-diagram-client]]
{{note|All other diagrams on this page show only the non client version of the settings, where the generated widget inherits from the EiffelVision class. }}
==Project build type==
If [[Build Tab|build type]] is selected as '''Project''' in the [[EiffelBuild: Project settings window|project settings]] , then all the classes listed above in "Generated classes" are generated, along with the following:
* A project configuration file called "build_project.ecf".
* An application class which launches the root window of the project.
The generated files comprise a complete project with a configuration file enabling you to compile and execute the generated system as is. The following diagram illustrates the hierarchy of the generated project, showing only the root window of the project:
[[Image:complete-project-diagram]]
==Modifying code after generation==
The choice to generate an interface and an implementation class for the windows and constants was to enable modification of the interface using EiffelBuild, once you had hand edited code. The rule is that the implementation classes are re-generated every time, but the interface classes are not. It follows from this that you should not add hand written code to the implementation classes (ending in _IMP), as any changes you make will be lost when re-generation takes place.
Using this mechanism, you can generate your initial system using EiffelBuild, and implement any event features that have been generated (in the interface) by EiffelBuild. If you then decide that you wish to modify the look and the feel of the interface, you can return to EiffelBuild, make the necessary adjustments and then re-generate the system.
{{note|When returning to EiffelBuild to modify the interface, if you delete or rename controls, then it is quite possible that you will break your existing code. Care should be taken with all changes of this type. }}
Looking at a generated system, you will see that the [[Object editor|events]] connected to your controls are defined as deferred in the implementation and actually implemented in the interface class. This means that if you return to EiffelBuild with a previously generated system, and add a new event to a control, then you will have to implement the definition in the interface class yourself (as the class interface class is not re-generated).
{{seealso|<br/>
[[EiffelBuild: Project settings window|Project settings]] }}

43
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-general-interface-description/docking.wiki Normal file
View File

@@ -0,0 +1,43 @@
[[Property:title|Docking]]
[[Property:weight|3]]
[[Property:uuid|1434e995-4445-cbce-187c-cd7e078197e9]]
The docking mechanism permits customization of the EiffelBuild interface through the re-ordering of tools to suit your preferences. You may simply "drag" one of the supported tools to a new location as desired. The [[Type selector|Type Selector]] , [[Component selector|Component Selector]] and [[Widget selector|Widget Selector]] all support docking.
==Performing a dock==
To dock one of the three supported tools, press and hold the left mouse button on the title of the tool, and move the mouse so that it points to the new location for the tool. Upon releasing the mouse button, the dock completes, and based on the mouse location, the following may occur:
* '''Re-positioning in the main window''' - If the mouse is held over the three part vertical split area displayed to the left hand side of the EiffelBuild window, the position of the tool within this structure may be modified, providing simple re-ordering. A small grayed area indicates the insertion position of the tool, only displayed if the tools position will be changed upon release. The gray area indicating the new insertion point has the following appearance:
[[Image:docking-insert]]
In this case, the tool being docked will be moved to immediately above the component selector. If no feedback is provided regarding the insertion, upon releasing the mouse button to complete the dock, the tool is moved to an external window.
* '''Docking externally''' - Completing a dock while not above the left hand area of the main window, or if no insert feedback is provided, causes the tool to be moved from its current location to an external window. A tool that is docked externally has the following appearance:
[[Image:docked-external]]
The tool may now be freely moved to any location on screen, in the same fashion as you would move any standard window. The window in which the tool is contained is always displayed "on top" of the main window. There are two methods of restoring the dialog back to its original location in the main window:
** '''Docking back''' - Start a drag from the title of the tool, and point the mouse to the position in which you wish to insert the tool within the main window. If the position is valid, feedback (the gray bar) is displayed, and completing the dock closes the dialog, and re-inserts the tool. If no feedback is provided, the pointed position is not valid, and completing the dock simply moves the window to that position on screen.
** '''Closing the window''' - Clicking the cross displayed to the right hand side of the windows title bar causes the window to be destroyed, and the tool contained to be restored back to its original position within the main window.
{{note|The position of tools that have been docked, is maintained automatically between EiffelBuild sessions. When a new project is opened, they are restored to the positions that they had during the last use. }}
==Main window with externally docked tools==
The following screenshot illustrates the appearance of the main window with all dockable tools external:
[[Image:main-window-with-docked-tools]]
{{seealso|<br/>
[[EiffelBuild: General interface description|General interface description]] }}

46
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-general-interface-description/eiffelbuild-key-shortcuts.wiki Normal file
View File

@@ -0,0 +1,46 @@
[[Property:title|EiffelBuild: Key shortcuts]]
[[Property:weight|2]]
[[Property:uuid|ac57a648-456c-e423-e141-2f1f0eff95cb]]
Many operations in EiffelBuild do not require the use of the mouse. The same effect can be achieved through the keyboard only.
This page gathers all the keyboard shortcuts available in the environment.
==Key shortcut reference==
{|
|-
| '''Key shortcut'''
| '''action'''
|-
| ''- file shortcuts -''
|-
| Ctrl+O
| Open project.
|-
| Ctrl+N
| New Project.
|-
| Ctrl+S
| Save project
|-
| ''- code generation shortcuts -''
|-
| Ctrl+G
| Generate code from project.
|-
| ''- miscellaneous shortcuts -''
|-
| Delete
| Delete object from currently selected tool.
|-
| Ctrl+T
| Tool always on top.
|}
'''Note''': These shortcuts are not always available and are dependent on the state of EiffelBuild. For example, Ctrl+S does nothing if there is no modified project open.
{{seealso|<br/>
[[EiffelBuild: General interface description|General interface description]] }}

30
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-general-interface-description/eiffelbuild-window-overview.wiki Normal file
View File

@@ -0,0 +1,30 @@
[[Property:title|EiffelBuild window overview]]
[[Property:weight|0]]
[[Property:uuid|7a64cd29-c65d-88e9-4eb2-4123825e4a86]]
==Window layout==
The use of EiffelBuild is based around one main window which remains throughout the execution. The appearance of the main window is as follows:
[[Image:main-window]]
The window contains several different tools, highlighted below:
* The [[Type selector|type selector]] - Situated at the top left of the window, this tool contains all the available EiffelVision 2 types available for interface construction.
* The [[Component selector| component selector]] - Situated in the middle left of the window, below the [[Type selector|type selector]] , this tool contains all the user defined components.
* The [[Widget selector|widget selector]] - Situated in the bottom left of the window contains all of the EiffelVision 2 windows contained in the open project. Each of these windows are generated by EiffelBuild as separate classes.
* The [[Layout constructor| layout constructor]] tool - Situated in the middle of the window, this tool displays a graphical representation of the interface that is currently being built.
* The docked [[Object editor|object editor]] - Situated to the right hand side of the window, this object editor automatically targets itself to the selected [[EiffelBuild Notation|object]] in the [[Layout constructor| layout constructor]] .
The [[Type selector|type selector]] , [[Component selector|component selector]] and [[Widget selector|widget selector]] may all be docked from their original position, permitting re-ordering and customization of the main window. Each of these may be docked external to the main window, permitting each to be displayed in their own movable window. For more information regarding the docking mechanism, see [[Docking|docking]] .
{{seealso|<br/>
[[Main toolbar| Main toolbar]] <br/>
[[Layout constructor| Layout constructor]] <br/>
[[Type selector|Type selector]] <br/>
[[Object editor|Object editor]] <br/>
[[Component selector| Component_selector]] <br/>
[[Docking| Docking]] <br/>
}}

5
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-general-interface-description/index.wiki Normal file
View File

@@ -0,0 +1,5 @@
[[Property:title|EiffelBuild: General interface description]]
[[Property:weight|2]]
[[Property:uuid|e16b365e-469e-e2ab-e955-7f4e81630fe3]]

68
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-general-interface-description/main-toolbar.wiki Normal file
View File

@@ -0,0 +1,68 @@
[[Property:title|Main toolbar]]
[[Property:weight|1]]
[[Property:uuid|66eef528-98c1-f238-9e67-694245941aca]]
At the top of the EiffelBuild development window, one toolbar is displayed by default, as shown below:
[[Image:toolbar]]
The complete list of the icons in the toolbar is displayed below. <br/>
{|
|-
| Icon
| Command
|-
| [[Image:icon-delete-small-color]]
| Delete [[EiffelBuild Notation|object]] / [[EiffelBuild Notation|component]] .
|-
| [[Image:icon-save-color]]
| [[Save a project|Save]] current project.
|-
| [[Image:icon-object-editor-color]]
| New [[Object editor|object editor]]
|-
| [[Image:icon-undo-color]]
| [[History|Undo]] last action.
|-
| [[Image:icon-cmd-history-color]]
| Display full [[History|history]] .
|-
| [[Image:icon-redo-color]]
| [[History|Redo]] last undone action.
|-
| [[Image:icon-code-generation-color]]
| [[EiffelBuild: Code Generation|Generate]] code.
|-
| [[Image:icon-system-color]]
| Display [[EiffelBuild: Project settings window|project settings]] .
|-
| [[Image:icon-builder-window-color]]
| Show/hide [[Builder window|builder window]] .
|-
| [[Image:icon-display-window-color]]
| Show/hide [[Display window|display window]] .
|-
| [[Image:icon-component-viewer-color]]
| Show/hide [[Component viewer|component viewer]] .
|-
| [[Image:icon-format-onces-color]]
| Display [[Constants|Constants]] dialog.
|-
| [[Image:icon-cut-color]]
| Cut selected object to clipboard.
|-
| [[Image:icon-copy-color]]
| Copy selected object to clipboard.
|-
| [[Image:icon-past-color]]
| Paste contents of clipboard.
|-
| [[Image:icon-clipboard-color]]
| View clipboard contents.
|}
The screenshot at the top of this page shows all of the buttons enabled. As the state of the currently open project changes, the state of each of these buttons is updated to reflect this. For example, immediately after saving the project, the save button is disabled until the project is modified again.
{{note|It is not possible to customize the toolbar. }}

43
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-notation.wiki Normal file
View File

@@ -0,0 +1,43 @@
[[Property:title|EiffelBuild Notation]]
[[Property:weight|1]]
[[Property:uuid|82803f2a-4089-a426-29b8-1799b2a9c1a5]]
This page contains descriptions of terms found within the EiffelBuild documentation.
==Object==
An EiffelBuild object is a representation of a Vision2 component and its properties. When developing with EiffelBuild, you manipulate objects to build the desired interface.
Each object type has a different set of properties that may be manipulated, and these correspond directly to the properties available within the [[EiffelVision Introduction|EiffelVision 2]] type. There is property which is specific to an EiffelBuild object, '''Name''' which is used for your identification purposes and as the attribute name in the generated code.
For more information on manipulating objects within EiffelBuild, see:
* How to [[Create an object|create an object]]
* How to [[Reparent an Object| reparent an object]] .
* [[Object editor|Object editor]] for details on modifying object properties.
Within EiffelBuild, there may be multiple views of a single object displayed simultaneously. Any modifications to an object will immediately update all views. Both the [[Layout constructor| layout constructor]] and the [[Builder window|builder window]] provide views of the objects within your project, and in these, the objects may be manipulated. The [[Display window|display window]] also provides a view of the objects in your system, except the objects cannot be manipulated from this view. It can be thought of as a preview of the project you are developing.
<span id="component"></span>
==Component==
EiffelBuild components are templates representing user defined object structures. From a component, you can quickly build a matching structure of objects. Components are available in EiffelBuild so that you do not repeatedly create the same structures over and over again while developing your projects.
You specify a new component by creating it from an existing object structure. See [[Component selector| component_selector]] for more detailed instructions on the use of components.
To view an existing component, use the [[Component viewer|component_viewer]] .
It is not possible to modify a component once created, except to [[Component selector| delete]] it.
<span id="pick_and_drop"></span>
==Pick and Drop==
The pick and drop mechanism is one of Eiffel Software 's exclusive technologies and is provided by [[EiffelVision Introduction|EiffelVision 2]] . In EiffelBuild, it allows you to easily send data from a component of the interface to another.
You can '''Pick''' a reference to a '''development object''', such as an object or component with a single click of the '''right''' mouse button. Then as you start moving the mouse around - not pressing any of its buttons - a pebble tracks the cursor position, and a line continuously connects the pebble to the object's original position.
You may terminate this situation in either of two ways:
* If the pebble you are dragging is the regular cursor, you can right-click again to confirm the pick-and-drop and so effectively send the dragged development object to the targeted component. This is known as '''Dropping'''.
Right-clicking when the pebble is the '''no''' cursor, will only stop the pick-and-drop because the component you are hovering with the mouse does not accept your development object.
* If, for any reason, you change your mind, you can cancel the pick-and-drop by left-clicking anywhere or by pressing the Escape key.

24
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-preferences.wiki Normal file
View File

@@ -0,0 +1,24 @@
[[Property:title|EiffelBuild Preferences]]
[[Property:weight|14]]
[[Property:uuid|6255b3d8-392a-7cae-4c15-90515664a9b6]]
The EiffelBuild preferences are used to handle all user defined preferences. For example, each time a dialog is displayed with a "do not show again" option, your chosen setting is recorded in the preferences. Various properties of the EiffelBuild interface are recorded by the preferences, on a user by user basis, permitting you to adapt the behavior of EiffelBuild to suit your needs.
During use of EiffelBuild, many settings and options that you select, will modify the preferences, ensuring the desired behavior is maintained. To access all of the available EiffelBuild preferences, you may use the Preferences dialog, accessible from the "View", "Preferences", "Preferences..." menu option. The preference dialog has the following appearance:
[[Image:preferences-dialog]]
To the left hand side of the dialog is a tree, containing the preferences structure, while on the right, the actual preferences in the selected tree node are displayed. To modify the value of a particular preference, double click on its "Literal Value" which displays a small dialog permitting modification of the value. Dependent on the type of the property, the dialog displayed may change appropriately.
The button marked "Restore Defaults" in the lower left hand corner of the dialog, may be selected to restore the preferences back to their defaults when EiffelBuild was first launched.
When you have finished modifying the preferences, select the "Close" button to close the dialog.
{{note|The preferences are saved automatically by EiffelBuild, even if the open project is not saved, the preferences are saved whenever a property changes. }}
{{seealso|<br/>
[[EiffelBuild: General interface description|General interface description]] <br/>
[[EiffelBuild Reference|EiffelBuild reference]] }}

42
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-project-settings-window/build-tab.wiki Normal file
View File

@@ -0,0 +1,42 @@
[[Property:title|Build Tab]]
[[Property:weight|0]]
[[Property:uuid|ca866291-46b8-6b7f-2492-37c228d53a8f]]
This tab contains information about the type of project you wish to build, and associated information.
Here is the appearance of the Build tab when 'build type' is selected as 'Project':
[[Image:project-build]]
If 'build'_type' is selected as 'Class', then the tab will have the following appearance:
[[Image:project-build-class]]
The options available in this tab are as follows:
* <span id="build_type"></span> '''Build type'''
Select 'Project' if you wish to generate a complete project including an ace file, and an application class, which will launch the GUI you are developing.
Select `Class` if you wish to generate a single class that represents the GUI you are developing. This option is useful if you wish to incorporate your current project into an existing EiffelVision 2 system.
* '''Always rebuild ace'''
This option causes the ace file to be completely re-generated every time you generate your project. If you do not wish the ace file to be re-generated, then disable this option. This check box is only available if 'build type' is set to 'project'.
* '''Project name'''
This entry will be added to the generated ace file as the SYSTEM attribute. The executable built from compiling this ace file will have this name. This option is only available if you have specified 'build_type' as 'Project'.
* '''Application class name'''
This entry will be the class name for the generated EiffelVision 2 application which will launch your GUI. This option is only available if you have specified 'build_type' as 'Project'.
* '''Constants class name'''
This entry is used as the name of the constants class generated by EiffelBuild to define all [[Constants|constants]] contained in your project. Two classes are actually generated from this name, an implementation and an interface class. For example, if you specify a name "constants", two classes, <eiffel>CONSTANTS_IMP</eiffel> and <eiffel>CONSTANTS</eiffel> (inheriting from <eiffel>CONSTANTS_IMP</eiffel>) are generated, and all other classes generated by EiffelBuild, inherit <eiffel>CONSTANTS</eiffel> for access to these constants.
{{seealso|<br/>
[[EiffelBuild: Code Generation|Code generation]] <br/>
[[EiffelBuild: Project settings window|Project settings window]] <br/>
[[Generation Tab|Generation tab]] <br/>
}}

19
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-project-settings-window/generation-tab.wiki Normal file
View File

@@ -0,0 +1,19 @@
[[Property:title|Generation Tab]]
[[Property:weight|1]]
[[Property:uuid|a332d8b6-3156-086b-0c71-a92b1725322d]]
This tab contains information about the available code generation options.
Here is the appearance of the Generation tab with default settings for a Build project:
[[Image:project-generation]]
The options available in this tab are as follows:
* '''Attribute declarations'''
** '''Local''' - All attributes (corresponding to widgets and items generated by EiffelBuild) are declared as local variables.
** '''Attributes''' -- All attributes are declared as attributes of the class with the following export status:
*** '''Exported''' - All attributes are exported to ANY.
*** '''Export only named''' - Only those attributes that have been named are exported to ANY while unnaned attributes are not exported..
*** '''Export None''' - None of the attributes are exported.
** '''Grouped''' - Should different objects of same type be declared individually, or grouped?<br/>

23
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/eiffelbuild-project-settings-window/index.wiki Normal file
View File

@@ -0,0 +1,23 @@
[[Property:title|EiffelBuild: Project settings window]]
[[Property:weight|13]]
[[Property:uuid|7844e875-28d8-8710-385c-c62d1be6a9e0]]
This is where global settings regarding your project are going to be made. In here you can specify:
* The type of project you wish to generate
* The system name
* Class names
* Code generation options
The project window can be raised by clicking [[Image:icon-display-window-color]] on the [[Main toolbar| main toolbar]] , or by selecting '''Settings...''' from the '''Project''' menu.
The window is organized as two tabs:
# [[Build Tab|Build]]
# [[Generation Tab|Generation]]
All options are enabled and saved into the project settings file, 'build_project.bpr' as soon as the window is closed.
{{seealso|<br/>
[[EiffelBuild: Code Generation|Code generation]] }}

36
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/history.wiki Normal file
View File

@@ -0,0 +1,36 @@
[[Property:title|History]]
[[Property:weight|11]]
[[Property:uuid|5bc08c08-be0d-bebd-dcfe-ec20b40c1e26]]
EiffelBuild has an limitless undo/redo mechanism built in. However, this mechanism only applies to the structure of the [[EiffelBuild Notation|objects]] you are developing in your project.
For example, every time you [[Create an object|create]] , [[Reparent an Object| reparent]] or [[Delete an object|delete]] an [[EiffelBuild Notation|object]] in your project, this is recorded in the history. If you modify properties of an [[EiffelBuild Notation|object]] (Using an [[Object editor|object editor]] ), these modifications are not recorded in the history.
==Undo==
To undo a change, click [[Image:icon-undo-color]] on the [[Main toolbar| main toolbar]] You can repeatedly undo, until you get to the beginning of the history, at which point, this button is disabled.
==Redo==
To redo a change (only applicable after one ore more undo's), click [[Image:icon-redo-color]] on the [[Main toolbar| main toolbar]] . You can repeatedly redo, until the history becomes current again, and at which point, this button is disabled.
==History window==
[[Image:history-window]]
The screenshot above shows the appearance of the history window.
This visibility of the window may be toggled by clicking [[Image:icon-cmd-history-color]] on the [[Main toolbar| main toolbar]] . You may also select '''History''' from the '''View''' menu to show the history window, and click the '''Close''' button to close the window manually.
Looking at the screenshot above, you will see that the last action in the history list is selected. This is always the case while working, until you start undoing your changes. To go back six steps, so that (in this case), there is just the one BUTTON added to the HORIZONTAL_BOX, you could click the undo button on the [[Main toolbar| main toolbar]] six times, or you can simply select the third item in this list. both have the same effect. You can also redo by selecting an item below the currently selection in the history list (Only possible after an undo).
If you execute an action which will be added to the history while the history is not at the final position, all history events after this current position will be removed, and the history will be up to date again.
{{note|If you use the history list to move through many recorded actions at once, there may be a slight delay dependent on the systems complexity and steps moved. }}
{{seealso|<br/>
[[Builder window|Builder window]] <br/>
[[Layout constructor| Layout constructor]] }}

5
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/index.wiki Normal file
View File

@@ -0,0 +1,5 @@
[[Property:title|EiffelBuild Reference]]
[[Property:weight|1]]
[[Property:uuid|15b53149-5a31-9a1a-e9ad-739174678064]]
EiffelBuild is the high-level interface builder by Eiffel Software which allows you to develop graphical user interface (GUI) applications simply and quickly.

57
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/layout-constructor.wiki Normal file
View File

@@ -0,0 +1,57 @@
[[Property:title|Layout constructor]]
[[Property:weight|3]]
[[Property:uuid|eb93c9bf-53b3-6718-5c30-d17133633c6f]]
The layout constructor provides a view of the [[EiffelBuild Notation|objects]] you have defined in your system, in which the [[EiffelBuild Notation|objects]] may be manipulated. The root node of the tree is the object currently selected within the [[Widget selector|widget selector]] and objects may be added/moved within the displayed widget structure by picking and dropping the objects as required. For example, in the screenshot below, you could add another list to the vertical box, by picking a list from the [[Type selector|type selector]] and dropping it on the vertical box object.
[[Image:layout-constructor]]
Each item in the tree represents one object. The screenshot above represents the following [[EiffelVision Introduction|EiffelVision 2]] interface definition - An EV_TITLED_WINDOW containing one child, of type EV_VERTICAL_BOX. Within the vertical box there is an EV_HORIZONTAL_BOX and an EV_LIST. The list is empty, but the horizontal box contains three different objects of type EV_BUTTON.
{{note|The widget displayed as the root of the Layout Constructor is the currently selected object in the [[Widget selector|Widget Selector]] . To edit the contents of a different widget, select the widget you wish to manipulate from the [[Widget selector|widget selector]] .}}
The information displayed, only shows you the structure of the [[EiffelBuild Notation|objects]] , and although it gives you an indication of the final appearance of the interface you are building, you cannot see the details of the interface. i.e. color, sizes, tool tips etc. To view an accurate representation of the widget structure you are building, show the [[Display window|Layout window]] .
All [[EiffelBuild Notation|objects]] displayed in the Layout Constructure are [[EiffelBuild Notation|pickable]] , so can be easily manipulated, e.g. [[Delete an object|deleted]] or [[Reparent an Object|reparented]] .
{{note|If the [[EiffelBuild Notation|object]] in the tree has the '''Name''' property set, then the text corresponds to the name, otherwise, the text is the type of the [[EiffelBuild Notation|object]] . }}
If you have just started a new project, then the layout constructor will only contain one tree item, TITLED_WINDOW.
==Selection==
The currently selected object within the Layout Constructor is automatically targetted to the docked [[Object editor|object editor]] which is situated to the right hand side of the main EiffelBuild Window. This enables you to quickly and easily edit the properties of the selected object. Note that Ctrl-right clicking on an object in the Layout Constructor displays a floating [[Object editor|object editor]] targeted to that object.
==Expanding/Collapsing==
To Expand all of the items displayed in the layout constructor, select '''Expand layout tree''' from the '''View''' menu, or select the small cross icon displayed at the top of the tool.
Similarly, if you wish to collapse all of the items in the layout constructor, select '''Collapse layout tree''' from the '''View''' menu.
==Highlighting an Object==
An [[EiffelBuild Notation|object]] contained in a system may be highlighted in the Layout Constructor by [[EiffelBuild Notation|picking]] it, and [[EiffelBuild Notation|dropping]] on the button displayed at the top of the Layout Constructor. Clicking this button with the mouse has no effect. The ability to highlight an object in this fashion proves to be particularly useful when building directly into the [[Builder window|builder window]] , as a particular object may be quickly highlighted in the Layout Constructor, and its properties edited.
==Locked Objects==
Objects that are instances of other objects are displayed as locked objects within the Layout Constructor as illustrated below:
[[Image:layout-constructor-locked]]
The object of type OK_CANCEL_BUTTONS is a locked instance of another object as illustrated by the locked icon displayed on top of it's type icon. As a locked object is simply an instance of another object, its internal structure may not be manipulated directly within the Layout Constructor. To change the structure of a locked object, you must directly change the object of which it is an instance.
To add a locked object to your interface, simply pick the object that you wish to re-use from the [[Widget selector|widget selector]] and drop it into the desired parent object within the Layout Constructor. In this case, the instance of the OK_CANCEL_BUTTONS object is actually comprised of a number of widgets which may only be modified through manipulation of the original OK_CANCEL_BUTTONS_OBJECT. Changes made to this original object are then applied to all instances within your interface structures.
You may convert an existing widget structure into a locked instance of a widget by picking the object to be used as the root of the structure (may not be locked) and dropping it into the [[Widget selector|widget selector]] . This creates a new "top level" object within the [[Widget selector|widget selector]] and places a locked instance of this at the original location in the widget structure where it was picked from.
{{note|Double clicking on a locked object within the Layout Constructor, targets the object of which it is an instance to the Layout Constructor. }}
{{seealso|<br/>
[[Builder window|Builder window]] <br/>
[[Object editor|Object editor]] <br/>
[[Display window|Layout window]] }}

73
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/object-editor/index.wiki Normal file
View File

@@ -0,0 +1,73 @@
[[Property:title|Object editor]]
[[Property:weight|5]]
[[Property:uuid|f00025e2-f39b-d0a2-9b2b-207768771905]]
An object editor is a tool which allows you to edit the properties of a selected [[EiffelBuild Notation|object]] . Common properties include minimum width and height, color, text etc.
An object editor can only reference one [[EiffelBuild Notation|object]] at once, and when not empty, it is considered to be "targeted" to the [[EiffelBuild Notation|object]] whose properties it references.
[[Image:object-editor]]
The screenshot above shows a floating object editor. The docked object editor is almost identical except that it is located within the EiffelBuild main window.
==Docked object editor==
The docked object editor is displayed to the right hand side of the EiffelBuild main window. This editor is always displayed and is permanently linked to the [[Layout constructor| layout constructor]] . This means that whenever the selected [[EiffelBuild Notation|object]] changes in the [[Layout constructor| layout constructor]] , the docked object editor becomes targeted to this [[EiffelBuild Notation|object]] .
==Floating object editors==
These object editors appear in their own window, and you may open as many of these as you wish.
To open a new floating object editor, [[EiffelBuild Notation|drop]] an [[EiffelBuild Notation|object]] on [[Image:icon-object-editor-color]] , displayed in the [[Main toolbar| main toolbar]] and also in each existing object editor. The new object editor will then be targeted to the [[EiffelBuild Notation|object]] that was [[EiffelBuild Notation|dropped]] .
{{note|If the [[EiffelBuild Notation|object]] targeted to floating object editor is deleted, then the editor will be destroyed. This helps stop the screen becoming cluttered with empty editors. }}
As a shortcut to a complete [[EiffelBuild Notation|pick and drop]] transport, you may hold down the Ctrl key while starting the [[EiffelBuild Notation|pick]] , which will immediately open a new floating object editor targeted to the [[EiffelBuild Notation|object]] you clicked.
==General use==
When an object editor is targeted to an [[EiffelBuild Notation|object]] , you will see that controls are available within the editor to customize that [[EiffelBuild Notation|object]] . Although every different type of [[EiffelBuild Notation|object]] will have different sets of properties that may be modified, the manipulation of these properties is as standardized as possible. Below are some general rules that apply:
* String properties inputted via a text field are updated within the object every time a key is pressed
* Integer properties inputted via a text field are only updated within the object when return is pressed, or the input box looses the focus.
* Almost without exception, a push button which controls a property, will open up a dialog, allowing the property to be edited. Examples are colors, pixmaps and events.
* If when you attempt to modify a property, it returns back to its original value, it means that the value you attempted to enter was invalid. For example, looking at the screen show above, if you enter -50 into the minimum_height text field and press return, it will revert back to 23. This is because the minimum_height of an <eiffel>EV_BUTTON</eiffel> may not be set to less than 0. To find allowable values for properties of an [[EiffelBuild Notation|object]] , consult the [[EiffelVision Introduction|EiffelVision 2]] documentation.
All properties that may be manipulated in an object editor correspond directly to a property of the [[EiffelVision Introduction|EiffelVision 2]] control that is represented by the [[EiffelBuild Notation|object]] (Displayed in an object editor as '''type'''). There is one exception to that rule though, and that is the '''Name''' field which is specific to EiffelBuild. This field is used for your identification of the [[EiffelBuild Notation|object]] and as the attribute name in the generated code. For example, when EiffelBuild generates code corresponding to the [[EiffelBuild Notation|object]] targeted in the editor shown above, it would declare the EiffelVision 2 component as - button1: EV_BUTTON
{{note|You may have as many object editors targeted to the same [[EiffelBuild Notation|object]] as you wish. Whenever a change is made to the [[EiffelBuild Notation|object]] through one of the editors, all other editors targeted to that [[EiffelBuild Notation|object]] are synchronized. }}
==Using Constants==
All fields that may use constants have a button marked with the constants symbol [[Image:icon-format-onces-color]] , which when selected, modifies the field to allow selection of the desired constant. A combo box is displayed with all valid constants (matching the type of the property) displayed, from which you may select the constant you wish to use. To remove the use of the constant, simply press the constants button again, which removes the constant, and sets the property to a manifest value representing the previous value of the last selected constant.
==Advanced property manipulation==
Although many of the properties of [[EiffelBuild Notation|objects]] are relatively simple, and can be manipulated with <eiffel>STRING</eiffel> or <eiffel>INTEGER</eiffel> values, there are others that require more complicated control mechanisms. The following [[EiffelBuild Notation|object]] properties have more complicated interfaces warranting further explanation:
* [[Merging radio button groups]]
* [[Positioning table children]]
* [[Positioning fixed children]]
For all "top level" objects (those contained within the [[Widget selector|widget selector]] which are to be generated as individual classes), a check button marked "Generate as client" is available towards the top of the Object Editor. If this is checked, the generated class uses the widget type of the object as a client, otherwise it inherits directly from the widget's class.
<span id="events"></span>
==Event connection==
As well as being able to manipulate the standard properties of an [[EiffelBuild Notation|object]] , facilities are provided for connecting to the events of an [[EiffelBuild Notation|object]] . Looking at the object editor screenshot above, you will see that there is a button marked '''Select events''' which is also available in all targeted editors.
{{note|The button will be marked '''Modify events''' when one or more events are already selected for the current [[EiffelBuild Notation|object]] . }}
Clicking this button will cause the following dialog to be displayed:
[[Image:event-selection-dialog]]
Looking at the screenshot above, you will see that this dialog contains all the action_sequences available for the <eiffel>EV_BUTTON</eiffel> to which the object editor is targeted.
If you check a button connected with one of the action sequences, you will be then able to enter the name of a feature that you wish to connect to the action sequence. The screenshot above shows the user has connected a feature named `button_pressed` to the `select_actions`. When [[EiffelBuild: Code Generation|code is generated]] , this will cause EiffelBuild to generate an empty feature named `button_pressed` already connected to the `select_actions` of the button.
{{note|You will only be allowed to enter valid and unique Eiffel feature names. If a name is invalid, it will be highlighted in red, and a dialog will warn you when you attempt to close the dialog. }}
{{seealso|<br/>
[[Create an object|Create an object]] <br/>
[[Delete an object|Delete an object]] }}

26
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/object-editor/merging-radio-button-groups.wiki Normal file
View File

@@ -0,0 +1,26 @@
[[Property:title|Merging radio button groups]]
[[Property:weight|0]]
[[Property:uuid|069fa6c5-ed77-9cd3-f565-d41d43c406fe]]
If the current [[Object editor|object editor]] contains an <eiffel>EV_CONTAINER</eiffel> [[EiffelBuild Notation|object]] , then the following control will be available:
[[Image:empty-radio-merge]]
With this control, you can merge two or more instances of <eiffel>EV_CONTAINER</eiffel> together, so that any <eiffel>EV_RADIO_BUTTON</eiffel> contained are grouped.
==Merging==
To create a new merge, [[EiffelBuild Notation|pick]] an [[EiffelBuild Notation|object]] of type <eiffel>EV_CONTAINER</eiffel>, and [[EiffelBuild Notation|drop]] it anywhere on the control. This will merge the radio button group of the <eiffel>EV_CONTAINER</eiffel> referenced in the object editor, to the transported one. Each merge, will show up as a new item in the control.
{{note|Container objects may only be grouped once, and as such, you will not be permitted to add an [[EiffelBuild Notation|object]] that is already contained in the list. }}
==Unmerging==
To unmerge a container [[EiffelBuild Notation|object]] from a group, [[EiffelBuild Notation|pick]] the representation of that [[EiffelBuild Notation|object]] from the list, and [[EiffelBuild Notation|drop]] on [[Image:icon-delete-small-color]] . This will unmerge the [[EiffelBuild Notation|object]] from the current group of containers.
==Locating group member==
To locate the [[EiffelBuild Notation|object]] referenced by a list item in the control, left click the item that you wish to locate. This will display the representation of the associated [[EiffelBuild Notation|object]] within the [[Layout constructor|layout constructor]] , and the associated icon will be animated for a short period of time.

23
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/object-editor/positioning-fixed-children.wiki Normal file
View File

@@ -0,0 +1,23 @@
[[Property:title|Positioning fixed children]]
[[Property:weight|2]]
[[Property:uuid|2c465f1b-99d6-7689-67ff-e9b45145a0c0]]
If the current [[EiffelBuild Notation|object]] in the object editor is of type <eiffel>EV_FIXED</eiffel>, a button marked "position children..." will be contained in the object editor. Click this button, to display the following window:
[[Image:fixed-child-positioner]]
* '''Moving''' - Press and hold the left mouse button within the selected child, and move the mouse.
* '''Resizing''' - Move the mouse over the border of the child, until the cursor changes to a resize cursor, then press and hold the left mouse button to re-size the child.
{{note|As placing a child in an <eiffel>EV_FIXED</eiffel> does not modify the size of the child, it is possible that some children have a size of 0x0 pixels, and hence do not show up in the diagram. In this case, there will be the following displayed in the status bar "Widget is 0x0 pixels, click HERE to enlarge". If you subsequently click on the status bar, then the widget will be enlarged to a more useful size. }}
==Grid Properties==
The grid properties are displayed in the bottom right hand side of the window. You may modify the following attributes:
* '''Snap to grid''' - Select this option if you wish all widget coordinates to be snapped to the grid displayed in the window.
* '''Visible''' - If selected, then the grid is visible.
* '''Grid size''' - The spacing between grid elements in pixels.
When you have finished manipulating the children of the table, click the button marked "Done" to close the dialog.

18
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/object-editor/positioning-table-children.wiki Normal file
View File

@@ -0,0 +1,18 @@
[[Property:title|Positioning table children]]
[[Property:weight|1]]
[[Property:uuid|7e302887-c3fd-1f30-866e-545aba53454e]]
If the current [[EiffelBuild Notation|object]] in the object editor is of type <eiffel>EV_TABLE</eiffel>, a button marked "position children..." is contained in the object editor. Click this button, to display the following window:
[[Image:table-child-positioner]]
Each of the children are displayed on a grid representing the table cells that each occupies (by default 1x1). To manipulate a child of the table, click the left mouse button inside the desired child, and it will be highlighted in red. You may the manipulate the selected child in the following ways:
* '''Moving''' - Press and hold the left mouse button within the selected child, and move the mouse.
* '''Resizing''' - Move the mouse over the border of the child, until the cursor changes to a resize cursor, then press and hold the left mouse button to re-size the child.
{{note|Each child, may only occupy a unique set of cells within the table, and if you attempt to move or re-size a child to an invalid position, it will be displayed in gray. }}
When you have finished manipulating the children of the table, click the button marked "Done" to close the dialog.

41
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/type-selector.wiki Normal file
View File

@@ -0,0 +1,41 @@
[[Property:title|Type selector]]
[[Property:weight|4]]
[[Property:uuid|893343c2-417f-90c5-147e-941bc232fe43]]
The type selector contains all the available EiffelVision 2 types supported by EiffelBuild. These are the basic building blocks for your system.
[[Image:type-selector]]
The types are organized into three groups - Primitives, Containers and Items. All types that may be used in EiffelBuild have a text in uppercase, corresponding to their type in [[EiffelVision Introduction|EiffelVision 2]] . For example, looking at the screenshot above, the <eiffel>BUTTON</eiffel> item represents an <eiffel>EV_BUTTON</eiffel>, and the <eiffel>COMBO_BOX</eiffel> item represents <eiffel>EV_COMBO_BOX</eiffel>.
{{note|The types available in the type selector are fixed, and cannot be modified. Almost all [[EiffelVision Introduction|EiffelVision 2]] components are available. }}
==Creating a new object==
[[EiffelBuild Notation|Objects]] are the building blocks used in EiffelBuild to construct your interface. To create a new [[EiffelBuild Notation|object]] for use in your system, [[EiffelBuild Notation|pick]] the type corresponding to the type of object you wish to create,and [[EiffelBuild Notation|drop]] onto an [[EiffelBuild Notation|object]] representation. If an object is full, or does not allow other objects of the new type to be contained, then you will not be able to [[EiffelBuild Notation|drop]] on it. <br/>
For example, if you have just started a new project, [[EiffelBuild Notation|pick]] HORIZONTAL_BOX from the type selector, and drop it on the <eiffel>EV_TITLED_WINDOW</eiffel> [[EiffelBuild Notation|object]] displayed in the [[Layout constructor| layout constructor]] . This will build you a new [[EiffelBuild Notation|object]] of type <eiffel>EV_HORIZONTAL_BOX</eiffel>, parented in the window. If you then [[EiffelBuild Notation|pick]] a BUTTON from the type selector, you will not be able to [[EiffelBuild Notation|drop]] it on the <eiffel>EV_TITLED_WINDOW</eiffel>, as a window may only contain one child and is therefore currently full. You may however, [[EiffelBuild Notation|drop]] on the <eiffel>EV_HORIZONTAL_BOX</eiffel> object you had just created, as the box is empty, and has space for multiple children. Doing so, will create a new [[EiffelBuild Notation|object]] of type <eiffel>EV_BUTTON</eiffel>, parented in the box.
This shows how simple it is to Build new [[EiffelBuild Notation|objects]] in EiffelBuild, you just need access to the parent [[EiffelBuild Notation|object]] to [[EiffelBuild Notation|drop]] the selected type into.
You may drop an object directly from the Type Selector into the [[Widget selector|widget selector]] which creates the object as a "top level object" ensuring that upon generation, it is represented by an individual set of classes. These top level objects may then be re-used within your interface as desired.
{{note|To understand the types accepted, and the capacity of objects, you should consult the [[EiffelVision Introduction|EiffelVision 2]] library reference. }}
==Changing the type of an existing object==
Why would you want to change the type of an existing [[EiffelBuild Notation|object]] , when you could just delete it and create a new [[EiffelBuild Notation|object]] ?
Imagine you have spent some time constructing a complicated interface. You have an EV_VERTICAL_BOX with children many levels deep. You realize that you wanted the <eiffel>EV_VERTICAL_BOX</eiffel> to be of type <eiffel>EV_HORIZONTAL_BOX</eiffel>. If you delete the object, all children contained will also be deleted, which in this case, is not what you want. Changing the type of the object does actually delete the object internally, but will automatically re-parent all of its children into the new object.
To perform a type change, [[EiffelBuild Notation|pick]] the [[EiffelBuild Notation|object]] that you wish to change, and [[EiffelBuild Notation|drop]] it on an item in the type selector representing the desired new type. All existing children of the old [[EiffelBuild Notation|object]] will be automatically re-parented in the new object.
The following rules govern if the type of an existing object may be changed to a new type:
* The parent of the existing [[EiffelBuild Notation|object]] must accept children of type corresponding to the new type.
* The new type must be able to accept all of the existing [[EiffelBuild Notation|objects]] children.
{{seealso|<br/>
[[Layout constructor|Layout constructor]] <br/>
}}

59
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-reference/widget-selector.wiki Normal file
View File

@@ -0,0 +1,59 @@
[[Property:title|Widget selector]]
[[Property:weight|9]]
[[Property:uuid|0626dd3a-28f2-ade6-8e6a-f992c2198fd6]]
The Widget Selector allows you to manage windows, dialogs and "top level" objects within the EiffelBuild project, with all windows accessible through this tool. Using the widget selector, you may add new windows to your project; delete windows; assign a root window (launched from the generated application); and group windows into directories. All objects contained in the Widget Selector are generated as individual classes at generation time. The Widget Selector has the following appearance:
[[Image:window-selector]]
==Adding Objects==
To add an Object to your project, [[EiffelBuild Notation|pick]] the object type from the [[Type selector|type selector]] , and [[EiffelBuild Notation|drop]] into the Widget Selector. There are two possible drop targets within the widget selector:
* '''The Widget Selector itself''' - The newly created object is added to the root directory of the project.
* '''A Directory node''' - The newly created object is added to the directory that was the target of the drop.
Both of these outcomes create a new object in your project that is to be generated as an individual class during code generation.
{{note|The selected object in the Widget Selector is automatically targeted as the root window of the [[Layout constructor|layout constructor]] , permitting building. You may not build directly into the representation of an object within the Widget Selector, as this must be performed within the [[Layout constructor|layout constructor]] or [[Builder window|builder window]] . }}
==Root Window==
The root window of a project is launched by the application class of the generated EiffelBuild project when executed. By assigning a window as a root, you ensure that it will be displayed on screen as the "root" window of the generated system when the system is launched.
The root window of the project is highlighted with a star, indicating that it is the root. Looking at the screenshot at the top of this page, the window named "main_window" is currently flagged as the root window of the project. To set a window as the root window of the project, select the window in the Widget Selector, and press the [[Image:icon-titled-window-main-small-color]] button displayed at the top of the Widget Selector.
==Directories==
The ability to add directories to your project permit organization of objects into sub groups as necessitated by your design. To add a directory to the project, select the [[Image:icon-new-cluster-small-color]] button displayed at the top of the Widget Selector, which displays the following dialog, prompting for the name of the directory to add:
[[Image:new-directory-dialog]]
Enter a unique name that is not already in use, and select "OK" to add the directory to your project. The newly added directory is then visible, as a node in the Widget Selector.
{{note|Creating a new directory in the Widget Selector causes the actual directory on the disk to be created immediately. }}
You may insert objects into a directory, or move an object between directories by [[EiffelBuild Notation|picking]] the object from its representation in the Widget Selector, and [[EiffelBuild Notation|dropping]] on the desired directory. Each object contained in the Widget Selector is generated as a seperate class and the parent directory is used as the generated location on disk.
{{note|If you move an object between directories within an EiffelBuild project that has already generated the Eiffel code for that object, the code files are moved immediately on the disk. }}
Directories may be nested as deeply as required, and the following buttons are available to help with directory nesting:
* [[Image:directory-search-small]] Selecting this button recursively adds all directories from the current project location to the project.
* [[Image:icon-show-hide-directory-color]] Selecting this button causes all directories included within the project that do not contain one or more objects to be hidden/shown within the Widget Selector.
Note that any directories that do not contain objects or have object nested within their structure recursively are displayed grayed out to indicate that there are no objects within.
==Expanding==
The [[Image:icon-expand-all-small-color]] button displayed at the top of the Widget Selector expands all nodes contained.
==Client Representations==
All objects within the Widget Selector that are used as clients within other object structures have client information displayed as subnodes of their representation, as illustrated in the following screenshot:
[[Image:widget-selector-clients]]
The OK_CANCEL_BUTTONS object is used is used in two different places within the project: once within INPUT_DIALOG and once within MAIN_WINDOW. If you select the tree node representing the instance of OK_CANCEL_BUTTONS within MAIN_WINDOW, the MAIN_WINDOW is targetted to the [[Type selector|type selector]] with the instance of the OK_CANCEL_BUTTONS object selected.
To use an instance of a widget contained within the Widget Selector as a client, simply pick the representation of the object and drop into the desired parent object within the [[Type selector|type selector]]
{{seealso| [[Layout constructor|Layout constructor]] }}

71
documentation/19.05/solutions/gui-building/eiffelbuild/eiffelbuild-version-history.wiki Normal file
View File

@@ -0,0 +1,71 @@
[[Property:title|EiffelBuild Version History]]
[[Property:weight|2]]
[[Property:uuid|8cc0540e-8ee7-c005-0534-a2ed62f41c96]]
== 7.3 Release ==
* Fixed a crash which could occur when generating a project.
* Fixed a crash when saving a project if it contained a pixmap with no path specified.
==6.8 Release==
* Fixed bug#13069 and bug#17427 for the incorrect generated code of the '''change_actions''' on an EV_SPIN_BUTTON.
* Fixed the icon view mode display for widgets where content was shown incorrectly in previous releases.
* Fixed code generation of widgets when generated as clients.
==6.7 Release==
Updated the generated code to the latest Eiffel syntax as specified by ECMA.
==6.5 Release==
* Fixed bug#15947 to make the generated code compile in void-safe mode.
* Fixed bug#13296 when retrieving a project using an EV_SPIN_BUTTON element.
* Fixed bug#12880 by improving speed of key navigation which was slowed down by attempting to refresh the object editor each time a new widget was highlighted. Now it is only done when the highlight doesn't change for a while.
==6.0 Release==
* Code generation includes the facility of closing the application when last window is closed.
* The EiffelBuild binary has been renamed into '''esbuilder'''.
* Fixed crash when generating code which included a combo box in read-only mode.
* Fixed bug#12920 where pressing a digit while dropping was not adding x-time the selected widgets (where x is the digit pressed).
* Fixed bug#12210 where pixmaps set on a menu would be incorrectly displayed in the generated executable (The last added one will always be shown for all menu entries with a pixmap).
* Fixed bug#11878 where EiffelBuild would crash when saving a project just after removing an event.
* Fixed bug#11738 where EiffelBuild would crash when picking and dropping a top level widget into the Generate button.
==5.7 Release==
* Fixed positioning bug when moving items within their current parent by dropping on another item in that parent with the shift key held down.
* Fixed bug where modifying the "User can resize" property of a window while the tools were always shown on top stopped the tools from being shown on top.
* Added support for multi-line tooltips.
* Added support for `is_item_expanded` from EV_SPLIT_AREA.
* Added the ability to specify a directory for generation, into which location all files are to be generated.
* Event selection dialogs now contain the name of the object to which they refer in their title for cases where multiple dialogs are open simultaneously
* The project settings dialog is now completely navigatable via the keyboard on Windows platforms.
* Added support for Ctrl+Z and Ctrl+Y to navigate through the history.
* The font selection dialog now shows the currently selected font when displayed.
* Deleting an object that is contained within an object editor now clears the contents of the object editor.
* Preferences window now has the focus when displayed so it is fully navigatable via the keyboard.
* Code generation improved to allow the modifying of constants and subsequent update of the interface, permitting multiple languages to be supported.
==5.6 Release==
* Added support for the generation of any widget as a class. You now may place widgets within the "Widget Selector" to enable this. The "Widget Selector" is simply the old "Widget Selector" renamed.
* Added clipboard functionality, permitting the copying/pasting of objects.
* Added support for new constant types: Font and Color.
==5.5 Release==
* Added support for EV_RICH_TEXT which has been added to EiffelVision2.
* Notebook item texts may now be set to string constants.
* Better support for corrupt installations with warning dialogs now displayed.
* Fixed bug with generated code for notebooks often hiding the first item when they were actually displayed.
==5.4 Release==
* Added support for multiple windows, including dialogs.
* Added support for constants of type Integer, String, Directory and Pixmap.
* New tool, "Widget Selector" added to handle organization of windows, including the ability to define subdirectories in a project, and group windows accordingly.
* Tip of the day dialog added.
* Recent projects are now available from the "File" menu.
* The contents of EiffelBuild projects may now be imported.
* The ability to reset the minimum dimensions of widgets have been added. In the previous version, it was not possible to complete undo the effects of setting a widgets minimum size.
* Preferences added, which allow you to customize the default behavior of EiffelBuild. For example, dialogs may be displayed or hidden as desired.
* The layout of EiffelBuild and its tools is now maintained between sessions.
* Docking added, permitting the re-ordering of particular tools within the interface, including making them "float" externally.
* Smarter code generation options, permitting only named attributes to be exported.

5
documentation/19.05/solutions/gui-building/eiffelbuild/index.wiki Normal file
View File

@@ -0,0 +1,5 @@
[[Property:title|EiffelBuild]]
[[Property:weight|0]]
[[Property:uuid|2af28db0-bc8f-daa6-daf2-18b08a11b606]]
EiffelBuild is the high-level interface builder by Eiffel Software which allows you to develop graphical user interface (GUI) applications simply and quickly.