mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-04-06 10:09:22 +02:00
Author:admin
Date:2008-09-19T07:54:43.000000Z git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@25 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase Sample: Calculator]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|12c3409d-165b-b1df-e26a-b05d49969661]]
|
||||
This sample consists of a command line reverse Polish notation (RPN) calculator.
|
||||
|
||||
{{note| '''Note:''' A RPN calculator works slightly differently from standard calculators. It consists of a stack of numbers. Operations are applied to the two numbers on top of the stack. The result is then put on top of the stack so that it can be used in the next operation. This sample refers to the top of the stack as ''Accumulator''.
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
[[Property:title|EiffelBase Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|5095bbdf-0dd6-7d7b-68d4-59a8293950ee]]
|
||||
* [[EiffelBase Sample: Calculator|Calculator]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Abstract Container Structures: The Taxonomy]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|15ec3e87-45c6-ab53-ddad-d1348a9d8d75]]
|
||||
A container data structure (or container in the sequel) is an object which serves to store and access collections of objects, called the '''items''' of the container. All classes describing containers are descendants of the deferred class [[ref:libraries/base/reference/container_chart|CONTAINER]] .
|
||||
|
||||
A container can be studied from three viewpoints: access, storage and traversal.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase Data Structures, Lists]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|23f540e0-16d5-807c-30af-74d3416a5709]]
|
||||
Many applications need sequential structures, also called linear structures, in particular lists and circular chains. Apart from three classes describing individual list cells, all the classes involved are descendants of class [[ref:/libraries/base/reference/linear_chart|LINEAR]] , one of the deferred classes describing general traversal properties and introduced in the chapter that described the general data structure taxonomy. More precisely, all but one of the classes of interest for the present discussion are descendants, direct or indirect, from a class called [[ref:/libraries/base/reference/chain_chart|CHAIN]] which describes general sequential structures possessing a cursor as well as insertion properties. The exception is class [[ref:/libraries/base/reference/countable_sequence_chart|COUNTABLE_SEQUENCE]] , which describes infinite structures; all the others describe finite structures. <br/>
|
||||
[[ref:/libraries/base/reference/chain_chart|CHAIN]] is an heir of [[ref:/libraries/base/reference/sequence_chart|SEQUENCE]] , which describes a more general notion of sequence. [[ref:/libraries/base/reference/sequence_chart|SEQUENCE]] is a descendant of [[ref:/libraries/base/reference/linear_chart|LINEAR]] . There are two main categories of sequential structures: some, called circular chains, are cyclic; others, called lists, are not. Another distinction exists between dynamic structures, which may be extended at will, and fixed ones, which have a bounded capacity. <br/>
|
||||
In all of the structures under review you may insert two or more occurrences of a given item in such a way that the occurrences are distinguishable. In other words, the structures are bags rather than just sets, although it is possible to use them to implement sets.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Dispensers]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|4f65d62b-940b-c3c2-557e-d709a2a1bcaf]]
|
||||
A dispenser is called that way because of the image of a vending machine (a dispenser) of a rather primitive nature, in which there is only one button. If you press the button and the dispenser is not empty, you get one of its items in the exit tray at the bottom, but you do not choose that item: the machine does. There is also an input slot at the top, into which you may deposit new items; but you have no control over the order in which successive button press operations will retrieve these items.
|
||||
|
||||
The deferred class [[ref:/libraries/base/reference/dispenser_chart|DISPENSER]] provides the facilities which will be shared by all specialized classes. In fact, the interface of all dispenser classes is nearly identical, with the exception of a few extra possibilities offered by priority queues. Many kinds of dispenser are possible, each defined by the relation that the machine defines between the order in which items are inserted and the order in which they arereturned. The Base libraries support three important categories - stacks, queues, and priority queues:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Iteration]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|9c0313bf-571d-0c8d-5c49-8bd99f86bed5]]
|
||||
The classes of the Iteration cluster encapsulate control structures representing common traversal operations.
|
||||
|
||||
=Iterators and Agents=
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Sets]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|44d33f46-cfa9-2aca-6b4f-2d9d91723d85]]
|
||||
Sets are containers where successive occurrences of the same item are not distinguished: inserting the same item twice has the same observable effect as inserting it once.
|
||||
|
||||
==Deferred classes==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Tables]]
|
||||
[[Property:weight|5]]
|
||||
[[Property:uuid|194a63a2-e440-18dc-c9d5-6959dbe169fb]]
|
||||
Hash tables are a convenient mechanism tostore and retrieve objects identified by unique keys.
|
||||
==Why use hash tables?==
|
||||
The main advantage of hash tables is the efficiency of the basic operations: store ( [[ref:libraries/base/reference/hash_table_chart|put]] ) and retrieve ( [[ref:libraries/base/reference/hash_table_chart|item]] , [[ref:libraries/base/reference/hash_table_chart|remove]] ). <br/>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, Trees]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|8357fc1a-a089-c846-aee8-18b8fb26c288]]
|
||||
Trees and their immediate generalization, forests, are useful for any system that manipulates hierarchically organized information. The range of applications is broad, from abstract syntax trees in compilers through document structures in text processing systems to company organization charts in business software. <br/>
|
||||
Trees, in particular binary trees and their variants, also provide convenient implementations of container data structures.
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase Data Structures Overview]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|195085fd-0b2f-8211-3d70-81c32cc13566]]
|
||||
The data structures cluster of EiffelBase includes classes that cover a wide range of data structures classes for you to reuse in your systems. The cluster is divided into a number of subclusters. Each subcluster contains one or more '''deferred''' classes, which provide the general high-level abstractions; other classes in the cluster inherit from the deferred ones.
|
||||
|
||||
The highest-level class is [[ref:libraries/base/reference/container_chart| CONTAINER]] , with the following heirs:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase, The Kernel]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|f6229125-dd7e-a50d-5b97-3ad7cd6071d5]]
|
||||
In addition to basic concepts close to the language level, the Kernel covers such common needs as '''input''' and '''output''', '''storage''' and '''retrieval''' of objects on persistent storage, fine control over '''exception handling''' and '''memory management''', and access to '''operating system facilities'''. The kernel can be divided into 5 logical clusters of classes:
|
||||
* The first cluster contains the universal class defining facilities accessible to all other classes: [[ref:/libraries/base/reference/any_chart|ANY]] . Every developer-defined class is a descendant of this class.
|
||||
* The second cluster includes classes whose facilities are directly related to language concepts:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBase Support Cluster]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|f9c2a003-9836-6688-db1f-5aa31313b317]]
|
||||
The support cluster offers some commonly needed functionality that do not belong to the kernel.
|
||||
|
||||
==Conversions, mathematical properties and ASCII characters==
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|EiffelBase]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|0153c1de-bf88-fa0d-52a5-e50ffcc4e8c8]]
|
||||
EiffelBase, covered by the open-source [[IFELL|IFFEL license]] , is one of the principal contributions of Eiffel: a library of fundamental structures and algorithms covering the basics of computing, and resulting from a "Linnaean" effort at a general-purpose taxonomy of computing structures. EiffelBase is one of the most carefully designed and extensively used libraries in the object-oriented industry.
|
||||
|
||||
The EiffelBase library includes:
|
||||
* A [[EiffelBase, The Kernel|Kernel]] that defines the core classes of all Eiffel systems.
|
||||
* A [[EiffelBase Data Structures Overview|Data Structures]] cluster including classes for all the major data structures (sets, lists, tables etc...)
|
||||
* A [[EiffelBase Support Cluster|Support]] cluster that provide access to the environment, basic math operations and a few other helper classes.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|be2b9c40-f2ff-d6dc-738d-b240deb69407]]
|
||||
* EiffelBase
|
||||
**EiffelBase Tutorial http://ise181.ise/book/documentation/eiffelbase
|
||||
**[[EiffelBase|EiffelBase Tutorial]]
|
||||
**EiffelBase class reference
|
||||
**EiffelBase samples http://ise181.ise/book/documentation/eiffelbase-samples
|
||||
**[[EiffelBase Samples|EiffelBase samples]]
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Compilation of multithreaded systems]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|24e474b5-3cb7-16ff-365f-73be8e73bd56]]
|
||||
==Settings==
|
||||
* Set the option multithreaded in the project settings under Advanced.
|
||||
* Do not use a non-multi-threaded precompiled library. The corresponding multi-threaded libraries of base, WEL and Vision2 should be located in $ISE_EIFFEL/precomp/spec/$PLATFORM/ with the mt prefix.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Multithread FAQ]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|a0e1ddf6-cc19-b6f8-0e05-075908ddd347]]
|
||||
===I've launched several threads and they do not seem to be executed:===
|
||||
|
||||
The thread that launched the several threads may be dead before its children.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Thread library overview]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|2bdeeb91-1917-f443-ebfc-4f877107edd7]]
|
||||
This is only a quick overview of the [[EiffelThread Library|Thread library]] . The reference of this library should give all its content.
|
||||
|
||||
==Creating and launching threads: the class THREAD (deferred)==
|
||||
@@ -40,7 +41,7 @@ To run the thread, use the feature <eiffel>launch</eiffel> from <eiffel>THREAD</
|
||||
<code> my_thread.launch</code>
|
||||
On the Eiffel side, the procedure <eiffel>execute</eiffel> will be launched. This procedures deferred in class <eiffel>THREAD</eiffel>, you have to define it in <eiffel>MY_THREAD</eiffel>.
|
||||
On the C side, a C thread will be created and launched.
|
||||
{{warning| '''Caution''': you may call <eiffel>join_all</eiffel> and the end of the execution of the parent thread if you do not want it to die before its child, otherwise they may prematurely terminate.
|
||||
{{warning| '''Caution''': you may call <eiffel>join_all</eiffel> and the end of the execution of the parent thread if you do not want it to die before its child, otherwise they may prematurely terminate. }}
|
||||
==The class MUTEX==
|
||||
|
||||
The implementation of the class <eiffel>MUTEX</eiffel> is mapped on the C standard thread library. An instance of class <eiffel>MUTEX</eiffel> can be shared between different thread.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelThread]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|d1e4c873-3e04-f49a-f6d2-6b9845f1e109]]
|
||||
The EiffelThread library includes the main components needed to build multithreaded systems. <br/>
|
||||
See:
|
||||
* [[EiffelThread: Introduction|Introduction]]
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
[[Property:title|Multi-threading]]
|
||||
[[Property:link_title|Concurrent computing]]
|
||||
[[Property:weight|-10]]
|
||||
[[Property:uuid|7c7a399a-076f-fd13-9b5f-f110c212e2e8]]
|
||||
== Multi-threading ==
|
||||
* [[Threads|Threads tutorial]]
|
||||
* EiffelThread class reference
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Esql Sample]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|04d03117-fdb2-8b73-677f-9b1a0c333dc4]]
|
||||
This sample consists of a command line SQL parser. SQL statements are filtered through a monitor and sent to the RDBMS.
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|EiffelStore Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|65a0aab3-bc1d-28b8-a6f0-6d71b4c6d54d]]
|
||||
=EiffelStore Samples=
|
||||
|
||||
The following basic examples showcases the different EiffelStore capabilities:
|
||||
* [[Esql Sample|esql]] : A command line SQL parser: very useful to test your Database connection!
|
||||
* [[Selector Sample|select]] : A basic example to perform smart database queries.
|
||||
* [[Inserter Sample|insert]] : A basic example to easily insert data in your database.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Inserter Sample]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|fa0b8601-ca7a-b1cc-384d-f366be33ac40]]
|
||||
This sample lets the user insert a DB_BOOK object in your database using EiffelStore insertion facilities.
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Selector Sample]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|3d608710-5537-04e4-fa89-a608ee6864cd]]
|
||||
This sample creates a <eiffel>DB_BOOK</eiffel> table in your database, enters sample data in it and lets you select rows from this table with author's name.
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelStore DataView Cluster]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|75f8cc72-7ccf-28a4-f6b2-beeb2219dc43]]
|
||||
==1. Introduction==
|
||||
|
||||
DataView cluster helps the programmer creating a GUI for a RDBMS. It gives a basic solution for a RDBMS GUI and also enables the developer to customize his GUI from this basic interface.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Data structures creation]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|d8845cb9-2581-f85d-aad1-460816711356]]
|
||||
==1. Overview==
|
||||
|
||||
EiffelStore enables to create data structures mapped to your own database. This part describes how the EiffelStore wizard generates these structures mapped to your database and how you can map your own classes to your database with EiffelStore.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Data structures use]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|25885469-d6c8-5d1c-bbf8-c5fca5524d36]]
|
||||
==1. Overview==
|
||||
|
||||
EiffelStore affords a context that optimizes and facilitates the use of the classes that maps your database content.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelStore Generation Cluster]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|f443ed73-14bb-9a3a-b7c7-35c2660e7784]]
|
||||
The EiffelStore library lets the user associate database elements with Eiffel objects. These database elements are basically database table rows, database view rows or more generally sets of database attribute values. The easiest way to manipulate database elements is to insert their content into Eiffel objects and to work on these Eiffel objects as database elements.
|
||||
|
||||
A first solution to implement this is to use some adaptable structures that will fit to any database element. This is done in EiffelStore through the [[ref:libraries/store/reference/db_tuple_flatshort|DB_TUPLE]] class, which contains mainly an [[ref:libraries/base/reference/array_chart|ARRAY]] [[[ref:libraries/base/reference/string_8_chart|STRING]] ] containing element attribute names and an [[ref:libraries/base/reference/array_chart|ARRAY]] [[[ref:libraries/base/reference/any_chart|ANY]] ] containing element attribute values. This solution has one major drawback: any static checking is impossible: the developer cannot be sure at compile time of the nature of a [[ref:libraries/store/reference/db_tuple_flatshort|DB_TUPLE]] , i.e. what it represents, and cannot know if attributes number, names and types are correct. To overcome this problem, a second solution is to use data structures that statically fits to the expected database element, as introduced in the [[Data Object Coupling|DataObject Coupling]] section.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelStore Implementation Layer]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|80cd0938-6837-3c17-8515-b4ac60a51d09]]
|
||||
Each interface class has an implementation counterpart that implements specific DBMS handling. The class prefix indicates clearly its layer, for instance:
|
||||
* [[ref:/libraries/store/reference/db_selection_flatshort|DB_SELECTION]] is the interface to perform a database selection query.
|
||||
* [[ref:/libraries/store/reference/database_selection_flatshort|DATABASE_SELECTION]] [[[ref:/libraries/store/reference/database_flatshort|DATABASE]] ] is its implementation.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Data Modification]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|ef5568ff-dc7c-4c85-0174-335fdab1bd84]]
|
||||
Use the [[ref:/libraries/store/reference/db_change_flatshort|DB_CHANGE]] class to perform any operation on your database that does not require access to a result. You can for instance modify table row content, drop table rows, create and delete tables.
|
||||
|
||||
{{note| '''Note''': Take a look at the [[Data Object Coupling|Data Storing]] capability if you want to '''insert''' table rows. }}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Data Object Coupling]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|c51311cd-8782-0bc3-3ef7-000ea6eee37c]]
|
||||
A smart way to work with relational databases is to have Eiffel objects directly mapping relational tables. Three EiffelStore classes enable this coupling:
|
||||
* [[ref:/libraries/store/reference/db_repository_flatshort|DB_REPOSITORY]] objects [[#describe|describe a relational table]] and allow Eiffel to create objects mapping database tables.
|
||||
* [[ref:/libraries/store/reference/db_store_flatshort|DB_STORE]] works directly with [[ref:/libraries/store/reference/db_repository_flatshort|DB_REPOSITORY]] objects to [[#insert|insert data into relational tables]] .
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Database Connection]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|2cf2cb7c-e28d-5d06-b03e-e2b17c1f6879]]
|
||||
# To connect to your database, you have to create a '''handle''': this handle actually links the interface classes with corresponding implementation classes mapped to your DBMS. This handle is implemented by the DATABASE_APPL class:
|
||||
<code>
|
||||
database_appl: DATABASE_APPL [ODBC]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Database control]]
|
||||
[[Property:weight|7]]
|
||||
[[Property:uuid|432c6e51-36d5-b469-c924-eb821713256a]]
|
||||
Use the [[ref:/libraries/store/reference/db_control_flatshort|DB_CONTROL]] class to check or change database status and behavior. The main operations you are likely to use are:
|
||||
* [[#errors|Handling]] database errors.
|
||||
* [[#connection|Connecting]] to the database.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Database Selection]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|de759a74-b3e1-c937-e620-67526c116925]]
|
||||
Use the [[ref:/libraries/store/reference/db_selection_flatshort|DB_SELECTION]] class to select data from the database. Once you have selected the data, you can [[Selection Access|access]] it with convenience using adaptative EiffelStore structures.
|
||||
|
||||
{{note| '''Note''': Take a look at the [[Data Object Coupling|Database/Eiffel objects Coupling]] if you need information about your database structure. }}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelStore Interface Layer]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|abd6c880-e0d8-0961-8cd2-d2ca43c1ce28]]
|
||||
The Interface layer gathers a set of classes covering all the capabilities an application need to interface efficiently with a DBMS.
|
||||
|
||||
The interface affords these main capabilities:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Query variables]]
|
||||
[[Property:weight|5]]
|
||||
[[Property:uuid|37222a07-a8f8-e57d-45f0-3b28cd66d660]]
|
||||
If you have to execute database queries which only differ in the expression values, you can create a template query and then bind variables into this template for each execution.
|
||||
|
||||
This mechanism can be applied for requests with a result ([[ref:/libraries/store/reference/db_selection_chart|DB_SELECTION]] ) or without ([[ref:/libraries/store/reference/db_change_chart|DB_CHANGE]] ). Hence both classes inherits from STRING_HDL that actually handle variable binding.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Selection Access]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|3b4fdde3-d903-55c8-0068-cee2407db280]]
|
||||
Once you have [[Database Selection|selected data]] from the database, it returns a set of rows containing queried columns values. Each row loaded with DB_SELECTION is stored in a DB_RESULT object. The easiest way to access the data is thus to refer to DB_RESULT objects themselves.
|
||||
|
||||
{{note| '''Note''': Take a look at the [[Data Object Coupling|Database/Eiffel objects Coupling]] to learn advanced data handling features. }}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Stored Procedures]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|9979af90-07c3-8b20-448e-04454a75c801]]
|
||||
When sending requests to the database, the request is first parsed then executed. Instead of parsing many times the same requests, i.e. with only changes in expression values, most of RDBMS enable to '''precompile''' requests. These requests can then be executed as routines and are identified by a name and a signature.
|
||||
|
||||
EiffelStore lets you use stored procedures with [[ref:/libraries/store/reference/db_proc_flatshort|DB_PROC]] class to:
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|EiffelStore Content]]
|
||||
[[Property:link_title|EiffelStore Tutorial]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|542caa33-5dc1-d2ea-414b-b1739045edd9]]
|
||||
EiffelStore main classes are grouped into 2 main layers:
|
||||
* The [[EiffelStore Interface Layer|interface layer]] provides a high-level, unique interface for every DBMS.
|
||||
* The [[EiffelStore Implementation Layer|implementation layer]] customizes high-level routines to various DBMS handles.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|EiffelStore Library]]
|
||||
[[Property:link_title|EiffelStore]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|f43ab3e6-4551-632a-384b-4964d1436730]]
|
||||
Type: Library <br/>
|
||||
Platform: Any <br/>
|
||||
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
[[Property:weight|-8]]
|
||||
[[Property:uuid|f5d26942-de52-76cc-0f41-66b959a78999]]
|
||||
== Database access ==
|
||||
* EiffelStore http://ise181.ise/book/documentation/eiffelstore-library
|
||||
** EiffelStore introduction http://ise181.ise/book/documentation/eiffelstore-introduction
|
||||
** EiffelStore tutorial http://ise181.ise/book/documentation/eiffelstore-content
|
||||
* [[EiffelStore Library|EiffelStore]]
|
||||
** [[EiffelStore introduction|EiffelStore introduction]]
|
||||
** [[EiffelStore Content|EiffelStore tutorial]]
|
||||
** EiffelStore class reference
|
||||
** EiffelStore samples http://ise181.ise/book/documentation/eiffelstore-samples
|
||||
** [[EiffelStore Samples|EiffelStore samples]]
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Absolute time]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|195849fc-1a9c-d734-2d2b-acae78133886]]
|
||||
The classes dealing with date and those dealing with time have almost the same construction. At the top of the hierarchy are the constants and the notion of value ([[ref:libraries/time/reference/time_value_chart|TIME_VALUE]] , [[ref:libraries/time/reference/date_value_chart|DATE_VALUE]] , [[ref:libraries/time/reference/date_time_value_chart|DATE_TIME_VALUE]] ). From this notion come two kinds of heirs which are the absolute notion of time (classes [[ref:libraries/time/reference/date_chart|DATE]] , [[ref:libraries/time/reference/time_chart|TIME]] and [[ref:libraries/time/reference/date_time_chart|DATE_TIME]] ) and the notion of duration (classes [[ref:libraries/time/reference/date_duration_chart|DATE_DURATION]] , [[ref:libraries/time/reference/time_duration_chart|TIME_DURATION]] , [[ref:libraries/time/reference/date_time_duration_chart|DATE_TIME_DURATION]] ).
|
||||
|
||||
[[ref:libraries/time/reference/date_chart|DATE]] , [[ref:libraries/time/reference/time_chart|TIME]] and [[ref:libraries/time/reference/date_time_chart|DATE_TIME]] inherit from the deferred class <eiffel>ABSOLUTE</eiffel>. It implies that instances of these classes are used as absolutes. We can imagine an oriented axis on which are reported values. <eiffel>ABSOLUTE </eiffel>inherits <eiffel>COMPARABLE</eiffel>, there is a complete order inside the class and its heir. <eiffel>ABSOLUTE</eiffel> is a client of <eiffel>DURATION</eiffel>, so that each instance of <eiffel>ABSOLUTE </eiffel>is linked with the duration between the origin and itself.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|DATE / TIME to STRING Conversion]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|88972ba4-694b-8558-b0c8-87b1fc40afc4]]
|
||||
The following table lists format conversion codes.
|
||||
{|
|
||||
|-
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Duration]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|64672bd0-b696-0c39-1e30-5ac64aae4a99]]
|
||||
<eiffel>TIME_DURATION</eiffel>, <eiffel>DATE_DURATION</eiffel> AND <eiffel>DATE_TIME_DURATION</eiffel>
|
||||
|
||||
The classes dealing with duration inherit DURATION, which inherits GROUP_ELEMENT and PART_COMPARABLE. An instance of <eiffel>TIME_DURATION</eiffel>, <eiffel>DATE_DURATION</eiffel> or <eiffel>DATE_TIME_DURATION</eiffel> is an element of a group, i.e. there is a zero and addition operations (infix +,infix -, prefix + and prefix -). Duration is used as an amount of time, without link to an origin. It may be added to the respective absolute notion (time + time_duration is possible, not time + date_time_duration nor date_time + time_duration...see classes <eiffel>TIME</eiffel>, <eiffel>DATE</eiffel> and <eiffel>DATE_TIME</eiffel>).
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
[[Property:title|EiffelTime]]
|
||||
[[Property:link_title|EiffelTime Tutorial]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|2c1bfedd-d515-cd6b-bd22-b06326fc98d8]]
|
||||
The library EiffelTime is built on three notions of time. The absolute notion (for example, what time is it? 3:45 p.m.) is used for events. It may be useful also to deal with an interval between two events (the meeting is between 3:45 p.m. and 6:00 p.m.). Finally EiffelTime has the notion of duration, which is the length of an interval (the meeting will take 2:15). The notion of absolute is linked with duration by the use of an origin.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Interval]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|d33d0216-fa71-60dc-f3b0-61ff42d621e6]]
|
||||
Class <eiffel>INTERVAL</eiffel> deals with intervals between two instances of the same class which conform to<eiffel> ABSOLUTE</eiffel> ( <eiffel>DATE</eiffel>, <eiffel>TIME</eiffel>, <eiffel>DATE_TIME</eiffel>). The notions of interval is directly linked with the notion of order.
|
||||
|
||||
The <eiffel>start_bound</eiffel> must be before the <eiffel>end_bound</eiffel>.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|More precision]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|fadf5bc2-bb72-f681-b9c4-bab7f0633209]]
|
||||
<eiffel>TIME</eiffel> and <eiffel>TIME_DURATION</eiffel> are designed to deal with high precision in time. The only limit is the one from number representation.
|
||||
|
||||
The classes <eiffel>TIME</eiffel> and <eiffel>TIME_DURATION</eiffel> have an attribute <eiffel>fine_second</eiffel> (inherited from <eiffel>TIME_VALUE</eiffel>) which allows high precision. This attribute represents the number of seconds with fractions (it is an instance of <eiffel>DOUBLE</eiffel>). From this attribute are calculated second and fractional_second (which are functions): second is the truncated-to-integer part and fractional_second is the difference between the two previous one, so that the sum of second and fractional_second is always equal to fine_second (see invariant in <eiffel>TIME_VALUE</eiffel>).
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|EiffelTime Library]]
|
||||
[[Property:link_title|EiffelTime]]
|
||||
[[Property:weight|9]]
|
||||
[[Property:uuid|3d96626f-11f3-67a2-dec6-69f7faf4a8d6]]
|
||||
Type: Library <br/>
|
||||
Platform: Any <br/>
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
[[Property:link_title|Dates and times]]
|
||||
[[Property:weight|-13]]
|
||||
[[Property:uuid|082fd8e1-b531-6cf1-3409-9cd9bc6483ad]]
|
||||
* Date and time manipulation
|
||||
** EiffelTime
|
||||
*** EiffelTime tutorial http://ise181.ise/book/documentation/eiffeltime
|
||||
*** EiffelTime class reference
|
||||
== Date and time manipulation ==
|
||||
* [[EiffelTime Library|EiffelTime]]
|
||||
** [[EiffelTime|EiffelTime tutorial]]
|
||||
** EiffelTime class reference
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Create an object]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|b2ef8e81-a045-dce2-725f-c8db5ab1b6db]]
|
||||
An EiffelBuild [[EiffelBuild Notation|object]] is a representation of a Vision2 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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild: Starting a project]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|803e2034-dec3-340c-e68e-fdbaefac8a5a]]
|
||||
* [[EiffelBuild: Creating a new project|Creating a new project]]
|
||||
* [[Retrieving a project from a Build project file|Retrieving a project from a Build project file]]
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild How To's]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|1df547c8-ca5b-f014-5b4f-a39ecefaa746]]
|
||||
* [[EiffelBuild: Starting a project|Starting a project]]
|
||||
* [[Create an object|Create an object]]
|
||||
* [[Delete an object|Delete an object]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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'''
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild: General interface description]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|e16b365e-469e-e2ab-e955-7f4e81630fe3]]
|
||||
* [[EiffelBuild window overview|EiffelBuild window overview]]
|
||||
* [[Main toolbar|Main toolbars]]
|
||||
* [[EiffelBuild: Key shortcuts|Key shortcuts]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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':
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild Reference]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|15b53149-5a31-9a1a-e9ad-739174678064]]
|
||||
* [[EiffelBuild Introduction|EiffelBuild Introduction]]
|
||||
* [[EiffelBuild Notation|EiffelBuild Notation]]
|
||||
* [[EiffelBuild: General interface description|General interface description]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Type selector]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|893343c2-417f-90c5-147e-941bc232fe43]]
|
||||
The type selector contains all the available Vision2 types supported by EiffelBuild. These are the basic building blocks for your system.
|
||||
|
||||
[[Image:type-selector]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[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]]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild Version History]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|8cc0540e-8ee7-c005-0534-a2ed62f41c96]]
|
||||
==6.2 Release==
|
||||
|
||||
No changes.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelBuild]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|2af28db0-bc8f-daa6-daf2-18b08a11b606]]
|
||||
Type: Tool <br/>
|
||||
Platform: Any <br/>
|
||||
Version: 5.4 <br/>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Accelerator Sample]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|e3a8eac2-94c6-287a-314b-b4d056f9c1ad]]
|
||||
[[Image:accelerator|accelerator]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Cursor Sample]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|8a00cb23-d093-1b2f-9caf-213e570f96a9]]
|
||||
[[Image:cursor-test|cursor_test]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Gauges Sample]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|91aa8c8b-7cc9-06c1-a6f0-96844ff078d5]]
|
||||
[[Image:gauges|gauges]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelVision 2 Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|79c05bf8-367e-001d-0c13-f668e34fa5b0]]
|
||||
Vision2 ships with a number of samples provided to demonstrate different aspects of the library. If you are a new vision2 user then it is suggested that you first compile and run the [[Widgets Sample|Widgets]] sample. This will demonstrate both the appearance and behavior of the available widgets.
|
||||
|
||||
The other samples provided are listed below:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Standard_dialogs Sample]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|31d0608e-0136-b3db-0745-9e8697dcc60d]]
|
||||
[[Image:standard-dialogs|Standard_dialogs]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Viewport Sample]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|e8722685-0343-c411-83b1-32f0c4e0175b]]
|
||||
[[Image:viewport|viewport]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Widgets Sample]]
|
||||
[[Property:weight|-1]]
|
||||
[[Property:uuid|04aa62bd-ef9c-152c-5c69-4fe7e750649f]]
|
||||
[[Image:widgets|widgets]] <br/>
|
||||
<br/>
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelVision Introduction]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|f964651a-e36d-4e9e-00ea-37803a26373a]]
|
||||
The EiffelVision library offers an object-oriented framework for graphical user interface (GUI) development. Using EiffelVision, developers can access all necessary GUI components, called [[Widgets|widgets]] (buttons, windows, list views) as well as truly graphical elements such as points, lines, arcs, polygons and the like -- to develop a modern, functional and good-looking graphical interactive application.
|
||||
|
||||
EiffelVision has played a major role at Eiffel Software and provided numerous Eiffel projects with a powerful, portable graphics development platform. EiffelStudio is totally reliant on EiffelVision for its graphical elements and overall interaction with the user.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Events]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|fc32d1b5-72d6-2955-18fd-bce988ed8323]]
|
||||
This cluster contains classes for event handling within Vision2.
|
||||
|
||||
==What is an event?==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Figures]]
|
||||
[[Property:weight|7]]
|
||||
[[Property:uuid|c12fee6e-5e99-ae59-8ac5-f57abb4c1878]]
|
||||
The EiffelVision figure cluster can be considered a high-level way of drawing on an [[ref:libraries/vision2/reference/ev_drawable_chart|EV_DRAWABLE]] descendant. Here are some advantages:
|
||||
* The model is separated from the representation by using projectors that take a world of figures and project it to any device, not just a drawing area.
|
||||
* Instead of drawing with static API's like draw_line, real figure objects are used that can move, change color or morph.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|EiffelVision Interface Content]]
|
||||
[[Property:link_title|EiffelVision Library Reference Manual]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|b343b38b-c8b2-4247-072d-ecc1bc3e387a]]
|
||||
EiffelVision 2 is a platform independent Graphical User Interface (GUI) library that allows easy, simultaneous development of Windowed applications for both Windows & Unix based platforms. Heavily relying on EiffelBase library, EiffelVision 2 has been designed primarily with ease of use in mind. By reusing EiffelBase structures, existing, as well as new Eiffel users will find EiffelVision to be surprising intuitive and easy to use. In no time, users will be producing good-looking Windowed application skeletons, of which will run on a multitude of platforms with no manipulation of code.
|
||||
The EiffelVision 2 library includes the following interface clusters:
|
||||
* A [[Kernel| kernel]] cluster that includes classes that are key to a Vision2 application. The main class being [[ref:libraries/vision2/reference/ev_application_chart| EV_APPLICATION]] which is the main entry point of all Vision2 applications.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Items]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|3143511c-28bd-cc5c-c710-700796778982]]
|
||||
All Vision2 items inherit [[ref:libraries/vision2/reference/ev_item_chart|EV_ITEM]] .
|
||||
|
||||
==What is an item?==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Kernel]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|d830dc77-cd77-1f52-0e39-e0ec1cffa028]]
|
||||
The kernel cluster contains classes that provide functionality that are common to most Windowed application. These classes are considered the core, or kernel of any Vision2 application. The most important of these classes is [[ref:libraries/vision2/reference/ev_application_chart|EV_APPLICATION]] . This is used to initialize the graphical toolkit and event loop of your Vision2 application. Kernel also includes classes such as [[ref:libraries/vision2/reference/ev_timeout_chart| EV_TIMEOUT]] that calls procedures (via agents) at a set interval, and [[ref:libraries/vision2/reference/ev_color_chart| EV_COLOR]] which is used for coloring widgets and items. To start programming with Vision2, you first have to correctly initialize [[ref:libraries/vision2/reference/ev_application_chart|EV_APPLICATION]] .
|
||||
|
||||
==Launching your application with EV_APPLICATION - The heart of all Vision2 systems==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|EiffelVision Pick and Drop]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|309203de-6536-fe26-4f73-cb1f4a450e6f]]
|
||||
Pick and drop is a mechanism which allows data to be transported from a '''source''' object to a '''target'''. Any Vision2 object inheriting [[ref:libraries/vision2/reference/ev_pick_and_dropable_chart|EV_PICK_AND_DROPABLE]] can be used to transport or receive data.
|
||||
|
||||
==A simple pick and drop example==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Properties]]
|
||||
[[Property:weight|5]]
|
||||
[[Property:uuid|0d46c1eb-bce4-2d67-0272-da4aa5950c65]]
|
||||
This cluster contains all the common properties available for Vision2 [[Widgets|widgets]] and [[Items|items]] . Every Vision2 widget has the same set of properties inherited from EV_WIDGET, but many widgets also inherit additional properties, further refining the behavior of the widget.
|
||||
|
||||
EV_WIDGET inherits the following properties:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Support]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|fd72dc5e-32bd-55aa-0e2e-2c7af69c72fd]]
|
||||
The support cluster contains many classes providing useful facilities within the library. Many of the classes within this cluster are constant classes, which are filled with constant values for specific contexts, generally indicated by their names. The following constant classes are available within this cluster:
|
||||
* [[ref:libraries/vision2/reference/ev_dialog_constants_chart|EV_DIALOG_CONSTANTS]]
|
||||
* [[ref:libraries/vision2/reference/ev_drawable_constants_chart|EV_DRAWABLE_CONSTANTS]]
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user